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.223 by root, Sat Aug 11 11:07:08 2007 UTC vs.
Revision 1.296 by root, Mon Dec 21 23:52:34 2009 UTC

…		…
19		19
20	#ifdef _WIN32	20	#ifdef _WIN32
21	# undef pipe	21	# undef pipe
22	// microsoft vs. C	22	// microsoft vs. C
23	# define sqrtf(x) sqrt(x)	23	# define sqrtf(x) sqrt(x)
24	# define roundf(x) (int)(x)
25	# define atan2f(x,y) atan2(x,y)	24	# define atan2f(x,y) atan2(x,y)
26	# define M_PI 3.14159265f	25	# define M_PI 3.14159265f
27	#endif	26	#endif
28		27
29	#include <assert.h>	28	#include <assert.h>
…		…
39	#include <SDL_endian.h>	38	#include <SDL_endian.h>
40	#include <SDL_image.h>	39	#include <SDL_image.h>
41	#include <SDL_mixer.h>	40	#include <SDL_mixer.h>
42	#include <SDL_opengl.h>	41	#include <SDL_opengl.h>
43		42
		43	/* work around os x broken headers */
		44	#ifdef __MACOSX__
		45	typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
		46	#endif
		47
44	#define PANGO_ENABLE_BACKEND	48	#define PANGO_ENABLE_BACKEND
45	#define G_DISABLE_CAST_CHECKS	49	#define G_DISABLE_CAST_CHECKS
46		50
47	#include <glib/gmacros.h>	51	#include <glib/gmacros.h>
48		52
49	#include <pango/pango.h>	53	#include <pango/pango.h>
		54
		55	#ifndef PANGO_VERSION_CHECK
		56	# define PANGO_VERSION_CHECK(a,b,c) 0
		57	#endif
		58
		59	#if !PANGO_VERSION_CHECK (1, 15, 2)
		60	# define pango_layout_get_line_readonly pango_layout_get_line
		61	# define pango_layout_get_lines_readonly pango_layout_get_lines
		62	# define pango_layout_iter_get_line_readonly pango_layout_iter_get_line
		63	# define pango_layout_iter_get_run_readonly pango_layout_iter_get_run
		64	#endif
50		65
51	#ifndef _WIN32	66	#ifndef _WIN32
52	# include <sys/types.h>	67	# include <sys/types.h>
53	# include <sys/socket.h>	68	# include <sys/socket.h>
54	# include <netinet/in.h>	69	# include <netinet/in.h>
55	# include <netinet/tcp.h>	70	# include <netinet/tcp.h>
56	# include <inttypes.h>	71	# include <inttypes.h>
57	#endif	72	#endif
58		73
		74	#if __GNUC__ >= 4
		75	# define expect(expr,value) __builtin_expect ((expr),(value))
		76	#else
		77	# define expect(expr,value) (expr)
		78	#endif
		79
		80	#define expect_false(expr) expect ((expr) != 0, 0)
		81	#define expect_true(expr) expect ((expr) != 0, 1)
		82
59	#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */	83	#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
60		84
		85	/* this is used as fow flag as well, so has to have a different value */
		86	/* then anything that is computed by incoming darkness */
61	#define FOW_DARKNESS 32	87	#define FOW_DARKNESS 50
		88	#define DARKNESS_ADJUST(n) (n)
62		89
63	#define MAP_EXTEND_X 32	90	#define MAP_EXTEND_X 32
64	#define MAP_EXTEND_Y 512	91	#define MAP_EXTEND_Y 512
65		92
66	#define MIN_FONT_HEIGHT 10	93	#define MIN_FONT_HEIGHT 10
67		94
68	#if 0	95	/* mask out modifiers we are not interested in */
69	# define PARACHUTE SDL_INIT_NOPARACHUTE	96	#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
70	#else	97
71	# define PARACHUTE 0	98	#define KMOD_LRAM 0x10000 // our extension
72	#endif	99
		100	#define TEXID_SPEECH 1
		101	#define TEXID_NOFACE 2
		102	#define TEXID_HIDDEN 3
73		103
74	static AV *texture_av;	104	static AV *texture_av;
75		105
76	static struct	106	static struct
77	{	107	{
…		…
120		150
121	#include "pango-font.c"	151	#include "pango-font.c"
122	#include "pango-fontmap.c"	152	#include "pango-fontmap.c"
123	#include "pango-render.c"	153	#include "pango-render.c"
124		154
125	typedef IV CFPlus__Channel;	155	typedef IV DC__Channel;
126	typedef SDL_RWops *CFPlus__RW;	156	typedef SDL_RWops *DC__RW;
127	typedef Mix_Chunk *CFPlus__MixChunk;	157	typedef Mix_Chunk *DC__MixChunk;
128	typedef Mix_Music *CFPlus__MixMusic;	158	typedef Mix_Music *DC__MixMusic;
129		159
130	typedef PangoFontDescription *CFPlus__Font;	160	typedef PangoFontDescription *DC__Font;
131		161
132	static int	162	static int
133	shape_attr_p (PangoLayoutRun *run)	163	shape_attr_p (PangoLayoutRun *run)
134	{	164	{
135	GSList *attrs = run->item->analysis.extra_attrs;	165	GSList *attrs = run->item->analysis.extra_attrs;
…		…
149		179
150	typedef struct cf_layout {	180	typedef struct cf_layout {
151	PangoLayout *pl;	181	PangoLayout *pl;
152	float r, g, b, a; // default color for rgba mode	182	float r, g, b, a; // default color for rgba mode
153	int base_height;	183	int base_height;
154	CFPlus__Font font;	184	DC__Font font;
		185	rc_t *rc;
155	} *CFPlus__Layout;	186	} *DC__Layout;
156		187
157	static CFPlus__Font default_font;	188	static DC__Font default_font;
158	static PangoContext *opengl_context;	189	static PangoContext *opengl_context;
159	static PangoFontMap *opengl_fontmap;	190	static PangoFontMap *opengl_fontmap;
160		191
161	static void	192	static void
162	substitute_func (FcPattern *pattern, gpointer data)	193	substitute_func (FcPattern *pattern, gpointer data)
…		…
167	#endif	198	#endif
168	FcPatternAddBool (pattern, FC_AUTOHINT, 0);	199	FcPatternAddBool (pattern, FC_AUTOHINT, 0);
169	}	200	}
170		201
171	static void	202	static void
172	layout_update_font (CFPlus__Layout self)	203	layout_update_font (DC__Layout self)
173	{	204	{
174	/* use a random scale factor to account for unknown descenders, 0.8 works	205	/* use a random scale factor to account for unknown descenders, 0.8 works
175	* reasonably well with bitstream vera	206	* reasonably well with dejavu/bistream fonts
176	*/	207	*/
177	PangoFontDescription *font = self->font ? self->font : default_font;	208	PangoFontDescription *font = self->font ? self->font : default_font;
178		209
179	pango_font_description_set_absolute_size (font,	210	pango_font_description_set_absolute_size (font,
180	MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));	211	MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
181		212
182	pango_layout_set_font_description (self->pl, font);	213	pango_layout_set_font_description (self->pl, font);
183	}	214	}
184		215
185	static void	216	static void
186	layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)	217	layout_get_pixel_size (DC__Layout self, int *w, int *h)
187	{	218	{
188	PangoRectangle rect;	219	PangoRectangle rect;
189		220
190	// get_pixel_* wrongly rounds down	221	// get_pixel_* wrongly rounds down
191	pango_layout_get_extents (self->pl, 0, &rect);	222	pango_layout_get_extents (self->pl, 0, &rect);
…		…
202		233
203	typedef uint16_t tileid;	234	typedef uint16_t tileid;
204	typedef uint16_t faceid;	235	typedef uint16_t faceid;
205		236
206	typedef struct {	237	typedef struct {
207	int name;	238	GLuint name;
208	int w, h;	239	int w, h;
209	float s, t;	240	float s, t;
210	uint8_t r, g, b, a;	241	uint8_t r, g, b, a;
211	tileid smoothtile;	242	tileid smoothtile;
212	uint8_t smoothlevel;	243	uint8_t smoothlevel;
		244	uint8_t unused; /* set to zero on use */
213	} maptex;	245	} maptex;
214		246
215	typedef struct {	247	typedef struct {
216	uint32_t player;	248	uint32_t player;
217	tileid tile[3];	249	tileid tile[3];
…		…
230	int faces; tileid *face2tile; // [faceid]	262	int faces; tileid *face2tile; // [faceid]
231	int texs; maptex *tex; // [tileid]	263	int texs; maptex *tex; // [tileid]
232		264
233	int32_t rows;	265	int32_t rows;
234	maprow *row;	266	maprow *row;
235	} *CFPlus__Map;	267	} *DC__Map;
236		268
237	static char *	269	static char *
238	prepend (char *ptr, int sze, int inc)	270	prepend (char *ptr, int sze, int inc)
239	{	271	{
240	char *p;	272	char *p;
…		…
278	self->texs *= 2;	310	self->texs *= 2;
279	}	311	}
280	}	312	}
281		313
282	static maprow *	314	static maprow *
283	map_get_row (CFPlus__Map self, int y)	315	map_get_row (DC__Map self, int y)
284	{	316	{
285	if (0 > y)	317	if (0 > y)
286	{	318	{
287	int extend = - y + MAP_EXTEND_Y;	319	int extend = - y + MAP_EXTEND_Y;
288	Prepend (maprow, self->row, self->rows, extend);	320	Prepend (maprow, self->row, self->rows, extend);
…		…
326		358
327	return row->col + (x - row->c0);	359	return row->col + (x - row->c0);
328	}	360	}
329		361
330	static mapcell *	362	static mapcell *
331	map_get_cell (CFPlus__Map self, int x, int y)	363	map_get_cell (DC__Map self, int x, int y)
332	{	364	{
333	return row_get_cell (map_get_row (self, y), x);	365	return row_get_cell (map_get_row (self, y), x);
334	}	366	}
335		367
336	static void	368	static void
337	map_clear (CFPlus__Map self)	369	map_clear (DC__Map self)
338	{	370	{
339	int r;	371	int r;
340		372
341	for (r = 0; r < self->rows; r++)	373	for (r = 0; r < self->rows; r++)
342	Safefree (self->row[r].col);	374	Safefree (self->row[r].col);
…		…
349	self->oy = 0;	381	self->oy = 0;
350	self->row = 0;	382	self->row = 0;
351	self->rows = 0;	383	self->rows = 0;
352	}	384	}
353		385
		386	#define CELL_CLEAR(cell) \
		387	do { \
		388	if ((cell)->player) \
		389	(cell)->tile [2] = 0; \
		390	(cell)->darkness = 0; \
		391	(cell)->stat_hp = 0; \
		392	(cell)->flags = 0; \
		393	(cell)->player = 0; \
		394	} while (0)
		395
354	static void	396	static void
355	map_blank (CFPlus__Map self, int x0, int y0, int w, int h)	397	map_blank (DC__Map self, int x0, int y0, int w, int h)
356	{	398	{
357	int x, y;	399	int x, y;
358	maprow *row;	400	maprow *row;
359	mapcell *cell;	401	mapcell *cell;
360		402
…		…
372	if (x >= row->c1)	414	if (x >= row->c1)
373	break;	415	break;
374		416
375	cell = row->col + x - row->c0;	417	cell = row->col + x - row->c0;
376		418
377	cell->darkness = 0;	419	CELL_CLEAR (cell);
378	cell->stat_hp = 0;
379	cell->flags = 0;
380	cell->player = 0;
381	}	420	}
382	}	421	}
383	}	422	}
384		423
385	typedef struct {	424	typedef struct {
…		…
439	n |= n >> 16;	478	n |= n >> 16;
440		479
441	return n + 1;	480	return n + 1;
442	}	481	}
443		482
		483	static unsigned int
		484	popcount (unsigned int n)
		485	{
		486	n -= (n >> 1) & 0x55555555U;
		487	n = ((n >> 2) & 0x33333333U) + (n & 0x33333333U);
		488	n = ((n >> 4) + n) & 0x0f0f0f0fU;
		489	n *= 0x01010101U;
		490
		491	return n >> 24;
		492	}
		493
444	/* SDL should provide this, really. */	494	/* SDL should provide this, really. */
445	#define SDLK_MODIFIER_MIN 300	495	#define SDLK_MODIFIER_MIN 300
446	#define SDLK_MODIFIER_MAX 314	496	#define SDLK_MODIFIER_MAX 314
447		497
448	/******************************************************************************/	498	/******************************************************************************/
…		…
486	return 0;	536	return 0;
487		537
488	return 1;	538	return 1;
489	}	539	}
490		540
491	MODULE = CFPlus PACKAGE = CFPlus	541	/******************************************************************************/
		542
		543	/* process keyboard modifiers */
		544	static int
		545	mod_munge (int mod)
		546	{
		547	mod &= MOD_MASK;
		548
		549	if (mod & (KMOD_META | KMOD_ALT))
		550	mod |= KMOD_LRAM;
		551
		552	return mod;
		553	}
		554
		555	static void
		556	deliantra_main ()
		557	{
		558	char *argv[] = { 0 };
		559	call_argv ("::main", G_DISCARD | G_VOID, argv);
		560	}
		561
		562	#ifdef __MACOSX__
		563	/* to due surprising braindamage on the side of SDL design, we
		564	* do some mind-boggling hack here: SDL requires a custom main()
		565	* on OS X, so... we provide one and call the original main(), which,
		566	* due to share dlibrary magic, calls -lSDLmain's main, not perl's main,
		567	* and which calls our main (== SDL_main) back.
		568	*/
		569	extern C_LINKAGE int
		570	main (int argc, char *argv[])
		571	{
		572	deliantra_main ();
		573	}
		574
		575	#undef main
		576
		577	extern C_LINKAGE int main (int argc, char *argv[]);
		578
		579	static void
		580	SDL_braino (void)
		581	{
		582	char *argv[] = { "deliantra client", 0 };
		583	(main) (1, argv);
		584	}
		585	#else
		586	static void
		587	SDL_braino (void)
		588	{
		589	deliantra_main ();
		590	}
		591	#endif
		592
		593	MODULE = Deliantra::Client PACKAGE = DC
492		594
493	PROTOTYPES: ENABLE	595	PROTOTYPES: ENABLE
494		596
495	BOOT:	597	BOOT:
496	{	598	{
497	HV *stash = gv_stashpv ("CFPlus", 1);	599	HV *stash = gv_stashpv ("DC", 1);
498	static const struct {	600	static const struct {
499	const char *name;	601	const char *name;
500	IV iv;	602	IV iv;
501	} *civ, const_iv[] = {	603	} *civ, const_iv[] = {
502	# define const_iv(name) { # name, (IV)name }	604	# define const_iv(name) { # name, (IV)name }
…		…
524		626
525	const_iv (SDL_APPINPUTFOCUS),	627	const_iv (SDL_APPINPUTFOCUS),
526	const_iv (SDL_APPMOUSEFOCUS),	628	const_iv (SDL_APPMOUSEFOCUS),
527	const_iv (SDL_APPACTIVE),	629	const_iv (SDL_APPACTIVE),
528		630
		631
		632	const_iv (SDLK_UNKNOWN),
		633	const_iv (SDLK_FIRST),
		634	const_iv (SDLK_BACKSPACE),
		635	const_iv (SDLK_TAB),
		636	const_iv (SDLK_CLEAR),
		637	const_iv (SDLK_RETURN),
		638	const_iv (SDLK_PAUSE),
		639	const_iv (SDLK_ESCAPE),
		640	const_iv (SDLK_SPACE),
		641	const_iv (SDLK_EXCLAIM),
		642	const_iv (SDLK_QUOTEDBL),
		643	const_iv (SDLK_HASH),
		644	const_iv (SDLK_DOLLAR),
		645	const_iv (SDLK_AMPERSAND),
		646	const_iv (SDLK_QUOTE),
		647	const_iv (SDLK_LEFTPAREN),
		648	const_iv (SDLK_RIGHTPAREN),
		649	const_iv (SDLK_ASTERISK),
		650	const_iv (SDLK_PLUS),
		651	const_iv (SDLK_COMMA),
		652	const_iv (SDLK_MINUS),
		653	const_iv (SDLK_PERIOD),
		654	const_iv (SDLK_SLASH),
		655	const_iv (SDLK_0),
		656	const_iv (SDLK_1),
		657	const_iv (SDLK_2),
		658	const_iv (SDLK_3),
		659	const_iv (SDLK_4),
		660	const_iv (SDLK_5),
		661	const_iv (SDLK_6),
		662	const_iv (SDLK_7),
		663	const_iv (SDLK_8),
		664	const_iv (SDLK_9),
		665	const_iv (SDLK_COLON),
		666	const_iv (SDLK_SEMICOLON),
		667	const_iv (SDLK_LESS),
		668	const_iv (SDLK_EQUALS),
		669	const_iv (SDLK_GREATER),
		670	const_iv (SDLK_QUESTION),
		671	const_iv (SDLK_AT),
		672
		673	const_iv (SDLK_LEFTBRACKET),
		674	const_iv (SDLK_BACKSLASH),
		675	const_iv (SDLK_RIGHTBRACKET),
		676	const_iv (SDLK_CARET),
		677	const_iv (SDLK_UNDERSCORE),
		678	const_iv (SDLK_BACKQUOTE),
		679	const_iv (SDLK_DELETE),
		680
		681	const_iv (SDLK_FIRST),
		682	const_iv (SDLK_LAST),
529	const_iv (SDLK_KP0),	683	const_iv (SDLK_KP0),
530	const_iv (SDLK_KP1),	684	const_iv (SDLK_KP1),
531	const_iv (SDLK_KP2),	685	const_iv (SDLK_KP2),
532	const_iv (SDLK_KP3),	686	const_iv (SDLK_KP3),
533	const_iv (SDLK_KP4),	687	const_iv (SDLK_KP4),
…		…
605	const_iv (KMOD_LMETA),	759	const_iv (KMOD_LMETA),
606	const_iv (KMOD_RMETA),	760	const_iv (KMOD_RMETA),
607	const_iv (KMOD_NUM),	761	const_iv (KMOD_NUM),
608	const_iv (KMOD_CAPS),	762	const_iv (KMOD_CAPS),
609	const_iv (KMOD_MODE),	763	const_iv (KMOD_MODE),
		764
		765	const_iv (KMOD_LRAM),
		766
		767	const_iv (MIX_DEFAULT_FORMAT),
		768
		769	const_iv (SDL_INIT_TIMER),
		770	const_iv (SDL_INIT_AUDIO),
		771	const_iv (SDL_INIT_VIDEO),
		772	const_iv (SDL_INIT_CDROM),
		773	const_iv (SDL_INIT_JOYSTICK),
		774	const_iv (SDL_INIT_EVERYTHING),
		775	const_iv (SDL_INIT_NOPARACHUTE),
		776	const_iv (SDL_INIT_EVENTTHREAD),
		777
		778	const_iv (SDL_GL_RED_SIZE),
		779	const_iv (SDL_GL_GREEN_SIZE),
		780	const_iv (SDL_GL_BLUE_SIZE),
		781	const_iv (SDL_GL_ALPHA_SIZE),
		782	const_iv (SDL_GL_DOUBLEBUFFER),
		783	const_iv (SDL_GL_BUFFER_SIZE),
		784	const_iv (SDL_GL_DEPTH_SIZE),
		785	const_iv (SDL_GL_STENCIL_SIZE),
		786	const_iv (SDL_GL_ACCUM_RED_SIZE),
		787	const_iv (SDL_GL_ACCUM_GREEN_SIZE),
		788	const_iv (SDL_GL_ACCUM_BLUE_SIZE),
		789	const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
		790	const_iv (SDL_GL_STEREO),
		791	const_iv (SDL_GL_MULTISAMPLEBUFFERS),
		792	const_iv (SDL_GL_MULTISAMPLESAMPLES),
		793	const_iv (SDL_GL_ACCELERATED_VISUAL),
		794	const_iv (SDL_GL_SWAP_CONTROL),
		795
		796	const_iv (FOW_DARKNESS)
610	# undef const_iv	797	# undef const_iv
611	};	798	};
612		799
613	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	800	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
614	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	801	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
…		…
632		819
633	NV floor (NV x)	820	NV floor (NV x)
634		821
635	NV ceil (NV x)	822	NV ceil (NV x)
636		823
		824	IV minpot (UV n)
		825
		826	IV popcount (UV n)
		827
		828	NV distance (NV dx, NV dy)
		829	CODE:
		830	RETVAL = pow (dx * dx + dy * dy, 0.5);
		831	OUTPUT:
		832	RETVAL
		833
637	void	834	void
638	pango_init ()	835	pango_init ()
639	CODE:	836	CODE:
640	{	837	{
641	opengl_fontmap = pango_opengl_font_map_new ();	838	opengl_fontmap = pango_opengl_font_map_new ();
642	pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);	839	pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
643	opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);	840	opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
		841	/*pango_context_set_font_description (opengl_context, default_font);*/
		842	#if PANGO_VERSION_CHECK (1, 15, 2)
		843	pango_context_set_language (opengl_context, pango_language_from_string ("en"));
		844	/*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
		845	#endif
644	}	846	}
645		847
646	char *
647	SDL_GetError ()	848	char *SDL_GetError ()
648		849
649	int	850	void SDL_braino ()
650	SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
651		851
652	void	852	int SDL_Init (U32 flags)
		853
		854	int SDL_InitSubSystem (U32 flags)
		855
		856	void SDL_QuitSubSystem (U32 flags)
		857
653	SDL_Quit ()	858	void SDL_Quit ()
		859
		860	int SDL_GL_SetAttribute (int attr, int value)
		861
		862	int SDL_GL_GetAttribute (int attr)
		863	CODE:
		864	if (SDL_GL_GetAttribute (attr, &RETVAL))
		865	XSRETURN_UNDEF;
		866	OUTPUT:
		867	RETVAL
654		868
655	void	869	void
656	SDL_ListModes (int rgb, int alpha)	870	SDL_ListModes (int rgb, int alpha)
657	PPCODE:	871	PPCODE:
658	{	872	{
…		…
670	SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);	884	SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
671	SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);	885	SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
672	SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);	886	SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
673		887
674	SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);	888	SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
675	#if SDL_VERSION_ATLEAST(1,2,10)
676	SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
677	SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);	889	SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
678	#endif
679		890
680	m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);	891	m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
681		892
682	if (m && m != (SDL_Rect **)-1)	893	if (m && m != (SDL_Rect **)-1)
683	while (*m)	894	while (*m)
684	{	895	{
685	if ((*m)->w >= 640 && (*m)->h >= 480)	896	if ((*m)->w >= 400 && (*m)->h >= 300)
686	{	897	{
687	AV *av = newAV ();	898	AV *av = newAV ();
688	av_push (av, newSViv ((*m)->w));	899	av_push (av, newSViv ((*m)->w));
689	av_push (av, newSViv ((*m)->h));	900	av_push (av, newSViv ((*m)->h));
690	av_push (av, newSViv (rgb));	901	av_push (av, newSViv (rgb));
…		…
714		925
715	if (RETVAL)	926	if (RETVAL)
716	{	927	{
717	av_clear (texture_av);	928	av_clear (texture_av);
718		929
719	SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");	930	SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
720	#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);	931	#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
721	#include "glfunc.h"	932	#include "glfunc.h"
722	#undef GL_FUNC	933	#undef GL_FUNC
723	}	934	}
724	}	935	}
…		…
731	char *	942	char *
732	SDL_GetKeyName (int sym)	943	SDL_GetKeyName (int sym)
733		944
734	int	945	int
735	SDL_GetAppState ()	946	SDL_GetAppState ()
		947
		948	int
		949	SDL_GetModState ()
736		950
737	void	951	void
738	poll_events ()	952	poll_events ()
739	PPCODE:	953	PPCODE:
740	{	954	{
…		…
750	{	964	{
751	case SDL_KEYDOWN:	965	case SDL_KEYDOWN:
752	case SDL_KEYUP:	966	case SDL_KEYUP:
753	hv_store (hv, "state", 5, newSViv (ev.key.state), 0);	967	hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
754	hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);	968	hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
755	hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);	969	hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
756	hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */	970	hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
757	hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);	971	hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
758	break;	972	break;
759		973
760	case SDL_ACTIVEEVENT:	974	case SDL_ACTIVEEVENT:
761	hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);	975	hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
…		…
779	x = ev.motion.x;	993	x = ev.motion.x;
780	y = ev.motion.y;	994	y = ev.motion.y;
781	SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));	995	SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
782	}	996	}
783		997
784	hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);	998	hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
785	hv_store (hv, "state", 5, newSViv (state), 0);	999	hv_store (hv, "state", 5, newSViv (state), 0);
786	hv_store (hv, "x", 1, newSViv (x), 0);	1000	hv_store (hv, "x", 1, newSViv (x), 0);
787	hv_store (hv, "y", 1, newSViv (y), 0);	1001	hv_store (hv, "y", 1, newSViv (y), 0);
788	hv_store (hv, "xrel", 4, newSViv (xrel), 0);	1002	hv_store (hv, "xrel", 4, newSViv (xrel), 0);
789	hv_store (hv, "yrel", 4, newSViv (yrel), 0);	1003	hv_store (hv, "yrel", 4, newSViv (yrel), 0);
790	}	1004	}
791	break;	1005	break;
792		1006
793	case SDL_MOUSEBUTTONDOWN:	1007	case SDL_MOUSEBUTTONDOWN:
794	case SDL_MOUSEBUTTONUP:	1008	case SDL_MOUSEBUTTONUP:
795	hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);	1009	hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);
796		1010
797	hv_store (hv, "button", 6, newSViv (ev.button.button), 0);	1011	hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
798	hv_store (hv, "state", 5, newSViv (ev.button.state), 0);	1012	hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
799	hv_store (hv, "x", 1, newSViv (ev.button.x), 0);	1013	hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
800	hv_store (hv, "y", 1, newSViv (ev.button.y), 0);	1014	hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
…		…
805	hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);	1019	hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
806	hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);	1020	hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
807	break;	1021	break;
808	}	1022	}
809		1023
810	XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1))));	1024	XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
811	}	1025	}
812	}	1026	}
813		1027
814	int	1028	int
815	Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 1024)	1029	Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
816	POSTCALL:	1030	POSTCALL:
817	Mix_HookMusicFinished (music_finished);	1031	Mix_HookMusicFinished (music_finished);
818	Mix_ChannelFinished (channel_finished);	1032	Mix_ChannelFinished (channel_finished);
		1033
		1034	void
		1035	Mix_QuerySpec ()
		1036	PPCODE:
		1037	{
		1038	int freq, channels;
		1039	Uint16 format;
		1040
		1041	if (Mix_QuerySpec (&freq, &format, &channels))
		1042	{
		1043	EXTEND (SP, 3);
		1044	PUSHs (sv_2mortal (newSViv (freq)));
		1045	PUSHs (sv_2mortal (newSViv (format)));
		1046	PUSHs (sv_2mortal (newSViv (channels)));
		1047	}
		1048	}
819		1049
820	void	1050	void
821	Mix_CloseAudio ()	1051	Mix_CloseAudio ()
822		1052
823	int	1053	int
…		…
858	}	1088	}
859	}	1089	}
860	#endif	1090	#endif
861	}	1091	}
862		1092
863	void	1093	int
864	add_font (char *file)	1094	add_font (char *file)
865	CODE:	1095	CODE:
866	FcConfigAppFontAddFile (0, (const FcChar8 *)file);	1096	RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
		1097	OUTPUT:
		1098	RETVAL
867		1099
868	void	1100	void
869	load_image_inline (SV *image_)	1101	load_image_inline (SV *image_)
870	ALIAS:	1102	ALIAS:
871	load_image_file = 1	1103	load_image_file = 1
…		…
957	void	1189	void
958	error (char *message)	1190	error (char *message)
959	CODE:	1191	CODE:
960	fprintf (stderr, "ERROR: %s\n", message);	1192	fprintf (stderr, "ERROR: %s\n", message);
961	#ifdef _WIN32	1193	#ifdef _WIN32
962	MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR);	1194	MessageBox (0, message, "Deliantra Client Error", MB_OK | MB_ICONERROR);
963	#endif	1195	#endif
964		1196
965	void	1197	void
966	fatal (char *message)	1198	fatal (char *message)
967	CODE:	1199	CODE:
968	fprintf (stderr, "FATAL: %s\n", message);	1200	fprintf (stderr, "FATAL: %s\n", message);
969	#ifdef _WIN32	1201	#ifdef _WIN32
970	MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR);	1202	MessageBox (0, message, "Deliantra Client Fatal Error", MB_OK | MB_ICONERROR);
971	#endif	1203	#endif
972	_exit (1);	1204	_exit (1);
973		1205
974	void	1206	void
975	_exit (int retval = 0)	1207	_exit (int retval = 0)
…		…
987	#if DEBUG	1219	#if DEBUG
988	VALGRIND_DO_LEAK_CHECK;	1220	VALGRIND_DO_LEAK_CHECK;
989	#endif	1221	#endif
990	}	1222	}
991		1223
992	MODULE = CFPlus PACKAGE = CFPlus::Font	1224	int
		1225	SvREFCNT (SV *sv)
		1226	CODE:
		1227	RETVAL = SvREFCNT (sv);
		1228	OUTPUT:
		1229	RETVAL
		1230
		1231	MODULE = Deliantra::Client PACKAGE = DC::Font
993		1232
994	PROTOTYPES: DISABLE	1233	PROTOTYPES: DISABLE
995		1234
996	CFPlus::Font	1235	DC::Font
997	new_from_file (SV *class, char *path, int id = 0)	1236	new_from_file (SV *class, char *path, int id = 0)
998	CODE:	1237	CODE:
999	{	1238	{
1000	int count;	1239	int count;
1001	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);	1240	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
…		…
1004	}	1243	}
1005	OUTPUT:	1244	OUTPUT:
1006	RETVAL	1245	RETVAL
1007		1246
1008	void	1247	void
1009	DESTROY (CFPlus::Font self)	1248	DESTROY (DC::Font self)
1010	CODE:	1249	CODE:
1011	pango_font_description_free (self);	1250	pango_font_description_free (self);
1012		1251
1013	void	1252	void
1014	make_default (CFPlus::Font self)	1253	make_default (DC::Font self)
1015	PROTOTYPE: $	1254	PROTOTYPE: $
1016	CODE:	1255	CODE:
1017	default_font = self;	1256	default_font = self;
1018		1257
1019	MODULE = CFPlus PACKAGE = CFPlus::Layout	1258	MODULE = Deliantra::Client PACKAGE = DC::Layout
1020		1259
1021	PROTOTYPES: DISABLE	1260	PROTOTYPES: DISABLE
1022		1261
1023	void	1262	void
1024	reset_glyph_cache ()	1263	glyph_cache_backup ()
1025	PROTOTYPE:	1264	PROTOTYPE:
1026	CODE:	1265	CODE:
		1266	tc_backup ();
		1267
		1268	void
		1269	glyph_cache_restore ()
		1270	PROTOTYPE:
		1271	CODE:
1027	tc_clear ();	1272	tc_restore ();
1028		1273
1029	CFPlus::Layout	1274	DC::Layout
1030	new (SV *class)	1275	new (SV *class)
1031	CODE:	1276	CODE:
1032	New (0, RETVAL, 1, struct cf_layout);	1277	New (0, RETVAL, 1, struct cf_layout);
1033		1278
1034	RETVAL->pl = pango_layout_new (opengl_context);	1279	RETVAL->pl = pango_layout_new (opengl_context);
…		…
1036	RETVAL->g = 1.;	1281	RETVAL->g = 1.;
1037	RETVAL->b = 1.;	1282	RETVAL->b = 1.;
1038	RETVAL->a = 1.;	1283	RETVAL->a = 1.;
1039	RETVAL->base_height = MIN_FONT_HEIGHT;	1284	RETVAL->base_height = MIN_FONT_HEIGHT;
1040	RETVAL->font = 0;	1285	RETVAL->font = 0;
		1286	RETVAL->rc = rc_alloc ();
1041		1287
1042	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);	1288	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1043	layout_update_font (RETVAL);	1289	layout_update_font (RETVAL);
1044	OUTPUT:	1290	OUTPUT:
1045	RETVAL	1291	RETVAL
1046		1292
1047	void	1293	void
1048	DESTROY (CFPlus::Layout self)	1294	DESTROY (DC::Layout self)
1049	CODE:	1295	CODE:
1050	g_object_unref (self->pl);	1296	g_object_unref (self->pl);
		1297	rc_free (self->rc);
1051	Safefree (self);	1298	Safefree (self);
1052		1299
1053	void	1300	void
1054	set_text (CFPlus::Layout self, SV *text_)	1301	set_text (DC::Layout self, SV *text_)
1055	CODE:	1302	CODE:
1056	{	1303	{
1057	STRLEN textlen;	1304	STRLEN textlen;
1058	char *text = SvPVutf8 (text_, textlen);	1305	char *text = SvPVutf8 (text_, textlen);
1059		1306
1060	pango_layout_set_text (self->pl, text, textlen);	1307	pango_layout_set_text (self->pl, text, textlen);
1061	}	1308	}
1062		1309
1063	void	1310	void
1064	set_markup (CFPlus::Layout self, SV *text_)	1311	set_markup (DC::Layout self, SV *text_)
1065	CODE:	1312	CODE:
1066	{	1313	{
1067	STRLEN textlen;	1314	STRLEN textlen;
1068	char *text = SvPVutf8 (text_, textlen);	1315	char *text = SvPVutf8 (text_, textlen);
1069		1316
1070	pango_layout_set_markup (self->pl, text, textlen);	1317	pango_layout_set_markup (self->pl, text, textlen);
1071	}	1318	}
1072		1319
1073	void	1320	void
1074	set_shapes (CFPlus::Layout self, ...)	1321	set_shapes (DC::Layout self, ...)
1075	CODE:	1322	CODE:
1076	{	1323	{
1077	PangoAttrList *attrs = 0;	1324	PangoAttrList *attrs = 0;
1078	const char *text = pango_layout_get_text (self->pl);	1325	const char *text = pango_layout_get_text (self->pl);
1079	const char *pos = text;	1326	const char *pos = text;
…		…
1114	if (attrs)	1361	if (attrs)
1115	pango_layout_set_attributes (self->pl, attrs);	1362	pango_layout_set_attributes (self->pl, attrs);
1116	}	1363	}
1117		1364
1118	void	1365	void
1119	get_shapes (CFPlus::Layout self)	1366	get_shapes (DC::Layout self)
1120	PPCODE:	1367	PPCODE:
1121	{	1368	{
1122	PangoLayoutIter *iter = pango_layout_get_iter (self->pl);	1369	PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
1123		1370
1124	do	1371	do
1125	{	1372	{
1126	PangoLayoutRun *run = pango_layout_iter_get_run (iter);	1373	PangoLayoutRun *run = pango_layout_iter_get_run_readonly (iter);
1127		1374
1128	if (run && shape_attr_p (run))	1375	if (run && shape_attr_p (run))
1129	{	1376	{
1130	PangoRectangle extents;	1377	PangoRectangle extents;
1131	pango_layout_iter_get_run_extents (iter, 0, &extents);	1378	pango_layout_iter_get_run_extents (iter, 0, &extents);
…		…
1139		1386
1140	pango_layout_iter_free (iter);	1387	pango_layout_iter_free (iter);
1141	}	1388	}
1142		1389
1143	int	1390	int
1144	has_wrapped (CFPlus::Layout self)	1391	has_wrapped (DC::Layout self)
1145	CODE:	1392	CODE:
1146	{	1393	{
1147	int lines = 1;	1394	int lines = 1;
1148	const char *text = pango_layout_get_text (self->pl);	1395	const char *text = pango_layout_get_text (self->pl);
1149		1396
…		…
1154	}	1401	}
1155	OUTPUT:	1402	OUTPUT:
1156	RETVAL	1403	RETVAL
1157		1404
1158	SV *	1405	SV *
1159	get_text (CFPlus::Layout self)	1406	get_text (DC::Layout self)
1160	CODE:	1407	CODE:
1161	RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);	1408	RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
1162	sv_utf8_decode (RETVAL);	1409	sv_utf8_decode (RETVAL);
1163	OUTPUT:	1410	OUTPUT:
1164	RETVAL	1411	RETVAL
1165		1412
1166	void	1413	void
1167	set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.)	1414	set_foreground (DC::Layout self, float r, float g, float b, float a = 1.)
1168	CODE:	1415	CODE:
1169	self->r = r;	1416	self->r = r;
1170	self->g = g;	1417	self->g = g;
1171	self->b = b;	1418	self->b = b;
1172	self->a = a;	1419	self->a = a;
1173		1420
1174	void	1421	void
1175	set_font (CFPlus::Layout self, CFPlus::Font font = 0)	1422	set_font (DC::Layout self, DC::Font font = 0)
1176	CODE:	1423	CODE:
1177	if (self->font != font)	1424	if (self->font != font)
1178	{	1425	{
1179	self->font = font;	1426	self->font = font;
1180	layout_update_font (self);	1427	layout_update_font (self);
1181	}	1428	}
1182		1429
1183	void	1430	void
1184	set_height (CFPlus::Layout self, int base_height)	1431	set_height (DC::Layout self, int base_height)
1185	CODE:	1432	CODE:
1186	if (self->base_height != base_height)	1433	if (self->base_height != base_height)
1187	{	1434	{
1188	self->base_height = base_height;	1435	self->base_height = base_height;
1189	layout_update_font (self);	1436	layout_update_font (self);
1190	}	1437	}
1191		1438
1192	void	1439	void
1193	set_width (CFPlus::Layout self, int max_width = -1)	1440	set_width (DC::Layout self, int max_width = -1)
1194	CODE:	1441	CODE:
1195	pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);	1442	pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
1196		1443
1197	void	1444	void
1198	set_indent (CFPlus::Layout self, int indent)	1445	set_indent (DC::Layout self, int indent)
1199	CODE:	1446	CODE:
1200	pango_layout_set_indent (self->pl, indent * PANGO_SCALE);	1447	pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1201		1448
1202	void	1449	void
1203	set_spacing (CFPlus::Layout self, int spacing)	1450	set_spacing (DC::Layout self, int spacing)
1204	CODE:	1451	CODE:
1205	pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);	1452	pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1206		1453
1207	void	1454	void
1208	set_ellipsise (CFPlus::Layout self, int ellipsise)	1455	set_ellipsise (DC::Layout self, int ellipsise)
1209	CODE:	1456	CODE:
1210	pango_layout_set_ellipsize (self->pl,	1457	pango_layout_set_ellipsize (self->pl,
1211	ellipsise == 1 ? PANGO_ELLIPSIZE_START	1458	ellipsise == 1 ? PANGO_ELLIPSIZE_START
1212	: ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE	1459	: ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1213	: ellipsise == 3 ? PANGO_ELLIPSIZE_END	1460	: ellipsise == 3 ? PANGO_ELLIPSIZE_END
1214	: PANGO_ELLIPSIZE_NONE	1461	: PANGO_ELLIPSIZE_NONE
1215	);	1462	);
1216		1463
1217	void	1464	void
1218	set_single_paragraph_mode (CFPlus::Layout self, int spm)	1465	set_single_paragraph_mode (DC::Layout self, int spm)
1219	CODE:	1466	CODE:
1220	pango_layout_set_single_paragraph_mode (self->pl, !!spm);	1467	pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1221		1468
1222	void	1469	void
1223	size (CFPlus::Layout self)	1470	size (DC::Layout self)
1224	PPCODE:	1471	PPCODE:
1225	{	1472	{
1226	int w, h;	1473	int w, h;
1227		1474
1228	layout_get_pixel_size (self, &w, &h);	1475	layout_get_pixel_size (self, &w, &h);
…		…
1231	PUSHs (sv_2mortal (newSViv (w)));	1478	PUSHs (sv_2mortal (newSViv (w)));
1232	PUSHs (sv_2mortal (newSViv (h)));	1479	PUSHs (sv_2mortal (newSViv (h)));
1233	}	1480	}
1234		1481
1235	int	1482	int
1236	descent (CFPlus::Layout self)	1483	descent (DC::Layout self)
1237	CODE:	1484	CODE:
1238	{	1485	{
1239	PangoRectangle rect;	1486	PangoRectangle rect;
1240	PangoLayoutLine *line = pango_layout_get_line (self->pl, 0);	1487	PangoLayoutLine *line = pango_layout_get_line_readonly (self->pl, 0);
1241	pango_layout_line_get_pixel_extents (line, 0, &rect);	1488	pango_layout_line_get_pixel_extents (line, 0, &rect);
1242	RETVAL = PANGO_DESCENT (rect);	1489	RETVAL = PANGO_DESCENT (rect);
1243	}	1490	}
1244	OUTPUT:	1491	OUTPUT:
1245	RETVAL	1492	RETVAL
1246		1493
1247	int	1494	int
1248	xy_to_index (CFPlus::Layout self, int x, int y)	1495	xy_to_index (DC::Layout self, int x, int y)
1249	CODE:	1496	CODE:
1250	{	1497	{
1251	int index, trailing;	1498	int index, trailing;
1252	pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);	1499	pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1253	RETVAL = index + trailing;	1500	RETVAL = index + trailing;
1254	}	1501	}
1255	OUTPUT:	1502	OUTPUT:
1256	RETVAL	1503	RETVAL
1257		1504
1258	void	1505	void
1259	cursor_pos (CFPlus::Layout self, int index)	1506	cursor_pos (DC::Layout self, int index)
1260	PPCODE:	1507	PPCODE:
1261	{	1508	{
1262	PangoRectangle strong_pos;	1509	PangoRectangle pos;
1263	pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);	1510	pango_layout_get_cursor_pos (self->pl, index, &pos, 0);
1264		1511
1265	EXTEND (SP, 3);	1512	EXTEND (SP, 3);
1266	PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));	1513	PUSHs (sv_2mortal (newSViv (pos.x / PANGO_SCALE)));
1267	PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));	1514	PUSHs (sv_2mortal (newSViv (pos.y / PANGO_SCALE)));
1268	PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));	1515	PUSHs (sv_2mortal (newSViv (pos.height / PANGO_SCALE)));
1269	}	1516	}
1270		1517
1271	void	1518	void
1272	index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)	1519	index_to_line_x (DC::Layout self, int index, int trailing = 0)
1273	PPCODE:	1520	PPCODE:
1274	{	1521	{
1275	int line, x;	1522	int line, x;
1276		1523
1277	pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);	1524	pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
		1525	#if !PANGO_VERSION_CHECK (1, 17, 3)
1278	/* pango bug: line is between 1..numlines, not 0..numlines-1 */	1526	/* pango bug: line is between 1..numlines, not 0..numlines-1 */
1279		1527	--line;
		1528	#endif
1280	EXTEND (SP, 2);	1529	EXTEND (SP, 2);
1281	PUSHs (sv_2mortal (newSViv (line - 1)));	1530	PUSHs (sv_2mortal (newSViv (line)));
1282	PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));	1531	PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1283	}	1532	}
1284		1533
1285	void	1534	void
1286	line_x_to_index (CFPlus::Layout self, int line, int x)	1535	line_x_to_index (DC::Layout self, int line, int x)
1287	PPCODE:	1536	PPCODE:
1288	{	1537	{
1289	PangoLayoutLine *lp;	1538	PangoLayoutLine *lp;
1290	int index, trailing;	1539	int index, trailing;
1291		1540
1292	if (line < 0)	1541	if (line < 0)
1293	XSRETURN_EMPTY;	1542	XSRETURN_EMPTY;
1294		1543
1295	if (!(lp = pango_layout_get_line (self->pl, line)))	1544	if (!(lp = pango_layout_get_line_readonly (self->pl, line)))
1296	XSRETURN_EMPTY; /* do better */	1545	XSRETURN_EMPTY; /* do better */
1297		1546
1298	pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);	1547	pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1299		1548
1300	EXTEND (SP, 2);	1549	EXTEND (SP, 2);
…		…
1306	PUSHs (sv_2mortal (newSViv (trailing)));	1555	PUSHs (sv_2mortal (newSViv (trailing)));
1307	}	1556	}
1308	}	1557	}
1309		1558
1310	void	1559	void
1311	render (CFPlus::Layout self, float x, float y, int flags = 0)	1560	render (DC::Layout self, float x, float y, int flags = 0)
1312	PPCODE:	1561	CODE:
		1562	rc_clear (self->rc);
1313	pango_opengl_render_layout_subpixel (	1563	pango_opengl_render_layout_subpixel (
1314	self->pl,	1564	self->pl,
		1565	self->rc,
1315	x * PANGO_SCALE, y * PANGO_SCALE,	1566	x * PANGO_SCALE, y * PANGO_SCALE,
1316	self->r, self->g, self->b, self->a,	1567	self->r, self->g, self->b, self->a,
1317	flags	1568	flags
1318	);	1569	);
		1570	// we assume that context_change actually clears/frees stuff
		1571	// and does not do any recomputation...
		1572	pango_layout_context_changed (self->pl);
1319		1573
1320	MODULE = CFPlus PACKAGE = CFPlus::Texture	1574	void
		1575	draw (DC::Layout self)
		1576	CODE:
		1577	{
		1578	glEnable (GL_TEXTURE_2D);
		1579	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		1580	glEnable (GL_BLEND);
		1581	gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
		1582	GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
		1583	glEnable (GL_ALPHA_TEST);
		1584	glAlphaFunc (GL_GREATER, 7.f / 255.f);
		1585
		1586	rc_draw (self->rc);
		1587
		1588	glDisable (GL_ALPHA_TEST);
		1589	glDisable (GL_BLEND);
		1590	glDisable (GL_TEXTURE_2D);
		1591	}
		1592
		1593	MODULE = Deliantra::Client PACKAGE = DC::Texture
1321		1594
1322	PROTOTYPES: ENABLE	1595	PROTOTYPES: ENABLE
1323
1324	int minpot (int n)
1325		1596
1326	void	1597	void
1327	pad (SV *data_, int ow, int oh, int nw, int nh)	1598	pad (SV *data_, int ow, int oh, int nw, int nh)
1328	CODE:	1599	CODE:
1329	{	1600	{
…		…
1395	glDisable (GL_ALPHA_TEST);	1666	glDisable (GL_ALPHA_TEST);
1396	glDisable (GL_BLEND);	1667	glDisable (GL_BLEND);
1397	}	1668	}
1398	}	1669	}
1399		1670
		1671	void
		1672	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)
		1673	PROTOTYPE: @
		1674	CODE:
		1675	{
		1676	glEnable (GL_TEXTURE_2D);
		1677	glEnable (GL_BLEND);
		1678	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
		1679	glBindTexture (GL_TEXTURE_2D, name1);
		1680
		1681	glColor3f (intensity, intensity, intensity);
		1682	glPushMatrix ();
		1683	glScalef (1./3, 1./3, 1.);
		1684
		1685	if (blend > 0.f)
		1686	{
		1687	float dx3 = dx * -3.f / w;
		1688	float dy3 = dy * -3.f / h;
		1689	GLfloat env_color[4] = { 0., 0., 0., blend };
		1690
		1691	/* interpolate the two shadow textures */
		1692	/* stage 0 == rgb(glcolor) + alpha(t0) */
		1693	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
		1694
		1695	/* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
		1696	gl.ActiveTexture (GL_TEXTURE1);
		1697	glEnable (GL_TEXTURE_2D);
		1698	glBindTexture (GL_TEXTURE_2D, name2);
		1699	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
		1700
		1701	/* rgb == rgb(glcolor) */
		1702	glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
		1703	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);
		1704	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
		1705
		1706	/* alpha = interpolate t0, t1 by env_alpha */
		1707	glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
		1708
		1709	glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
		1710	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
		1711	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
		1712
		1713	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
		1714	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
		1715
		1716	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
		1717	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
		1718
		1719	glBegin (GL_QUADS);
		1720	gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
		1721	gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
		1722	gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
		1723	gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
		1724	glEnd ();
		1725
		1726	glDisable (GL_TEXTURE_2D);
		1727	gl.ActiveTexture (GL_TEXTURE0);
		1728	}
		1729	else
		1730	{
		1731	/* simple blending of one texture, also opengl <1.3 path */
		1732	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
		1733
		1734	glBegin (GL_QUADS);
		1735	glTexCoord2f (0, 0); glVertex2f (0, 0);
		1736	glTexCoord2f (0, t); glVertex2f (0, h);
		1737	glTexCoord2f (s, t); glVertex2f (w, h);
		1738	glTexCoord2f (s, 0); glVertex2f (w, 0);
		1739	glEnd ();
		1740	}
		1741
		1742	/* draw ?-marks or equivalent, this is very clumsy code :/ */
		1743	{
		1744	int x, y;
		1745	int dx3 = dx * 3;
		1746	int dy3 = dy * 3;
		1747
		1748	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		1749	glBindTexture (GL_TEXTURE_2D, hidden_tex);
		1750	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		1751	glTranslatef (-1., -1., 0);
		1752	glBegin (GL_QUADS);
		1753
		1754	for (y = 1; y < h; y += 3)
		1755	{
		1756	int y1 = y - dy3;
		1757	int y1valid = y1 >= 0 && y1 < h;
		1758
		1759	for (x = 1; x < w; x += 3)
		1760	{
		1761	int x1 = x - dx3;
		1762	uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
		1763	uint8_t h2;
		1764
		1765	if (y1valid && x1 >= 0 && x1 < w)
		1766	h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
		1767	else
		1768	h2 = 1; /* out of range == invisible */
		1769
		1770	if (h1 || h2)
		1771	{
		1772	float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
		1773	glColor4f (1., 1., 1., alpha);
		1774
		1775	glTexCoord2f (0, 0.); glVertex2i (x , y );
		1776	glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
		1777	glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
		1778	glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
		1779	}
		1780	}
		1781	}
		1782	}
		1783
		1784	glEnd ();
		1785
		1786	glPopMatrix ();
		1787
		1788	glDisable (GL_TEXTURE_2D);
		1789	glDisable (GL_BLEND);
		1790	}
		1791
1400	IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)	1792	IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1401	CODE:	1793	CODE:
1402	{	1794	{
1403	GLint width;	1795	GLint width;
1404	glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);	1796	glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
…		…
1406	RETVAL = width > 0;	1798	RETVAL = width > 0;
1407	}	1799	}
1408	OUTPUT:	1800	OUTPUT:
1409	RETVAL	1801	RETVAL
1410		1802
1411	MODULE = CFPlus PACKAGE = CFPlus::Map	1803	MODULE = Deliantra::Client PACKAGE = DC::Map
1412		1804
1413	PROTOTYPES: DISABLE	1805	PROTOTYPES: DISABLE
1414		1806
1415	CFPlus::Map	1807	DC::Map
1416	new (SV *class)	1808	new (SV *class)
1417	CODE:	1809	CODE:
1418	New (0, RETVAL, 1, struct map);	1810	New (0, RETVAL, 1, struct map);
1419	RETVAL->x = 0;	1811	RETVAL->x = 0;
1420	RETVAL->y = 0;	1812	RETVAL->y = 0;
…		…
1428	RETVAL->row = 0;	1820	RETVAL->row = 0;
1429	OUTPUT:	1821	OUTPUT:
1430	RETVAL	1822	RETVAL
1431		1823
1432	void	1824	void
1433	DESTROY (CFPlus::Map self)	1825	DESTROY (DC::Map self)
1434	CODE:	1826	CODE:
1435	{	1827	{
1436	map_clear (self);	1828	map_clear (self);
1437	Safefree (self->face2tile);	1829	Safefree (self->face2tile);
1438	Safefree (self->tex);	1830	Safefree (self->tex);
1439	Safefree (self);	1831	Safefree (self);
1440	}	1832	}
1441		1833
1442	void	1834	void
1443	resize (CFPlus::Map self, int map_width, int map_height)	1835	resize (DC::Map self, int map_width, int map_height)
1444	CODE:	1836	CODE:
1445	self->w = map_width;	1837	self->w = map_width;
1446	self->h = map_height;	1838	self->h = map_height;
1447		1839
1448	void	1840	void
1449	clear (CFPlus::Map self)	1841	clear (DC::Map self)
1450	CODE:	1842	CODE:
1451	map_clear (self);	1843	map_clear (self);
1452		1844
1453	void	1845	void
1454	set_tileid (CFPlus::Map self, int face, int tile)	1846	set_tileid (DC::Map self, int face, int tile)
1455	CODE:	1847	CODE:
1456	{	1848	{
1457	need_facenum (self, face); self->face2tile [face] = tile;	1849	need_facenum (self, face); self->face2tile [face] = tile;
1458	need_texid (self, tile);	1850	need_texid (self, tile);
1459	}	1851	}
1460		1852
1461	void	1853	void
1462	set_smooth (CFPlus::Map self, int face, int smooth, int level)	1854	set_smooth (DC::Map self, int face, int smooth, int level)
1463	CODE:	1855	CODE:
1464	{	1856	{
1465	tileid texid;	1857	tileid texid;
1466	maptex *tex;	1858	maptex *tex;
1467		1859
…		…
1480	tex->smoothtile = self->face2tile [smooth];	1872	tex->smoothtile = self->face2tile [smooth];
1481	tex->smoothlevel = level;	1873	tex->smoothlevel = level;
1482	}	1874	}
1483		1875
1484	void	1876	void
1485	set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)	1877	set_texture (DC::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1486	CODE:	1878	CODE:
1487	{	1879	{
1488	need_texid (self, texid);	1880	need_texid (self, texid);
1489		1881
1490	{	1882	{
…		…
1509	// use uglier nearest interpolation because linear suffers	1901	// use uglier nearest interpolation because linear suffers
1510	// from transparent color bleeding and ugly wrapping effects.	1902	// from transparent color bleeding and ugly wrapping effects.
1511	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	1903	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1512	}	1904	}
1513		1905
		1906	void
		1907	expire_textures (DC::Map self, int texid, int count)
		1908	PPCODE:
		1909	for (; texid < self->texs && count; ++texid, --count)
		1910	{
		1911	maptex *tex = self->tex + texid;
		1912
		1913	if (tex->name)
		1914	{
		1915	if (tex->unused)
		1916	{
		1917	tex->name = 0;
		1918	tex->unused = 0;
		1919	XPUSHs (sv_2mortal (newSViv (texid)));
		1920	}
		1921	else
		1922	tex->unused = 1;
		1923	}
		1924	}
		1925
1514	int	1926	int
1515	ox (CFPlus::Map self)	1927	ox (DC::Map self)
1516	ALIAS:	1928	ALIAS:
1517	oy = 1	1929	oy = 1
1518	x = 2	1930	x = 2
1519	y = 3	1931	y = 3
1520	w = 4	1932	w = 4
…		…
1531	}	1943	}
1532	OUTPUT:	1944	OUTPUT:
1533	RETVAL	1945	RETVAL
1534		1946
1535	void	1947	void
1536	scroll (CFPlus::Map self, int dx, int dy)	1948	scroll (DC::Map self, int dx, int dy)
1537	CODE:	1949	CODE:
1538	{	1950	{
1539	if (dx > 0)	1951	if (dx > 0)
1540	map_blank (self, self->x, self->y, dx, self->h);	1952	map_blank (self, self->x, self->y, dx, self->h);
1541	else if (dx < 0)	1953	else if (dx < 0)
…		…
1557	self->y += MAP_EXTEND_Y;	1969	self->y += MAP_EXTEND_Y;
1558	}	1970	}
1559	}	1971	}
1560		1972
1561	SV *	1973	SV *
1562	map1a_update (CFPlus::Map self, SV *data_, int extmap)	1974	map1a_update (DC::Map self, SV *data_, int extmap)
1563	CODE:	1975	CODE:
1564	{	1976	{
1565	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);	1977	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1566	uint8_t *data_end = (uint8_t *)SvEND (data_);	1978	uint8_t *data_end = (uint8_t *)SvEND (data_);
1567	mapcell *cell;	1979	mapcell *cell;
…		…
1595	uint8_t ext, cmd;	2007	uint8_t ext, cmd;
1596		2008
1597	do	2009	do
1598	{	2010	{
1599	ext = *data++;	2011	ext = *data++;
1600	cmd = ext & 0x3f;	2012	cmd = ext & 0x7f;
1601		2013
1602	if (cmd < 4)	2014	if (cmd < 4)
1603	cell->darkness = 255 - ext * 64 + 1;	2015	cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
1604	else if (cmd == 5) // health	2016	else if (cmd == 5) // health
1605	{	2017	{
1606	cell->stat_width = 1;	2018	cell->stat_width = 1;
1607	cell->stat_hp = *data++;	2019	cell->stat_hp = *data++;
1608	}	2020	}
1609	else if (cmd == 6) // monster width	2021	else if (cmd == 6) // monster width
1610	cell->stat_width = *data++ + 1;	2022	cell->stat_width = *data++ + 1;
1611	else if (cmd == 0x47)	2023	else if (cmd == 0x47)
1612	{	2024	{
1613	if (*data == 4)	2025	if (*data == 1) cell->player = data [1];
1614	; // decode player count	2026	else if (*data == 2) cell->player = data [2] + (data [1] << 8);
		2027	else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
		2028	else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
1615		2029
1616	data += *data + 1;	2030	data += *data + 1;
1617	}	2031	}
1618	else if (cmd == 8) // cell flags	2032	else if (cmd == 8) // cell flags
1619	cell->flags = *data++;	2033	cell->flags = *data++;
…		…
1636	cell->tile [z] = self->face2tile [face];	2050	cell->tile [z] = self->face2tile [face];
1637		2051
1638	if (cell->tile [z])	2052	if (cell->tile [z])
1639	{	2053	{
1640	maptex *tex = self->tex + cell->tile [z];	2054	maptex *tex = self->tex + cell->tile [z];
		2055	tex->unused = 0;
1641	if (!tex->name)	2056	if (!tex->name)
1642	av_push (missing, newSViv (cell->tile [z]));	2057	av_push (missing, newSViv (cell->tile [z]));
1643		2058
1644	if (tex->smoothtile)	2059	if (tex->smoothtile)
1645	{	2060	{
1646	maptex *smooth = self->tex + tex->smoothtile;	2061	maptex *smooth = self->tex + tex->smoothtile;
		2062	smooth->unused = 0;
1647	if (!smooth->name)	2063	if (!smooth->name)
1648	av_push (missing, newSViv (tex->smoothtile));	2064	av_push (missing, newSViv (tex->smoothtile));
1649	}	2065	}
1650	}	2066	}
1651	}	2067	}
1652	}	2068	}
1653	else	2069	else
1654	cell->darkness = 0;	2070	CELL_CLEAR (cell);
1655	}	2071	}
1656	}	2072	}
1657	OUTPUT:	2073	OUTPUT:
1658	RETVAL	2074	RETVAL
1659		2075
1660	SV *	2076	SV *
1661	mapmap (CFPlus::Map self, int x0, int y0, int w, int h)	2077	mapmap (DC::Map self, int x0, int y0, int w, int h)
1662	CODE:	2078	CODE:
1663	{	2079	{
1664	int x1, x;	2080	int x1, x;
1665	int y1, y;	2081	int y1, y;
1666	int z;	2082	int z;
…		…
1711	}	2127	}
1712	OUTPUT:	2128	OUTPUT:
1713	RETVAL	2129	RETVAL
1714		2130
1715	void	2131	void
1716	draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)	2132	draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1717	CODE:	2133	CODE:
1718	{	2134	{
1719	int x, y, z;	2135	int x, y, z;
1720		2136
1721	HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());	2137	HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1722	uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level	2138	uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1723	static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)	2139	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)
1724	smooth_key skey;	2140	smooth_key skey;
1725		2141	int pl_x, pl_y;
		2142	maptex pl_tex;
1726	rc_t *rc = rc_alloc ();	2143	rc_t *rc = rc_alloc ();
		2144	rc_t *rc_ov = rc_alloc ();
1727	rc_key_t key;	2145	rc_key_t key;
1728	rc_array_t *arr;	2146	rc_array_t *arr, *arr_hidden;
1729		2147
		2148	pl_tex.name = 0;
		2149
1730	// thats current max. sorry.	2150	// that's current max. sorry.
1731	if (sw > 255) sw = 255;	2151	if (sw > 255) sw = 255;
1732	if (sh > 255) sh = 255;	2152	if (sh > 255) sh = 255;
1733		2153
1734	// clear key, in case of extra padding	2154	// clear key, in case of extra padding
1735	memset (&skey, 0, sizeof (skey));	2155	memset (&skey, 0, sizeof (skey));
…		…
1739	key.g = 255;	2159	key.g = 255;
1740	key.b = 255;	2160	key.b = 255;
1741	key.a = 255;	2161	key.a = 255;
1742	key.mode = GL_QUADS;	2162	key.mode = GL_QUADS;
1743	key.format = GL_T2F_V3F;	2163	key.format = GL_T2F_V3F;
1744	key.texname = -1;
1745		2164
1746	mx += self->x;	2165	mx += self->x;
1747	my += self->y;	2166	my += self->y;
1748		2167
1749	// first pass: determine smooth_max	2168	// first pass: determine smooth_max
…		…
1770		2189
1771	glEnable (GL_BLEND);	2190	glEnable (GL_BLEND);
1772	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	2191	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1773	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	2192	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1774		2193
		2194	key.texname = self->tex [TEXID_HIDDEN].name;
		2195	arr_hidden = rc_array (rc_ov, &key);
		2196
1775	for (z = 0; z <= 2; z++)	2197	for (z = 0; z <= 2; z++)
1776	{	2198	{
1777	memset (smooth_level, 0, sizeof (smooth_level));	2199	memset (smooth_level, 0, sizeof (smooth_level));
		2200	key.texname = -1;
1778		2201
1779	for (y = 0; y < sh; y++)	2202	for (y = 0; y < sh; y++)
1780	if (0 <= y + my && y + my < self->rows)	2203	if (0 <= y + my && y + my < self->rows)
1781	{	2204	{
1782	maprow *row = self->row + (y + my);	2205	maprow *row = self->row + (y + my);
…		…
1790	if (tile)	2213	if (tile)
1791	{	2214	{
1792	maptex tex = self->tex [tile];	2215	maptex tex = self->tex [tile];
1793	int px, py;	2216	int px, py;
1794		2217
1795	// suppressing texture state switches here
1796	// is only moderately effective, but worth the extra effort
1797	if (key.texname != tex.name)	2218	if (key.texname != tex.name)
1798	{	2219	{
		2220	self->tex [tile].unused = 0;
		2221
1799	if (!tex.name)	2222	if (!tex.name)
1800	tex = self->tex [2]; /* missing, replace by noface */	2223	tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1801		2224
1802	key.texname = tex.name;	2225	key.texname = tex.name;
1803	arr = rc_array (rc, &key);	2226	arr = rc_array (rc, &key);
1804	}	2227	}
1805		2228
1806	px = (x + 1) * T - tex.w;	2229	px = (x + 1) * T - tex.w;
1807	py = (y + 1) * T - tex.h;	2230	py = (y + 1) * T - tex.h;
		2231
		2232	if (expect_false (cell->player == player) && expect_false (z == 2))
		2233	{
		2234	pl_x = px;
		2235	pl_y = py;
		2236	pl_tex = tex;
		2237	continue;
		2238	}
1808		2239
1809	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2240	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1810	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);	2241	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
1811	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);	2242	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
1812	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2243	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
1813
1814	if (cell->flags && z == 2)
1815	{
1816	// overlays such as the speech bubble, probably more to come
1817	if (cell->flags & 1)
1818	{
1819	maptex tex = self->tex [1];
1820	int px = x * T + T * 2 / 32;
1821	int py = y * T - T * 6 / 32;
1822
1823	if (tex.name)
1824	{
1825	if (key.texname != tex.name)
1826	{
1827	key.texname = tex.name;
1828	arr = rc_array (rc, &key);
1829	}
1830
1831	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1832	rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1833	rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1834	rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1835	}
1836	}
1837	}
1838		2244
1839	// update smooth hash	2245	// update smooth hash
1840	if (tex.smoothtile)	2246	if (tex.smoothtile)
1841	{	2247	{
1842	skey.tile = tex.smoothtile;	2248	skey.tile = tex.smoothtile;
…		…
1873	skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);	2279	skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1874	skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);	2280	skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1875	skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);	2281	skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1876	}	2282	}
1877	}	2283	}
		2284
		2285	if (expect_false (z == 2) && expect_false (cell->flags))
		2286	{
		2287	// overlays such as the speech bubble, probably more to come
		2288	if (cell->flags & 1)
		2289	{
		2290	rc_key_t key_ov = key;
		2291	maptex tex = self->tex [TEXID_SPEECH];
		2292	rc_array_t *arr;
		2293	int px = x * T + T * 2 / 32;
		2294	int py = y * T - T * 6 / 32;
		2295
		2296	key_ov.texname = tex.name;
		2297	arr = rc_array (rc_ov, &key_ov);
		2298
		2299	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
		2300	rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
		2301	rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
		2302	rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
		2303	}
		2304	}
1878	}	2305	}
1879	}	2306	}
		2307
		2308	rc_draw (rc);
		2309	rc_clear (rc);
1880		2310
1881	// go through all smoothlevels, lowest to highest, then draw.	2311	// go through all smoothlevels, lowest to highest, then draw.
1882	// this is basically counting sort	2312	// this is basically counting sort
1883	{	2313	{
1884	int w, b;	2314	int w, b;
1885		2315
		2316	glEnable (GL_TEXTURE_2D);
		2317	glBegin (GL_QUADS);
1886	for (w = 0; w < 256 / 32; ++w)	2318	for (w = 0; w < 256 / 32; ++w)
1887	{	2319	{
1888	uint32_t smask = smooth_level [w];	2320	uint32_t smask = smooth_level [w];
1889	if (smask)	2321	if (smask)
1890	for (b = 0; b < 32; ++b)	2322	for (b = 0; b < 32; ++b)
…		…
1915	{	2347	{
1916	// this time avoiding texture state changes	2348	// this time avoiding texture state changes
1917	// save gobs of state changes.	2349	// save gobs of state changes.
1918	if (key.texname != tex.name)	2350	if (key.texname != tex.name)
1919	{	2351	{
		2352	self->tex [skey->tile].unused = 0;
		2353
		2354	glEnd ();
1920	key.texname = tex.name;	2355	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
1921	arr = rc_array (rc, &key);	2356	glBegin (GL_QUADS);
1922	}	2357	}
1923		2358
1924	if (border)	2359	if (border)
1925	{	2360	{
1926	float ox = border * dx;	2361	float ox = border * dx;
1927		2362
1928	rc_t2f_v3f (arr, ox , 0.f , px , py , 0);	2363	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
1929	rc_t2f_v3f (arr, ox , dy , px , py + T, 0);	2364	glTexCoord2f (ox , dy ); glVertex2i (px , py + T);
1930	rc_t2f_v3f (arr, ox + dx, dy , px + T, py + T, 0);	2365	glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T);
1931	rc_t2f_v3f (arr, ox + dx, 0.f , px + T, py , 0);	2366	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py );
1932	}	2367	}
1933		2368
1934	if (corner)	2369	if (corner)
1935	{	2370	{
1936	float ox = corner * dx;	2371	float ox = corner * dx;
1937		2372
1938	rc_t2f_v3f (arr, ox , dy , px , py , 0);	2373	glTexCoord2f (ox , dy ); glVertex2i (px , py );
1939	rc_t2f_v3f (arr, ox , dy * 2.f, px , py + T, 0);	2374	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T);
1940	rc_t2f_v3f (arr, ox + dx, dy * 2.f, px + T, py + T, 0);	2375	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);
1941	rc_t2f_v3f (arr, ox + dx, dy , px + T, py , 0);	2376	glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py );
1942	}	2377	}
1943	}	2378	}
1944	}	2379	}
1945	}	2380	}
1946	}	2381	}
1947	}	2382	}
		2383
		2384	glEnd ();
		2385	glDisable (GL_TEXTURE_2D);
		2386	key.texname = -1;
1948	}	2387	}
1949		2388
1950	hv_clear (smooth);	2389	hv_clear (smooth);
		2390	}
		2391
		2392	if (pl_tex.name)
		2393	{
		2394	maptex tex = pl_tex;
		2395	int px = pl_x + sdx;
		2396	int py = pl_y + sdy;
		2397
		2398	key.texname = tex.name;
		2399	arr = rc_array (rc, &key);
		2400
		2401	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
		2402	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);
		2403	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
		2404	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);
		2405
1951	rc_draw (rc);	2406	rc_draw (rc);
1952	rc_clear (rc);
1953	}	2407	}
		2408
		2409	rc_draw (rc_ov);
		2410	rc_clear (rc_ov);
1954		2411
1955	glDisable (GL_BLEND);	2412	glDisable (GL_BLEND);
1956	rc_free (rc);	2413	rc_free (rc);
		2414	rc_free (rc_ov);
1957		2415
1958	// top layer: overlays such as the health bar	2416	// top layer: overlays such as the health bar
1959	for (y = 0; y < sh; y++)	2417	for (y = 0; y < sh; y++)
1960	if (0 <= y + my && y + my < self->rows)	2418	if (0 <= y + my && y + my < self->rows)
1961	{	2419	{
…		…
1966	{	2424	{
1967	mapcell *cell = row->col + (x + mx - row->c0);	2425	mapcell *cell = row->col + (x + mx - row->c0);
1968		2426
1969	int px = x * T;	2427	int px = x * T;
1970	int py = y * T;	2428	int py = y * T;
		2429
		2430	if (expect_false (cell->player == player))
		2431	{
		2432	px += sdx;
		2433	py += sdy;
		2434	}
1971		2435
1972	if (cell->stat_hp)	2436	if (cell->stat_hp)
1973	{	2437	{
1974	int width = cell->stat_width * T;	2438	int width = cell->stat_width * T;
1975	int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;	2439	int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
…		…
1986	}	2450	}
1987	}	2451	}
1988	}	2452	}
1989		2453
1990	void	2454	void
1991	draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)	2455	draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
1992	CODE:	2456	CODE:
1993	{	2457	{
1994	static float color[16][3] = {	2458	static float color[16][3] = {
1995	{ 0.00F, 0.00F, 0.00F },	2459	{ 0.00f, 0.00f, 0.00f },
1996	{ 1.00F, 1.00F, 1.00F },	2460	{ 1.00f, 1.00f, 1.00f },
1997	{ 0.00F, 0.00F, 0.55F },	2461	{ 0.00f, 0.00f, 0.55f },
1998	{ 1.00F, 0.00F, 0.00F },	2462	{ 1.00f, 0.00f, 0.00f },
1999		2463
2000	{ 1.00F, 0.54F, 0.00F },	2464	{ 1.00f, 0.54f, 0.00f },
2001	{ 0.11F, 0.56F, 1.00F },	2465	{ 0.11f, 0.56f, 1.00f },
2002	{ 0.93F, 0.46F, 0.00F },	2466	{ 0.93f, 0.46f, 0.00f },
2003	{ 0.18F, 0.54F, 0.34F },	2467	{ 0.18f, 0.54f, 0.34f },
2004		2468
2005	{ 0.56F, 0.73F, 0.56F },	2469	{ 0.56f, 0.73f, 0.56f },
2006	{ 0.80F, 0.80F, 0.80F },	2470	{ 0.80f, 0.80f, 0.80f },
2007	{ 0.55F, 0.41F, 0.13F },	2471	{ 0.55f, 0.41f, 0.13f },
2008	{ 0.99F, 0.77F, 0.26F },	2472	{ 0.99f, 0.77f, 0.26f },
2009		2473
2010	{ 0.74F, 0.65F, 0.41F },	2474	{ 0.74f, 0.65f, 0.41f },
2011		2475
2012	{ 0.00F, 1.00F, 1.00F },	2476	{ 0.00f, 1.00f, 1.00f },
2013	{ 1.00F, 0.00F, 1.00F },	2477	{ 1.00f, 0.00f, 1.00f },
2014	{ 1.00F, 1.00F, 0.00F },	2478	{ 1.00f, 1.00f, 0.00f },
2015	};	2479	};
2016		2480
2017	int x, y;	2481	int x, y;
2018		2482
2019	glEnable (GL_TEXTURE_2D);	2483	glEnable (GL_TEXTURE_2D);
		2484	/* GL_REPLACE would be correct, as we don't need to modulate alpha,
		2485	* but the nvidia driver (185.18.14) mishandles alpha textures
		2486	* and takes the colour from god knows where instead of using
		2487	* Cp. MODULATE results in the same colour, but slightly different
		2488	* alpha, but atcually gives us the correct colour with nvidia.
		2489	*/
2020	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	2490	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2021	glEnable (GL_BLEND);	2491	glEnable (GL_BLEND);
2022	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	2492	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2023	glBegin (GL_QUADS);	2493	glBegin (GL_QUADS);
2024		2494
2025	for (y = 0; y < h; y++)	2495	for (y = 0; y < h; y++)
…		…
2029		2499
2030	if (m)	2500	if (m)
2031	{	2501	{
2032	float *c = color [m & 15];	2502	float *c = color [m & 15];
2033		2503
2034	float tx1 = m & 0x40 ? 0.5 : 0.;	2504	float tx1 = m & 0x40 ? 0.5f : 0.f;
2035	float tx2 = tx1 + 0.5;	2505	float tx2 = tx1 + 0.5f;
2036		2506
2037	glColor4f (c[0], c[1], c[2], 0.75);	2507	glColor4f (c[0], c[1], c[2], 1);
2038	glTexCoord2f (tx1, 0.); glVertex2i (x , y );	2508	glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2039	glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);	2509	glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2040	glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);	2510	glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2041	glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );	2511	glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2042	}	2512	}
…		…
2046	glDisable (GL_BLEND);	2516	glDisable (GL_BLEND);
2047	glDisable (GL_TEXTURE_2D);	2517	glDisable (GL_TEXTURE_2D);
2048	}	2518	}
2049		2519
2050	void	2520	void
2051	fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)	2521	fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2052	PPCODE:	2522	PPCODE:
2053	{	2523	{
2054	int x, y;	2524	int x, y;
2055	int sw1 = sw + 2;	2525	int sw1 = sw + 2;
2056	int sh1 = sh + 2;	2526	int sh1 = sh + 2;
2057	int sh3 = sh * 3;	2527	int sh3 = sh * 3;
2058	int sw34 = (sw * 3 + 3) & ~3;	2528	int sw3 = sw * 3;
2059	uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);	2529	uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2060	SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));	2530	SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
2061	uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);	2531	uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2062		2532
2063	SvPOK_only (darkness3_sv);	2533	SvPOK_only (darkness3_sv);
2064	SvCUR_set (darkness3_sv, sw34 * sh3);	2534	SvCUR_set (darkness3_sv, sw3 * sh3);
2065		2535
2066	mx += self->x - 1;	2536	mx += self->x - 1;
2067	my += self->y - 1;	2537	my += self->y - 1;
2068
2069	memset (darkness1, 255, sw1 * sh1);
2070		2538
2071	for (y = 0; y < sh1; y++)	2539	for (y = 0; y < sh1; y++)
2072	if (0 <= y + my && y + my < self->rows)	2540	if (0 <= y + my && y + my < self->rows)
2073	{	2541	{
2074	maprow *row = self->row + (y + my);	2542	maprow *row = self->row + (y + my);
…		…
2077	if (row->c0 <= x + mx && x + mx < row->c1)	2545	if (row->c0 <= x + mx && x + mx < row->c1)
2078	{	2546	{
2079	mapcell *cell = row->col + (x + mx - row->c0);	2547	mapcell *cell = row->col + (x + mx - row->c0);
2080		2548
2081	darkness1 [y * sw1 + x] = cell->darkness	2549	darkness1 [y * sw1 + x] = cell->darkness
2082	? 255 - (cell->darkness - 1)	2550	? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2083	: 255 - FOW_DARKNESS;	2551	: DARKNESS_ADJUST (255 - FOW_DARKNESS);
2084	}	2552	}
2085	}	2553	}
2086		2554
2087	for (y = 0; y < sh; ++y)	2555	for (y = 0; y < sh; ++y)
2088	for (x = 0; x < sw; ++x)	2556	for (x = 0; x < sw; ++x)
…		…
2107		2575
2108	uint8_t r13 = (d13 + d23 + d12) / 3;	2576	uint8_t r13 = (d13 + d23 + d12) / 3;
2109	uint8_t r23 = d23;	2577	uint8_t r23 = d23;
2110	uint8_t r33 = (d23 + d33 + d32) / 3;	2578	uint8_t r33 = (d23 + d33 + d32) / 3;
2111		2579
2112	darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);	2580	darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2113	darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);	2581	darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2114	darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);	2582	darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2115	darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);	2583	darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2116	darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);	2584	darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2117	darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);	2585	darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2118	darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);	2586	darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2119	darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);	2587	darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2120	darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);	2588	darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2121	}	2589	}
2122		2590
2123	free (darkness1);	2591	free (darkness1);
2124		2592
2125	EXTEND (SP, 3);	2593	EXTEND (SP, 3);
2126	PUSHs (sv_2mortal (newSViv (sw34)));	2594	PUSHs (sv_2mortal (newSViv (sw3)));
2127	PUSHs (sv_2mortal (newSViv (sh3)));	2595	PUSHs (sv_2mortal (newSViv (sh3)));
2128	PUSHs (darkness3_sv);	2596	PUSHs (darkness3_sv);
2129	}	2597	}
2130		2598
2131	SV *	2599	SV *
2132	get_rect (CFPlus::Map self, int x0, int y0, int w, int h)	2600	get_rect (DC::Map self, int x0, int y0, int w, int h)
2133	CODE:	2601	CODE:
2134	{	2602	{
2135	int x, y, x1, y1;	2603	int x, y, x1, y1;
2136	SV *data_sv = newSV (w * h * 7 + 5);	2604	SV *data_sv = newSV (w * h * 7 + 5);
2137	uint8_t *data = (uint8_t *)SvPVX (data_sv);	2605	uint8_t *data = (uint8_t *)SvPVX (data_sv);
…		…
2194	else	2662	else
2195	*data++ = 0;	2663	*data++ = 0;
2196	}	2664	}
2197	}	2665	}
2198		2666
		2667	/* if size is w*h + 5 then no data has been found */
		2668	if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
		2669	{
2199	SvPOK_only (data_sv);	2670	SvPOK_only (data_sv);
2200	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));	2671	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
		2672	}
		2673
2201	RETVAL = data_sv;	2674	RETVAL = data_sv;
2202	}	2675	}
2203	OUTPUT:	2676	OUTPUT:
2204	RETVAL	2677	RETVAL
2205		2678
2206	void	2679	void
2207	set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)	2680	set_rect (DC::Map self, int x0, int y0, SV *data_sv)
2208	PPCODE:	2681	PPCODE:
2209	{	2682	{
2210	int x, y, z;	2683	int x, y, z;
2211	int w, h;	2684	int w, h;
2212	int x1, y1;	2685	int x1, y1;
		2686	STRLEN len;
		2687	uint8_t *data, *end;
		2688
		2689	len = SvLEN (data_sv);
		2690	SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
		2691	data = SvPVbyte_nolen (data_sv);
		2692	end = data + len + 8;
		2693
		2694	if (len < 5)
		2695	XSRETURN_EMPTY;
2213		2696
2214	if (*data++ != 0)	2697	if (*data++ != 0)
2215	return; /* version mismatch */	2698	XSRETURN_EMPTY; /* version mismatch */
2216		2699
2217	w = *data++ << 8; w |= *data++;	2700	w = *data++ << 8; w |= *data++;
2218	h = *data++ << 8; h |= *data++;	2701	h = *data++ << 8; h |= *data++;
2219		2702
2220	// we need to do this 'cause we don't keep an absolute coord system for rows	2703	// we need to do this 'cause we don't keep an absolute coord system for rows
…		…
2232	{	2715	{
2233	maprow *row = map_get_row (self, y);	2716	maprow *row = map_get_row (self, y);
2234		2717
2235	for (x = x0; x < x1; x++)	2718	for (x = x0; x < x1; x++)
2236	{	2719	{
		2720	uint8_t flags;
		2721
		2722	if (data + 7 >= end)
		2723	XSRETURN_EMPTY;
		2724
2237	uint8_t flags = *data++;	2725	flags = *data++;
2238		2726
2239	if (flags)	2727	if (flags)
2240	{	2728	{
2241	mapcell *cell = row_get_cell (row, x);	2729	mapcell *cell = row_get_cell (row, x);
2242	tileid tile[3] = { 0, 0, 0 };	2730	tileid tile[3] = { 0, 0, 0 };
…		…
2245	if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }	2733	if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2246	if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }	2734	if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2247		2735
2248	if (cell->darkness == 0)	2736	if (cell->darkness == 0)
2249	{	2737	{
2250	cell->darkness = 0;	2738	/*cell->darkness = 0;*/
		2739	EXTEND (SP, 3);
2251		2740
2252	for (z = 0; z <= 2; z++)	2741	for (z = 0; z <= 2; z++)
2253	{	2742	{
2254	tileid t = tile [z];	2743	tileid t = tile [z];
2255		2744
2256	if (t >= self->texs || (t && !self->tex [t].name))	2745	if (t >= self->texs || (t && !self->tex [t].name))
2257	{	2746	{
2258	XPUSHs (sv_2mortal (newSViv (t)));	2747	PUSHs (sv_2mortal (newSViv (t)));
2259	need_texid (self, t);	2748	need_texid (self, t);
2260	}	2749	}
2261		2750
2262	cell->tile [z] = t;	2751	cell->tile [z] = t;
2263	}	2752	}
…		…
2265	}	2754	}
2266	}	2755	}
2267	}	2756	}
2268	}	2757	}
2269		2758
2270	MODULE = CFPlus PACKAGE = CFPlus::RW	2759	MODULE = Deliantra::Client PACKAGE = DC::RW
2271		2760
2272	CFPlus::RW	2761	DC::RW
2273	new (SV *class, SV *data_sv)	2762	new (SV *class, SV *data_sv)
2274	CODE:	2763	CODE:
2275	{	2764	{
2276	STRLEN datalen;	2765	STRLEN datalen;
2277	char *data = SvPVbyte (data_sv, datalen);	2766	char *data = SvPVbyte (data_sv, datalen);
…		…
2279	RETVAL = SDL_RWFromConstMem (data, datalen);	2768	RETVAL = SDL_RWFromConstMem (data, datalen);
2280	}	2769	}
2281	OUTPUT:	2770	OUTPUT:
2282	RETVAL	2771	RETVAL
2283		2772
2284	CFPlus::RW	2773	DC::RW
2285	new_from_file (SV *class, const char *path, const char *mode = "rb")	2774	new_from_file (SV *class, const char *path, const char *mode = "rb")
2286	CODE:	2775	CODE:
2287	RETVAL = SDL_RWFromFile (path, mode);	2776	RETVAL = SDL_RWFromFile (path, mode);
2288	OUTPUT:	2777	OUTPUT:
2289	RETVAL	2778	RETVAL
2290		2779
2291	# fails on win32:	2780	# fails on win32:
2292	# CFPlus.xs(2268) : error C2059: syntax error : '('	2781	# dc.xs(2268) : error C2059: syntax error : '('
2293	#void	2782	#void
2294	#close (CFPlus::RW self)	2783	#close (DC::RW self)
2295	# CODE:	2784	# CODE:
2296	# (self->(close)) (self);	2785	# (self->(close)) (self);
2297		2786
2298	MODULE = CFPlus PACKAGE = CFPlus::Channel	2787	MODULE = Deliantra::Client PACKAGE = DC::Channel
2299		2788
2300	PROTOTYPES: DISABLE	2789	PROTOTYPES: DISABLE
2301		2790
2302	CFPlus::Channel	2791	DC::Channel
2303	find ()	2792	find ()
2304	CODE:	2793	CODE:
2305	{	2794	{
2306	RETVAL = Mix_GroupAvailable (-1);	2795	RETVAL = Mix_GroupAvailable (-1);
2307		2796
…		…
2320	}	2809	}
2321	OUTPUT:	2810	OUTPUT:
2322	RETVAL	2811	RETVAL
2323		2812
2324	void	2813	void
2325	halt (CFPlus::Channel self)	2814	halt (DC::Channel self)
2326	CODE:	2815	CODE:
2327	Mix_HaltChannel (self);	2816	Mix_HaltChannel (self);
2328		2817
2329	void	2818	void
2330	expire (CFPlus::Channel self, int ticks = -1)	2819	expire (DC::Channel self, int ticks = -1)
2331	CODE:	2820	CODE:
2332	Mix_ExpireChannel (self, ticks);	2821	Mix_ExpireChannel (self, ticks);
2333		2822
2334	void	2823	void
2335	fade_out (CFPlus::Channel self, int ticks = -1)	2824	fade_out (DC::Channel self, int ticks = -1)
2336	CODE:	2825	CODE:
2337	Mix_FadeOutChannel (self, ticks);	2826	Mix_FadeOutChannel (self, ticks);
2338		2827
2339	int	2828	int
2340	volume (CFPlus::Channel self, int volume)	2829	volume (DC::Channel self, int volume)
2341	CODE:	2830	CODE:
2342	RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));	2831	RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
2343	OUTPUT:	2832	OUTPUT:
2344	RETVAL	2833	RETVAL
2345		2834
2346	void	2835	void
2347	unregister_all_effects (CFPlus::Channel self)	2836	unregister_all_effects (DC::Channel self)
2348	CODE:	2837	CODE:
2349	Mix_UnregisterAllEffects (self);	2838	Mix_UnregisterAllEffects (self);
2350		2839
2351	void	2840	void
2352	set_panning (CFPlus::Channel self, int left, int right)	2841	set_panning (DC::Channel self, int left, int right)
2353	CODE:	2842	CODE:
2354	left = CLAMP (left , 0, 255);	2843	left = CLAMP (left , 0, 255);
2355	right = CLAMP (right, 0, 255);	2844	right = CLAMP (right, 0, 255);
2356	Mix_SetPanning (self, left, right);	2845	Mix_SetPanning (self, left, right);
2357		2846
2358	void	2847	void
2359	set_distance (CFPlus::Channel self, int distance)	2848	set_distance (DC::Channel self, int distance)
2360	CODE:	2849	CODE:
2361	Mix_SetDistance (self, CLAMP (distance, 0, 255));	2850	Mix_SetDistance (self, CLAMP (distance, 0, 255));
2362		2851
2363	void	2852	void
2364	set_position (CFPlus::Channel self, int angle, int distance)	2853	set_position (DC::Channel self, int angle, int distance)
2365	CODE:	2854	CODE:
2366		2855
2367	void	2856	void
2368	set_position_r (CFPlus::Channel self, int dx, int dy, int maxdistance)	2857	set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2369	CODE:	2858	CODE:
2370	{	2859	{
2371	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));	2860	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2372	int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI);	2861	int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2373	Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));	2862	Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2374	}	2863	}
2375		2864
2376	void	2865	void
2377	set_reverse_stereo (CFPlus::Channel self, int flip)	2866	set_reverse_stereo (DC::Channel self, int flip)
2378	CODE:	2867	CODE:
2379	Mix_SetReverseStereo (self, flip);	2868	Mix_SetReverseStereo (self, flip);
2380		2869
2381	MODULE = CFPlus PACKAGE = CFPlus::MixChunk	2870	MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2382		2871
2383	PROTOTYPES: DISABLE	2872	PROTOTYPES: DISABLE
2384		2873
2385	CFPlus::MixChunk	2874	DC::MixChunk
2386	new (SV *class, CFPlus::RW rwops)	2875	new (SV *class, DC::RW rwops)
2387	CODE:	2876	CODE:
2388	RETVAL = Mix_LoadWAV_RW (rwops, 1);	2877	RETVAL = Mix_LoadWAV_RW (rwops, 1);
2389	OUTPUT:	2878	OUTPUT:
2390	RETVAL	2879	RETVAL
2391		2880
2392	void	2881	void
2393	DESTROY (CFPlus::MixChunk self)	2882	DESTROY (DC::MixChunk self)
2394	CODE:	2883	CODE:
2395	Mix_FreeChunk (self);	2884	Mix_FreeChunk (self);
2396		2885
2397	int	2886	int
2398	volume (CFPlus::MixChunk self, int volume = -1)	2887	volume (DC::MixChunk self, int volume = -1)
2399	CODE:	2888	CODE:
2400	if (items > 1)	2889	if (items > 1)
2401	volume = CLAMP (volume, 0, 128);	2890	volume = CLAMP (volume, 0, 128);
2402	RETVAL = Mix_VolumeChunk (self, volume);	2891	RETVAL = Mix_VolumeChunk (self, volume);
2403	OUTPUT:	2892	OUTPUT:
2404	RETVAL	2893	RETVAL
2405		2894
2406	CFPlus::Channel	2895	DC::Channel
2407	play (CFPlus::MixChunk self, CFPlus::Channel channel = -1, int loops = 0, int ticks = -1)	2896	play (DC::MixChunk self, DC::Channel channel = -1, int loops = 0, int ticks = -1)
2408	CODE:	2897	CODE:
2409	{	2898	{
2410	RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);	2899	RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2411		2900
2412	if (RETVAL < 0)	2901	if (RETVAL < 0)
…		…
2419	}	2908	}
2420	}	2909	}
2421	OUTPUT:	2910	OUTPUT:
2422	RETVAL	2911	RETVAL
2423		2912
2424	MODULE = CFPlus PACKAGE = CFPlus::MixMusic	2913	MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2425		2914
2426	int	2915	int
2427	volume (int volume = -1)	2916	volume (int volume = -1)
2428	PROTOTYPE: ;$	2917	PROTOTYPE: ;$
2429	CODE:	2918	CODE:
…		…
2441	void	2930	void
2442	halt ()	2931	halt ()
2443	CODE:	2932	CODE:
2444	Mix_HaltMusic ();	2933	Mix_HaltMusic ();
2445		2934
2446	CFPlus::MixMusic	2935	DC::MixMusic
2447	new (SV *class, CFPlus::RW rwops)	2936	new (SV *class, DC::RW rwops)
2448	CODE:	2937	CODE:
2449	RETVAL = Mix_LoadMUS_RW (rwops);	2938	RETVAL = Mix_LoadMUS_RW (rwops);
2450	OUTPUT:	2939	OUTPUT:
2451	RETVAL	2940	RETVAL
2452		2941
2453	void	2942	void
2454	DESTROY (CFPlus::MixMusic self)	2943	DESTROY (DC::MixMusic self)
2455	CODE:	2944	CODE:
2456	Mix_FreeMusic (self);	2945	Mix_FreeMusic (self);
2457		2946
2458	int	2947	int
2459	play (CFPlus::MixMusic self, int loops = -1)	2948	play (DC::MixMusic self, int loops = -1)
2460	CODE:	2949	CODE:
2461	RETVAL = Mix_PlayMusic (self, loops);	2950	RETVAL = Mix_PlayMusic (self, loops);
2462	OUTPUT:	2951	OUTPUT:
2463	RETVAL	2952	RETVAL
2464		2953
2465	void	2954	void
2466	fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position)	2955	fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
2467	CODE:	2956	CODE:
2468	Mix_FadeInMusicPos (self, loops, ms, position);	2957	Mix_FadeInMusicPos (self, loops, ms, position);
2469		2958
2470	MODULE = CFPlus PACKAGE = CFPlus::OpenGL	2959	MODULE = Deliantra::Client PACKAGE = DC::OpenGL
2471		2960
2472	PROTOTYPES: ENABLE	2961	PROTOTYPES: ENABLE
2473		2962
2474	BOOT:	2963	BOOT:
2475	{	2964	{
2476	HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);	2965	HV *stash = gv_stashpv ("DC::OpenGL", 1);
2477	static const struct {	2966	static const struct {
2478	const char *name;	2967	const char *name;
2479	IV iv;	2968	IV iv;
2480	} *civ, const_iv[] = {	2969	} *civ, const_iv[] = {
2481	# define const_iv(name) { # name, (IV)name }	2970	# define const_iv(name) { # name, (IV)name }
2482	const_iv (GL_VENDOR),	2971	const_iv (GL_VENDOR),
2483	const_iv (GL_VERSION),	2972	const_iv (GL_VERSION),
2484	const_iv (GL_EXTENSIONS),	2973	const_iv (GL_EXTENSIONS),
		2974	const_iv (GL_MAX_TEXTURE_UNITS),
2485	const_iv (GL_COLOR_MATERIAL),	2975	const_iv (GL_COLOR_MATERIAL),
2486	const_iv (GL_SMOOTH),	2976	const_iv (GL_SMOOTH),
2487	const_iv (GL_FLAT),	2977	const_iv (GL_FLAT),
2488	const_iv (GL_DITHER),	2978	const_iv (GL_DITHER),
2489	const_iv (GL_BLEND),	2979	const_iv (GL_BLEND),
…		…
2501	const_iv (GL_ZERO),	2991	const_iv (GL_ZERO),
2502	const_iv (GL_SRC_ALPHA),	2992	const_iv (GL_SRC_ALPHA),
2503	const_iv (GL_DST_ALPHA),	2993	const_iv (GL_DST_ALPHA),
2504	const_iv (GL_ONE_MINUS_SRC_ALPHA),	2994	const_iv (GL_ONE_MINUS_SRC_ALPHA),
2505	const_iv (GL_ONE_MINUS_DST_ALPHA),	2995	const_iv (GL_ONE_MINUS_DST_ALPHA),
		2996	const_iv (GL_SRC_COLOR),
		2997	const_iv (GL_DST_COLOR),
		2998	const_iv (GL_ONE_MINUS_SRC_COLOR),
		2999	const_iv (GL_ONE_MINUS_DST_COLOR),
2506	const_iv (GL_SRC_ALPHA_SATURATE),	3000	const_iv (GL_SRC_ALPHA_SATURATE),
2507	const_iv (GL_RGB),	3001	const_iv (GL_RGB),
2508	const_iv (GL_RGBA),	3002	const_iv (GL_RGBA),
2509	const_iv (GL_RGBA4),	3003	const_iv (GL_RGBA4),
2510	const_iv (GL_RGBA8),	3004	const_iv (GL_RGBA8),
…		…
2516	const_iv (GL_INTENSITY),	3010	const_iv (GL_INTENSITY),
2517	const_iv (GL_LUMINANCE),	3011	const_iv (GL_LUMINANCE),
2518	const_iv (GL_LUMINANCE_ALPHA),	3012	const_iv (GL_LUMINANCE_ALPHA),
2519	const_iv (GL_FLOAT),	3013	const_iv (GL_FLOAT),
2520	const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),	3014	const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
		3015	const_iv (GL_COMPRESSED_ALPHA_ARB),
		3016	const_iv (GL_COMPRESSED_LUMINANCE_ARB),
		3017	const_iv (GL_COMPRESSED_LUMINANCE_ALPHA_ARB),
		3018	const_iv (GL_COMPRESSED_INTENSITY_ARB),
		3019	const_iv (GL_COMPRESSED_RGB_ARB),
		3020	const_iv (GL_COMPRESSED_RGBA_ARB),
2521	const_iv (GL_COMPILE),	3021	const_iv (GL_COMPILE),
2522	const_iv (GL_PROXY_TEXTURE_1D),	3022	const_iv (GL_PROXY_TEXTURE_1D),
2523	const_iv (GL_PROXY_TEXTURE_2D),	3023	const_iv (GL_PROXY_TEXTURE_2D),
2524	const_iv (GL_TEXTURE_1D),	3024	const_iv (GL_TEXTURE_1D),
2525	const_iv (GL_TEXTURE_2D),	3025	const_iv (GL_TEXTURE_2D),
…		…
2564	const_iv (GL_PERSPECTIVE_CORRECTION_HINT),	3064	const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2565	const_iv (GL_POINT_SMOOTH_HINT),	3065	const_iv (GL_POINT_SMOOTH_HINT),
2566	const_iv (GL_LINE_SMOOTH_HINT),	3066	const_iv (GL_LINE_SMOOTH_HINT),
2567	const_iv (GL_POLYGON_SMOOTH_HINT),	3067	const_iv (GL_POLYGON_SMOOTH_HINT),
2568	const_iv (GL_GENERATE_MIPMAP_HINT),	3068	const_iv (GL_GENERATE_MIPMAP_HINT),
		3069	const_iv (GL_TEXTURE_COMPRESSION_HINT),
2569	const_iv (GL_FASTEST),	3070	const_iv (GL_FASTEST),
2570	const_iv (GL_DONT_CARE),	3071	const_iv (GL_DONT_CARE),
2571	const_iv (GL_NICEST),	3072	const_iv (GL_NICEST),
2572	const_iv (GL_V2F),	3073	const_iv (GL_V2F),
2573	const_iv (GL_V3F),	3074	const_iv (GL_V3F),
2574	const_iv (GL_T2F_V3F),	3075	const_iv (GL_T2F_V3F),
2575	const_iv (GL_T2F_N3F_V3F),	3076	const_iv (GL_T2F_N3F_V3F),
		3077	const_iv (GL_FUNC_ADD),
		3078	const_iv (GL_FUNC_SUBTRACT),
		3079	const_iv (GL_FUNC_REVERSE_SUBTRACT),
2576	# undef const_iv	3080	# undef const_iv
2577	};	3081	};
2578		3082
2579	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	3083	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
2580	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	3084	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2581		3085
2582	texture_av = newAV ();	3086	texture_av = newAV ();
2583	AvREAL_off (texture_av);	3087	AvREAL_off (texture_av);
2584	}	3088	}
2585		3089
		3090	void
		3091	disable_GL_EXT_blend_func_separate ()
		3092	CODE:
		3093	gl.BlendFuncSeparate = 0;
		3094	gl.BlendFuncSeparateEXT = 0;
		3095
		3096	void
		3097	apple_nvidia_bug (int enable)
		3098
2586	char *	3099	char *
2587	gl_vendor ()	3100	gl_vendor ()
2588	CODE:	3101	CODE:
2589	RETVAL = (char *)glGetString (GL_VENDOR);	3102	RETVAL = (char *)glGetString (GL_VENDOR);
2590	OUTPUT:	3103	OUTPUT:
…		…
2639		3152
2640	void glBlendFuncSeparate (int sa, int da, int saa, int daa)	3153	void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2641	CODE:	3154	CODE:
2642	gl_BlendFuncSeparate (sa, da, saa, daa);	3155	gl_BlendFuncSeparate (sa, da, saa, daa);
2643		3156
		3157	# void glBlendEquation (int se)
		3158
2644	void glDepthMask (int flag)	3159	void glDepthMask (int flag)
2645		3160
2646	void glLogicOp (int opcode)	3161	void glLogicOp (int opcode)
2647		3162
2648	void glColorMask (int red, int green, int blue, int alpha)	3163	void glColorMask (int red, int green, int blue, int alpha)
…		…
2682	void glRotate (float angle, float x, float y, float z)	3197	void glRotate (float angle, float x, float y, float z)
2683	CODE:	3198	CODE:
2684	glRotatef (angle, x, y, z);	3199	glRotatef (angle, x, y, z);
2685		3200
2686	void glColor (float r, float g, float b, float a = 1.0)	3201	void glColor (float r, float g, float b, float a = 1.0)
		3202	PROTOTYPE: @
2687	ALIAS:	3203	ALIAS:
2688	glColor_premultiply = 1	3204	glColor_premultiply = 1
2689	CODE:	3205	CODE:
2690	if (ix)	3206	if (ix)
2691	{	3207	{
…		…
2711		3227
2712	void glRect (float x1, float y1, float x2, float y2)	3228	void glRect (float x1, float y1, float x2, float y2)
2713	CODE:	3229	CODE:
2714	glRectf (x1, y1, x2, y2);	3230	glRectf (x1, y1, x2, y2);
2715		3231
		3232	void glRect_lineloop (float x1, float y1, float x2, float y2)
		3233	CODE:
		3234	glBegin (GL_LINE_LOOP);
		3235	glVertex2f (x1, y1);
		3236	glVertex2f (x2, y1);
		3237	glVertex2f (x2, y2);
		3238	glVertex2f (x1, y2);
		3239	glEnd ();
		3240
2716	PROTOTYPES: ENABLE	3241	PROTOTYPES: ENABLE
2717		3242
2718	void glBegin (int mode)	3243	void glBegin (int mode)
2719		3244
2720	void glEnd ()	3245	void glEnd ()
…		…
2752	void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)	3277	void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2753	CODE:	3278	CODE:
2754	if (gl.SeparableFilter2D)	3279	if (gl.SeparableFilter2D)
2755	gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);	3280	gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2756		3281
2757	void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)	3282	void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data = 0)
2758		3283
2759	void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)	3284	void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2760		3285
2761	void glDrawPixels (int width, int height, int format, int type, char *pixels)	3286	void glDrawPixels (int width, int height, int format, int type, char *pixels)
2762		3287
…		…
2788		3313
2789	void glEndList ()	3314	void glEndList ()
2790		3315
2791	void glCallList (int list)	3316	void glCallList (int list)
2792		3317
2793	MODULE = CFPlus PACKAGE = CFPlus::UI::Base	3318	void c_init ()
		3319	CODE:
		3320	glPixelStorei (GL_PACK_ALIGNMENT , 1);
		3321	glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
		3322
		3323	MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2794		3324
2795	PROTOTYPES: DISABLE	3325	PROTOTYPES: DISABLE
2796		3326
2797	void	3327	void
2798	find_widget (SV *self, NV x, NV y)	3328	find_widget (SV *self, NV x, NV y)
…		…
2802	XPUSHs (self);	3332	XPUSHs (self);
2803	}	3333	}
2804		3334
2805	BOOT:	3335	BOOT:
2806	{	3336	{
2807	hover_gv = gv_fetchpv ("CFPlus::UI::HOVER", 1, SVt_NV);	3337	hover_gv = gv_fetchpv ("DC::UI::HOVER", 1, SVt_NV);
2808		3338
2809	draw_x_gv = gv_fetchpv ("CFPlus::UI::Base::draw_x", 1, SVt_NV);	3339	draw_x_gv = gv_fetchpv ("DC::UI::Base::draw_x", 1, SVt_NV);
2810	draw_y_gv = gv_fetchpv ("CFPlus::UI::Base::draw_y", 1, SVt_NV);	3340	draw_y_gv = gv_fetchpv ("DC::UI::Base::draw_y", 1, SVt_NV);
2811	draw_w_gv = gv_fetchpv ("CFPlus::UI::Base::draw_w", 1, SVt_NV);	3341	draw_w_gv = gv_fetchpv ("DC::UI::Base::draw_w", 1, SVt_NV);
2812	draw_h_gv = gv_fetchpv ("CFPlus::UI::Base::draw_h", 1, SVt_NV);	3342	draw_h_gv = gv_fetchpv ("DC::UI::Base::draw_h", 1, SVt_NV);
2813	}	3343	}
2814		3344
2815	void	3345	void
2816	draw (SV *self)	3346	draw (SV *self)
2817	CODE:	3347	CODE:
…		…
2821	NV x, y, w, h;	3351	NV x, y, w, h;
2822	SV *draw_x_sv = GvSV (draw_x_gv);	3352	SV *draw_x_sv = GvSV (draw_x_gv);
2823	SV *draw_y_sv = GvSV (draw_y_gv);	3353	SV *draw_y_sv = GvSV (draw_y_gv);
2824	SV *draw_w_sv = GvSV (draw_w_gv);	3354	SV *draw_w_sv = GvSV (draw_w_gv);
2825	SV *draw_h_sv = GvSV (draw_h_gv);	3355	SV *draw_h_sv = GvSV (draw_h_gv);
2826	SV *hover;
2827	double draw_x, draw_y, draw_w, draw_h;	3356	double draw_x, draw_y;
2828		3357
2829	if (!SvROK (self))	3358	if (!SvROK (self))
2830	croak ("CFPlus::Base::draw: %s not a reference", SvPV_nolen (self));	3359	croak ("DC::Base::draw: %s not a reference", SvPV_nolen (self));
2831		3360
2832	hv = (HV *)SvRV (self);	3361	hv = (HV *)SvRV (self);
2833		3362
2834	if (SvTYPE (hv) != SVt_PVHV)	3363	if (SvTYPE (hv) != SVt_PVHV)
2835	croak ("CFPlus::Base::draw: %s not a hashref", SvPV_nolen (self));	3364	croak ("DC::Base::draw: %s not a hashref", SvPV_nolen (self));
2836		3365
2837	svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;	3366	svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
2838	svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;	3367	svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
2839		3368
2840	if (!h || !w)	3369	if (!h || !w)
…		…
2860	{	3389	{
2861	svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);	3390	svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
2862		3391
2863	if (svp && SvTRUE (*svp))	3392	if (svp && SvTRUE (*svp))
2864	{	3393	{
2865	glColor4f (1*0.2f, 0.8*0.2f, 0.5*0.2f, 0.2f);	3394	glColor4f (1.0f * 0.2f, 0.8f * 0.2f, 0.5f * 0.2f, 0.2f);
2866	glEnable (GL_BLEND);	3395	glEnable (GL_BLEND);
2867	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);	3396	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
2868	glBegin (GL_QUADS);	3397	glBegin (GL_QUADS);
2869	glVertex2f (0, 0);	3398	glVertex2f (0, 0);
2870	glVertex2f (w, 0);	3399	glVertex2f (w, 0);
…		…
2873	glEnd ();	3402	glEnd ();
2874	glDisable (GL_BLEND);	3403	glDisable (GL_BLEND);
2875	}	3404	}
2876	}	3405	}
2877	#if 0	3406	#if 0
2878	if ($ENV{CFPLUS_DEBUG} & 1) {	3407	// draw borders, for debugging
2879	glPushMatrix;	3408	glPushMatrix ();
2880	glColor 1, 1, 0, 1;	3409	glColor4f (1., 1., 0., 1.);
2881	glTranslate 0.375, 0.375;	3410	glTranslatef (.5, .5, 0.);
2882	glBegin GL_LINE_LOOP;	3411	glBegin (GL_LINE_LOOP);
2883	glVertex 0 , 0;	3412	glVertex2f (0 , 0);
2884	glVertex $self->{w} - 1, 0;	3413	glVertex2f (w - 1, 0);
2885	glVertex $self->{w} - 1, $self->{h} - 1;	3414	glVertex2f (w - 1, h - 1);
2886	glVertex 0 , $self->{h} - 1;	3415	glVertex2f (0 , h - 1);
2887	glEnd;	3416	glEnd ();
2888	glPopMatrix;	3417	glPopMatrix ();
2889	#CFPlus::UI::Label->new (w => $self->{w}, h => $self->{h}, text => $self, fontsize => 0)->_draw;
2890	}
2891	#endif	3418	#endif
2892	PUSHMARK (SP);	3419	PUSHMARK (SP);
2893	XPUSHs (self);	3420	XPUSHs (self);
2894	PUTBACK;	3421	PUTBACK;
2895	call_method ("_draw", G_VOID | G_DISCARD);	3422	call_method ("_draw", G_VOID | G_DISCARD);

Diff Legend

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