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.262 by root, Wed Jul 16 20:12:27 2008 UTC vs.
Revision 1.331 by root, Mon Nov 19 00:10:34 2018 UTC

…		…
15		15
16	#include "EXTERN.h"	16	#include "EXTERN.h"
17	#include "perl.h"	17	#include "perl.h"
18	#include "XSUB.h"	18	#include "XSUB.h"
19		19
		20	#include "flat_hash_map.hpp"
		21
20	#ifdef _WIN32	22	#ifdef _WIN32
21	# undef pipe	23	# undef pipe
22	// microsoft vs. C	24	// microsoft vs. C
23	# define sqrtf(x) sqrt(x)	25	# define sqrtf(x) sqrt(x)
24	# define roundf(x) (int)(x)
25	# define atan2f(x,y) atan2(x,y)	26	# define atan2f(x,y) atan2(x,y)
26	# define M_PI 3.14159265f	27	# define M_PI 3.14159265f
27	#endif	28	#endif
28		29
29	#include <assert.h>	30	#include <cassert>
30	#include <math.h>	31	#include <cmath>
31	#include <string.h>	32	#include <cstring>
32	#include <stdio.h>	33	#include <cstdio>
33	#include <stdlib.h>	34	#include <cstdlib>
		35
		36	#include <utility>
		37	#include <bitset>
34		38
35	#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW	39	#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
36		40
37	#include <SDL.h>	41	#include <SDL.h>
38	#include <SDL_thread.h>	42	#include <SDL_thread.h>
39	#include <SDL_endian.h>	43	#include <SDL_endian.h>
40	#include <SDL_image.h>	44	#include <SDL_image.h>
41	#include <SDL_mixer.h>	45	#include <SDL_mixer.h>
42	#include <SDL_opengl.h>	46	#include <SDL_opengl.h>
43		47
		48	/* work around os x broken headers */
		49	#ifdef __MACOSX__
		50	typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
		51	typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
		52	typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
		53	#endif
		54
44	#define PANGO_ENABLE_BACKEND	55	#define PANGO_ENABLE_BACKEND
45	#define G_DISABLE_CAST_CHECKS	56	#define G_DISABLE_CAST_CHECKS
46		57
47	#include <glib/gmacros.h>	58	#include <glib.h>
48		59
49	#include <pango/pango.h>	60	#include <pango/pango.h>
50		61
51	#ifndef PANGO_VERSION_CHECK	62	#ifndef PANGO_VERSION_CHECK
52	# define PANGO_VERSION_CHECK(a,b,c) 0	63	# define PANGO_VERSION_CHECK(a,b,c) 0
…		…
65	# include <netinet/in.h>	76	# include <netinet/in.h>
66	# include <netinet/tcp.h>	77	# include <netinet/tcp.h>
67	# include <inttypes.h>	78	# include <inttypes.h>
68	#endif	79	#endif
69		80
70	#if __GNUC__ >= 4	81	#include "ecb.h"
71	# define expect(expr,value) __builtin_expect ((expr),(value))
72	#else
73	# define expect(expr,value) (expr)
74	#endif
75
76	#define expect_false(expr) expect ((expr) != 0, 0)
77	#define expect_true(expr) expect ((expr) != 0, 1)
78		82
79	#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */	83	#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
80		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 */
81	#define FOW_DARKNESS 32	87	#define FOW_DARKNESS 50
		88	#define DARKNESS_ADJUST(n) (n)
82		89
83	#define MAP_EXTEND_X 32	90	#define MAP_EXTEND_X 32
84	#define MAP_EXTEND_Y 512	91	#define MAP_EXTEND_Y 512
85		92
86	#define MIN_FONT_HEIGHT 10	93	#define MIN_FONT_HEIGHT 10
87		94
88	/* mask out modifiers we are not interested in */	95	/* mask out modifiers we are not interested in */
89	#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)	96	#define MOD_MASK (KMOD_CTRL | KMOD_SHIFT | KMOD_ALT | KMOD_META)
90		97
91	#if 1	98	#define KMOD_LRAM 0x10000 // our extension
92	# define PARACHUTE SDL_INIT_NOPARACHUTE	99
93	#else	100	#define TEXID_SPEECH 1
94	# define PARACHUTE 0	101	#define TEXID_NOFACE 2
95	#endif	102
		103	static char *
		104	fast_sv_grow (SV *sv, STRLEN need)
		105	{
		106	STRLEN len = SvLEN (sv);
		107	STRLEN want = SvCUR (sv) + need;
		108
		109	if (ecb_expect_false (len < want))
		110	{
		111	do
		112	len *= 2;
		113	while (len < want);
		114
		115	sv_grow (sv, len);
		116	}
		117
		118	SvCUR_set (sv, want);
		119	return SvEND (sv) - need;
		120	}
96		121
97	static AV *texture_av;	122	static AV *texture_av;
98		123
99	static struct	124	static struct
100	{	125	{
…		…
157	{	182	{
158	GSList *attrs = run->item->analysis.extra_attrs;	183	GSList *attrs = run->item->analysis.extra_attrs;
159		184
160	while (attrs)	185	while (attrs)
161	{	186	{
162	PangoAttribute *attr = attrs->data;	187	PangoAttribute *attr = (PangoAttribute *)attrs->data;
163		188
164	if (attr->klass->type == PANGO_ATTR_SHAPE)	189	if (attr->klass->type == PANGO_ATTR_SHAPE)
165	return 1;	190	return 1;
166		191
167	attrs = attrs->next;	192	attrs = attrs->next;
168	}	193	}
169		194
170	return 0;	195	return 0;
171	}	196	}
172		197
173	typedef struct cf_layout {	198	struct cf_layout {
174	PangoLayout *pl;	199	PangoLayout *pl;
175	float r, g, b, a; // default color for rgba mode	200	float r, g, b, a; // default color for rgba mode
176	int base_height;	201	int base_height;
177	DC__Font font;	202	DC__Font font;
178	rc_t *rc;	203	rc_t rc;
179	} *DC__Layout;	204	};
		205
		206	typedef cf_layout *DC__Layout;
180		207
181	static DC__Font default_font;	208	static DC__Font default_font;
182	static PangoContext *opengl_context;	209	static PangoContext *opengl_context;
183	static PangoFontMap *opengl_fontmap;	210	static PangoFontMap *opengl_fontmap;
184		211
185	static void	212	static void
186	substitute_func (FcPattern *pattern, gpointer data)	213	substitute_func (FcPattern *pattern, gpointer data)
187	{	214	{
188	FcPatternAddBool (pattern, FC_HINTING, 1);	215	FcPatternAddBool (pattern, FC_HINTING, 1);
189	#ifdef FC_HINT_STYLE	216	#ifdef FC_HINT_STYLE
190	FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL);	217	FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
191	#endif	218	#endif
192	FcPatternAddBool (pattern, FC_AUTOHINT, 0);	219	FcPatternAddBool (pattern, FC_AUTOHINT, 0);
193	}	220	}
194		221
195	static void	222	static void
…		…
222		249
223	*w = rect.width;	250	*w = rect.width;
224	*h = rect.height;	251	*h = rect.height;
225	}	252	}
226		253
		254	/////////////////////////////////////////////////////////////////////////////
		255
227	typedef uint16_t tileid;	256	typedef uint16_t tileid;
228	typedef uint16_t faceid;	257	typedef uint16_t faceid;
229		258
230	typedef struct {	259	struct maptex
		260	{
231	GLuint name;	261	GLuint name;
232	int w, h;	262	int w, h;
233	float s, t;	263	float s, t;
234	uint8_t r, g, b, a;	264	uint8_t r, g, b, a;
235	tileid smoothtile;	265	tileid smoothtile;
236	uint8_t smoothlevel;	266	uint8_t smoothlevel;
237	} maptex;	267	uint8_t unused; /* set to zero on use */
		268	};
238		269
239	typedef struct {	270	struct mapcell
		271	{
240	uint32_t player;	272	uint32_t player;
241	tileid tile[3];	273	tileid tile[3];
242	uint16_t darkness;	274	uint16_t darkness;
243	uint8_t stat_width, stat_hp, flags, smoothmax;	275	uint8_t stat_width, stat_hp, flags, smoothmax;
244	} mapcell;	276	};
245		277
246	typedef struct {	278	struct maprow
		279	{
247	int32_t c0, c1;	280	int32_t c0, c1;
248	mapcell *col;	281	mapcell *col;
249	} maprow;	282	};
250		283
251	typedef struct map {	284	struct mapgrid {
252	int x, y, w, h;	285	int x, y, w, h;
253	int ox, oy; /* offset to virtual global coordinate system */	286	int ox, oy; /* offset to virtual global coordinate system */
254	int faces; tileid *face2tile; // [faceid]	287	int faces; tileid *face2tile; // [faceid]
255	int texs; maptex *tex; // [tileid]	288	int texs; maptex *tex; // [tileid]
256		289
257	int32_t rows;	290	int32_t rows;
258	maprow *row;	291	maprow *row;
259	} *DC__Map;	292	};
260		293
261	static char *	294	typedef mapgrid *DC__Map;
		295
		296	template<typename T>
		297	static void
262	prepend (char *ptr, int sze, int inc)	298	prepend (T *&ptr, int sze, int inc)
263	{	299	{
264	char *p;	300	T *p;
265		301
266	New (0, p, sze + inc, char);	302	Newx (p, inc + sze, T);
267	Zero (p, inc, char);	303	Zero (p, inc, T);
268	Move (ptr, p + inc, sze, char);	304	Move (ptr, p + inc, sze, T);
269	Safefree (ptr);	305	Safefree (ptr);
270		306
271	return p;	307	ptr = p;
272	}	308	}
273		309
274	static char *	310	template<typename T>
275	append (char *ptr, int sze, int inc)
276	{
277	Renew (ptr, sze + inc, char);
278	Zero (ptr + sze, inc, char);
279
280	return ptr;
281	}
282
283	#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
284	#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
285
286	static void	311	static void
		312	append (T *&ptr, int sze, int inc)
		313	{
		314	Renew (ptr, sze + inc, T);
		315	Zero (ptr + sze, inc, T);
		316	}
		317
		318	static void
287	need_facenum (struct map *self, faceid face)	319	need_facenum (struct mapgrid *self, faceid face)
288	{	320	{
289	while (self->faces <= face)	321	while (self->faces <= face)
290	{	322	{
291	Append (tileid, self->face2tile, self->faces, self->faces);	323	append (self->face2tile, self->faces, self->faces);
292	self->faces *= 2;	324	self->faces *= 2;
293	}	325	}
294	}	326	}
295		327
296	static void	328	static void
297	need_texid (struct map *self, int texid)	329	need_texid (struct mapgrid *self, int texid)
298	{	330	{
299	while (self->texs <= texid)	331	while (self->texs <= texid)
300	{	332	{
301	Append (maptex, self->tex, self->texs, self->texs);	333	append (self->tex, self->texs, self->texs);
302	self->texs *= 2;	334	self->texs *= 2;
303	}	335	}
304	}	336	}
305		337
306	static maprow *	338	static maprow *
307	map_get_row (DC__Map self, int y)	339	map_get_row (mapgrid *self, int y)
308	{	340	{
309	if (0 > y)	341	if (0 > y)
310	{	342	{
311	int extend = - y + MAP_EXTEND_Y;	343	int extend = - y + MAP_EXTEND_Y;
312	Prepend (maprow, self->row, self->rows, extend);	344	prepend (self->row, self->rows, extend);
313		345
314	self->rows += extend;	346	self->rows += extend;
315	self->y += extend;	347	self->y += extend;
316	y += extend;	348	y += extend;
317	}	349	}
318	else if (y >= self->rows)	350	else if (y >= self->rows)
319	{	351	{
320	int extend = y - self->rows + MAP_EXTEND_Y;	352	int extend = y - self->rows + MAP_EXTEND_Y;
321	Append (maprow, self->row, self->rows, extend);	353	append (self->row, self->rows, extend);
322	self->rows += extend;	354	self->rows += extend;
323	}	355	}
324		356
325	return self->row + y;	357	return self->row + y;
326	}	358	}
…		…
336	}	368	}
337		369
338	if (row->c0 > x)	370	if (row->c0 > x)
339	{	371	{
340	int extend = row->c0 - x + MAP_EXTEND_X;	372	int extend = row->c0 - x + MAP_EXTEND_X;
341	Prepend (mapcell, row->col, row->c1 - row->c0, extend);	373	prepend (row->col, row->c1 - row->c0, extend);
342	row->c0 -= extend;	374	row->c0 -= extend;
343	}	375	}
344	else if (x >= row->c1)	376	else if (x >= row->c1)
345	{	377	{
346	int extend = x - row->c1 + MAP_EXTEND_X;	378	int extend = x - row->c1 + MAP_EXTEND_X;
347	Append (mapcell, row->col, row->c1 - row->c0, extend);	379	append (row->col, row->c1 - row->c0, extend);
348	row->c1 += extend;	380	row->c1 += extend;
349	}	381	}
350		382
351	return row->col + (x - row->c0);	383	return row->col + (x - row->c0);
352	}	384	}
353		385
354	static mapcell *	386	static mapcell *
355	map_get_cell (DC__Map self, int x, int y)	387	map_get_cell (mapgrid *self, int x, int y)
356	{	388	{
357	return row_get_cell (map_get_row (self, y), x);	389	return row_get_cell (map_get_row (self, y), x);
358	}	390	}
359		391
360	static void	392	static void
361	map_clear (DC__Map self)	393	map_clear (mapgrid *self)
362	{	394	{
363	int r;	395	int r;
364		396
365	for (r = 0; r < self->rows; r++)	397	for (r = 0; r < self->rows; r++)
366	Safefree (self->row[r].col);	398	Safefree (self->row[r].col);
…		…
373	self->oy = 0;	405	self->oy = 0;
374	self->row = 0;	406	self->row = 0;
375	self->rows = 0;	407	self->rows = 0;
376	}	408	}
377		409
		410	#define CELL_CLEAR(cell) \
		411	do { \
		412	if ((cell)->player) \
		413	(cell)->tile [2] = 0; \
		414	(cell)->darkness = 0; \
		415	(cell)->stat_hp = 0; \
		416	(cell)->flags = 0; \
		417	(cell)->player = 0; \
		418	} while (0)
		419
378	static void	420	static void
379	map_blank (DC__Map self, int x0, int y0, int w, int h)	421	map_blank (mapgrid *self, int x0, int y0, int w, int h)
380	{	422	{
381	int x, y;	423	int x, y;
382	maprow *row;	424	maprow *row;
383	mapcell *cell;	425	mapcell *cell;
384		426
…		…
396	if (x >= row->c1)	438	if (x >= row->c1)
397	break;	439	break;
398		440
399	cell = row->col + x - row->c0;	441	cell = row->col + x - row->c0;
400		442
401	cell->darkness = 0;	443	CELL_CLEAR (cell);
402	cell->stat_hp = 0;
403	cell->flags = 0;
404	cell->player = 0;
405	}	444	}
406	}	445	}
407	}	446	}
408		447
409	typedef struct {	448	struct smooth_key
		449	{
410	tileid tile;	450	tileid tile;
411	uint8_t x, y, level;	451	uint8_t x, y, level;
412	} smooth_key;	452
		453	bool operator == (const smooth_key &o) const
		454	{
		455	return tile == o.tile && x == o.x && y == o.y && level == o.level;
		456	}
		457	};
		458
		459	typedef ska::flat_hash_map<smooth_key, IV> smooth_hash;
		460
		461	namespace std {
		462	template <>
		463	struct hash<smooth_key>
		464	{
		465	size_t operator () (const smooth_key &v) const
		466	{
		467	return v.tile + (v.x << 8) + (v.y << 16) + (v.level << 24);
		468	}
		469	};
		470	}
413		471
414	static void	472	static void
415	smooth_or_bits (HV *hv, smooth_key *key, IV bits)	473	smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
416	{	474	{
417	SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);	475	auto &&it = h.find (key);
418		476
419	if (SvIOK (*sv))	477	if (it == h.end ())
420	SvIV_set (*sv, SvIVX (*sv) | bits);	478	h.insert (std::make_pair (key, bits));
421	else	479	else
422	sv_setiv (*sv, bits);	480	it->second |= bits;
423	}	481	}
424		482
425	static void	483	static void
426	music_finished (void)	484	music_finished (void)
427	{	485	{
…		…
444	ev.code = 1;	502	ev.code = 1;
445	ev.data1 = (void *)(long)channel;	503	ev.data1 = (void *)(long)channel;
446	ev.data2 = 0;	504	ev.data2 = 0;
447		505
448	SDL_PushEvent ((SDL_Event *)&ev);	506	SDL_PushEvent ((SDL_Event *)&ev);
		507	}
		508
		509	// approximately divide by 255
		510	static unsigned int
		511	div255 (unsigned int n)
		512	{
		513	return (n + (n >> 8)) >> 8;
449	}	514	}
450		515
451	static unsigned int	516	static unsigned int
452	minpot (unsigned int n)	517	minpot (unsigned int n)
453	{	518	{
…		…
463	n |= n >> 16;	528	n |= n >> 16;
464		529
465	return n + 1;	530	return n + 1;
466	}	531	}
467		532
468	static unsigned int
469	popcount (unsigned int n)
470	{
471	n -= (n >> 1) & 0x55555555U;
472	n = ((n >> 2) & 0x33333333U) + (n & 0x33333333U);
473	n = ((n >> 4) + n) & 0x0f0f0f0fU;
474	n *= 0x01010101U;
475
476	return n >> 24;
477	}
478
479	/* SDL should provide this, really. */	533	/* SDL should provide this, really. */
480	#define SDLK_MODIFIER_MIN 300	534	#define SDLK_MODIFIER_MIN 300
481	#define SDLK_MODIFIER_MAX 314	535	#define SDLK_MODIFIER_MAX 314
482		536
483	/******************************************************************************/	537	/******************************************************************************/
…		…
520	if (!svp || !SvTRUE (*svp))	574	if (!svp || !SvTRUE (*svp))
521	return 0;	575	return 0;
522		576
523	return 1;	577	return 1;
524	}	578	}
		579
		580	/******************************************************************************/
		581
		582	/* process keyboard modifiers */
		583	static int
		584	mod_munge (int mod)
		585	{
		586	mod &= MOD_MASK;
		587
		588	if (mod & (KMOD_META | KMOD_ALT))
		589	mod |= KMOD_LRAM;
		590
		591	return mod;
		592	}
		593
		594	static void
		595	deliantra_main (SV *real_main)
		596	{
		597	dSP;
		598
		599	PUSHMARK (SP);
		600	call_sv (real_main, G_DISCARD | G_VOID);
		601	}
		602
		603	#ifdef __MACOSX__
		604	static SV *real_main;
		605
		606	/* to due surprising braindamage on the side of SDL design, we
		607	* do some mind-boggling hack here: SDL requires a custom main()
		608	* on OS X, so... we provide one and call the original main(), which,
		609	* due to shared library magic, calls -lSDLmain's main, not perl's main,
		610	* and which calls our main (== SDL_main) back.
		611	*/
		612	extern C_LINKAGE int
		613	main (int argc, char *argv[])
		614	{
		615	deliantra_main (real_main);
		616	}
		617
		618	#undef main
		619
		620	extern C_LINKAGE int main (int argc, char *argv[]);
		621
		622	static void
		623	SDL_main_hack (SV *real_main_)
		624	{
		625	real_main = real_main_;
		626
		627	char *argv[] = { "deliantra client", 0 };
		628	(main) (1, argv);
		629	}
		630	#else
		631	static void
		632	SDL_main_hack (SV *real_main)
		633	{
		634	deliantra_main (real_main);
		635	}
		636	#endif
525		637
526	MODULE = Deliantra::Client PACKAGE = DC	638	MODULE = Deliantra::Client PACKAGE = DC
527		639
528	PROTOTYPES: ENABLE	640	PROTOTYPES: ENABLE
529		641
…		…
558	const_iv (SDL_USEREVENT),	670	const_iv (SDL_USEREVENT),
559		671
560	const_iv (SDL_APPINPUTFOCUS),	672	const_iv (SDL_APPINPUTFOCUS),
561	const_iv (SDL_APPMOUSEFOCUS),	673	const_iv (SDL_APPMOUSEFOCUS),
562	const_iv (SDL_APPACTIVE),	674	const_iv (SDL_APPACTIVE),
		675
		676
		677	const_iv (SDLK_UNKNOWN),
		678	const_iv (SDLK_FIRST),
		679	const_iv (SDLK_BACKSPACE),
		680	const_iv (SDLK_TAB),
		681	const_iv (SDLK_CLEAR),
		682	const_iv (SDLK_RETURN),
		683	const_iv (SDLK_PAUSE),
		684	const_iv (SDLK_ESCAPE),
		685	const_iv (SDLK_SPACE),
		686	const_iv (SDLK_EXCLAIM),
		687	const_iv (SDLK_QUOTEDBL),
		688	const_iv (SDLK_HASH),
		689	const_iv (SDLK_DOLLAR),
		690	const_iv (SDLK_AMPERSAND),
		691	const_iv (SDLK_QUOTE),
		692	const_iv (SDLK_LEFTPAREN),
		693	const_iv (SDLK_RIGHTPAREN),
		694	const_iv (SDLK_ASTERISK),
		695	const_iv (SDLK_PLUS),
		696	const_iv (SDLK_COMMA),
		697	const_iv (SDLK_MINUS),
		698	const_iv (SDLK_PERIOD),
		699	const_iv (SDLK_SLASH),
		700	const_iv (SDLK_0),
		701	const_iv (SDLK_1),
		702	const_iv (SDLK_2),
		703	const_iv (SDLK_3),
		704	const_iv (SDLK_4),
		705	const_iv (SDLK_5),
		706	const_iv (SDLK_6),
		707	const_iv (SDLK_7),
		708	const_iv (SDLK_8),
		709	const_iv (SDLK_9),
		710	const_iv (SDLK_COLON),
		711	const_iv (SDLK_SEMICOLON),
		712	const_iv (SDLK_LESS),
		713	const_iv (SDLK_EQUALS),
		714	const_iv (SDLK_GREATER),
		715	const_iv (SDLK_QUESTION),
		716	const_iv (SDLK_AT),
		717
		718	const_iv (SDLK_LEFTBRACKET),
		719	const_iv (SDLK_BACKSLASH),
		720	const_iv (SDLK_RIGHTBRACKET),
		721	const_iv (SDLK_CARET),
		722	const_iv (SDLK_UNDERSCORE),
		723	const_iv (SDLK_BACKQUOTE),
		724	const_iv (SDLK_DELETE),
563		725
564	const_iv (SDLK_FIRST),	726	const_iv (SDLK_FIRST),
565	const_iv (SDLK_LAST),	727	const_iv (SDLK_LAST),
566	const_iv (SDLK_KP0),	728	const_iv (SDLK_KP0),
567	const_iv (SDLK_KP1),	729	const_iv (SDLK_KP1),
…		…
643	const_iv (KMOD_RMETA),	805	const_iv (KMOD_RMETA),
644	const_iv (KMOD_NUM),	806	const_iv (KMOD_NUM),
645	const_iv (KMOD_CAPS),	807	const_iv (KMOD_CAPS),
646	const_iv (KMOD_MODE),	808	const_iv (KMOD_MODE),
647		809
		810	const_iv (KMOD_LRAM),
		811
648	const_iv (MIX_DEFAULT_FORMAT),	812	const_iv (MIX_DEFAULT_FORMAT),
		813
		814	const_iv (SDL_INIT_TIMER),
		815	const_iv (SDL_INIT_AUDIO),
		816	const_iv (SDL_INIT_VIDEO),
		817	const_iv (SDL_INIT_CDROM),
		818	const_iv (SDL_INIT_JOYSTICK),
		819	const_iv (SDL_INIT_EVERYTHING),
		820	const_iv (SDL_INIT_NOPARACHUTE),
		821	const_iv (SDL_INIT_EVENTTHREAD),
		822
		823	const_iv (SDL_GL_RED_SIZE),
		824	const_iv (SDL_GL_GREEN_SIZE),
		825	const_iv (SDL_GL_BLUE_SIZE),
		826	const_iv (SDL_GL_ALPHA_SIZE),
		827	const_iv (SDL_GL_DOUBLEBUFFER),
		828	const_iv (SDL_GL_BUFFER_SIZE),
		829	const_iv (SDL_GL_DEPTH_SIZE),
		830	const_iv (SDL_GL_STENCIL_SIZE),
		831	const_iv (SDL_GL_ACCUM_RED_SIZE),
		832	const_iv (SDL_GL_ACCUM_GREEN_SIZE),
		833	const_iv (SDL_GL_ACCUM_BLUE_SIZE),
		834	const_iv (SDL_GL_ACCUM_ALPHA_SIZE),
		835	const_iv (SDL_GL_STEREO),
		836	const_iv (SDL_GL_MULTISAMPLEBUFFERS),
		837	const_iv (SDL_GL_MULTISAMPLESAMPLES),
		838	const_iv (SDL_GL_ACCELERATED_VISUAL),
		839	const_iv (SDL_GL_SWAP_CONTROL),
		840
		841	const_iv (FOW_DARKNESS)
649	# undef const_iv	842	# undef const_iv
650	};	843	};
651		844
652	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	845	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
653	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	846	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
654		847
655	assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);	848	assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
656	assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);	849	assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
657	}	850	}
658		851
…		…
674	NV ceil (NV x)	867	NV ceil (NV x)
675		868
676	IV minpot (UV n)	869	IV minpot (UV n)
677		870
678	IV popcount (UV n)	871	IV popcount (UV n)
		872	CODE:
		873	RETVAL = ecb_popcount32 (n);
		874	OUTPUT:
		875	RETVAL
		876
		877	NV distance (NV dx, NV dy)
		878	CODE:
		879	RETVAL = pow (dx * dx + dy * dy, 0.5);
		880	OUTPUT:
		881	RETVAL
679		882
680	void	883	void
681	pango_init ()	884	pango_init ()
682	CODE:	885	CODE:
683	{	886	{
…		…
689	pango_context_set_language (opengl_context, pango_language_from_string ("en"));	892	pango_context_set_language (opengl_context, pango_language_from_string ("en"));
690	/*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/	893	/*pango_context_set_base_dir (opengl_context, PANGO_DIRECTION_WEAK_LTR);*/
691	#endif	894	#endif
692	}	895	}
693		896
694	char *
695	SDL_GetError ()	897	char *SDL_GetError ()
696		898
697	int	899	void SDL_main_hack (SV *real_main)
698	SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)	900	PROTOTYPE: &
699		901
700	void	902	int SDL_Init (U32 flags)
		903
		904	int SDL_InitSubSystem (U32 flags)
		905
		906	void SDL_QuitSubSystem (U32 flags)
		907
701	SDL_Quit ()	908	void SDL_Quit ()
		909
		910	int SDL_GL_SetAttribute (int attr, int value)
		911	C_ARGS: (SDL_GLattr)attr, value
		912
		913	int SDL_GL_GetAttribute (int attr)
		914	CODE:
		915	if (SDL_GL_GetAttribute ((SDL_GLattr)attr, &RETVAL))
		916	XSRETURN_UNDEF;
		917	OUTPUT:
		918	RETVAL
702		919
703	void	920	void
704	SDL_ListModes (int rgb, int alpha)	921	SDL_ListModes (int rgb, int alpha)
705	PPCODE:	922	PPCODE:
706	{	923	{
…		…
718	SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);	935	SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
719	SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);	936	SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
720	SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);	937	SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
721		938
722	SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);	939	SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
723	#if SDL_VERSION_ATLEAST(1,2,10)
724	SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
725	SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);	940	SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
726	#endif
727		941
728	m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);	942	m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
729		943
730	if (m && m != (SDL_Rect **)-1)	944	if (m && m != (SDL_Rect **)-1)
731	while (*m)	945	while (*m)
732	{	946	{
733	if ((*m)->w >= 800 && (*m)->h >= 480)	947	if ((*m)->w >= 400 && (*m)->h >= 300)
734	{	948	{
735	AV *av = newAV ();	949	AV *av = newAV ();
736	av_push (av, newSViv ((*m)->w));	950	av_push (av, newSViv ((*m)->w));
737	av_push (av, newSViv ((*m)->h));	951	av_push (av, newSViv ((*m)->h));
738	av_push (av, newSViv (rgb));	952	av_push (av, newSViv (rgb));
…		…
761	);	975	);
762		976
763	if (RETVAL)	977	if (RETVAL)
764	{	978	{
765	av_clear (texture_av);	979	av_clear (texture_av);
766
767	SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
768	#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);	980	#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
769	#include "glfunc.h"	981	#include "glfunc.h"
770	#undef GL_FUNC	982	#undef GL_FUNC
		983	if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
		984	if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
771	}	985	}
772	}	986	}
773	OUTPUT:	987	OUTPUT:
774	RETVAL	988	RETVAL
		989
		990	void
		991	SDL_WM_SetCaption (const char *title, const char *icon)
775		992
776	void	993	void
777	SDL_GL_SwapBuffers ()	994	SDL_GL_SwapBuffers ()
778		995
779	char *	996	char *
780	SDL_GetKeyName (int sym)	997	SDL_GetKeyName (int sym)
		998	C_ARGS: (SDLKey)sym
781		999
782	int	1000	int
783	SDL_GetAppState ()	1001	SDL_GetAppState ()
784		1002
785	int	1003	int
786	SDL_GetModState ()	1004	SDL_GetModState ()
787		1005
		1006	int
		1007	SDL_WaitEvent ()
		1008	C_ARGS: 0
		1009
788	void	1010	void
		1011	SDL_PumpEvents ()
		1012
		1013	void
789	poll_events ()	1014	peep_events ()
790	PPCODE:	1015	PPCODE:
791	{	1016	{
792	SDL_Event ev;	1017	SDL_Event ev;
793		1018
794	SDL_PumpEvents ();	1019	SDL_PumpEvents ();
…		…
801	{	1026	{
802	case SDL_KEYDOWN:	1027	case SDL_KEYDOWN:
803	case SDL_KEYUP:	1028	case SDL_KEYUP:
804	hv_store (hv, "state", 5, newSViv (ev.key.state), 0);	1029	hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
805	hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);	1030	hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
806	hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod & MOD_MASK), 0);	1031	hv_store (hv, "mod", 3, newSViv (mod_munge (ev.key.keysym.mod)), 0);
807	hv_store (hv, "cmod", 4, newSViv (SDL_GetModState () & MOD_MASK), 0); /* current mode */	1032	hv_store (hv, "cmod", 4, newSViv (mod_munge (SDL_GetModState ())), 0); /* current mode */
808	hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);	1033	hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
809	break;	1034	break;
810		1035
811	case SDL_ACTIVEEVENT:	1036	case SDL_ACTIVEEVENT:
812	hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);	1037	hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
…		…
830	x = ev.motion.x;	1055	x = ev.motion.x;
831	y = ev.motion.y;	1056	y = ev.motion.y;
832	SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));	1057	SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
833	}	1058	}
834		1059
835	hv_store (hv, "mod", 3, newSViv (SDL_GetModState () & MOD_MASK), 0);	1060	hv_store (hv, "mod", 3, newSViv (mod_munge (SDL_GetModState ())), 0);
836	hv_store (hv, "state", 5, newSViv (state), 0);	1061	hv_store (hv, "state", 5, newSViv (state), 0);
837	hv_store (hv, "x", 1, newSViv (x), 0);	1062	hv_store (hv, "x", 1, newSViv (x), 0);
838	hv_store (hv, "y", 1, newSViv (y), 0);	1063	hv_store (hv, "y", 1, newSViv (y), 0);
839	hv_store (hv, "xrel", 4, newSViv (xrel), 0);	1064	hv_store (hv, "xrel", 4, newSViv (xrel), 0);
840	hv_store (hv, "yrel", 4, newSViv (yrel), 0);	1065	hv_store (hv, "yrel", 4, newSViv (yrel), 0);
…		…
860		1085
861	XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));	1086	XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
862	}	1087	}
863	}	1088	}
864		1089
		1090	char *
		1091	SDL_AudioDriverName ()
		1092	CODE:
		1093	{
		1094	char buf [256];
		1095	if (!SDL_AudioDriverName (buf, sizeof (buf)))
		1096	XSRETURN_UNDEF;
		1097
		1098	RETVAL = buf;
		1099	}
		1100	OUTPUT:
		1101	RETVAL
		1102
865	int	1103	int
866	Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)	1104	Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
867	POSTCALL:	1105	POSTCALL:
868	Mix_HookMusicFinished (music_finished);	1106	Mix_HookMusicFinished (music_finished);
869	Mix_ChannelFinished (channel_finished);	1107	Mix_ChannelFinished (channel_finished);
870		1108
871	void	1109	void
872	Mix_QuerySpec ()	1110	Mix_QuerySpec ()
…		…
931	add_font (char *file)	1169	add_font (char *file)
932	CODE:	1170	CODE:
933	RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);	1171	RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
934	OUTPUT:	1172	OUTPUT:
935	RETVAL	1173	RETVAL
		1174
		1175	void
		1176	IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
		1177
		1178	# MIX_INIT_MP3 gives smpeg + libstdc++ + libgcc_s
		1179	void
		1180	Mix_Init (int flags = MIX_INIT_MOD | MIX_INIT_OGG)
936		1181
937	void	1182	void
938	load_image_inline (SV *image_)	1183	load_image_inline (SV *image_)
939	ALIAS:	1184	ALIAS:
940	load_image_file = 1	1185	load_image_file = 1
…		…
986		1231
987	SDL_LockSurface (surface2);	1232	SDL_LockSurface (surface2);
988	EXTEND (SP, 6);	1233	EXTEND (SP, 6);
989	PUSHs (sv_2mortal (newSViv (surface2->w)));	1234	PUSHs (sv_2mortal (newSViv (surface2->w)));
990	PUSHs (sv_2mortal (newSViv (surface2->h)));	1235	PUSHs (sv_2mortal (newSViv (surface2->h)));
991	PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));	1236	PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
992	PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));	1237	PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
993	PUSHs (sv_2mortal (newSViv (GL_RGBA)));	1238	PUSHs (sv_2mortal (newSViv (GL_RGBA)));
994	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));	1239	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
995	SDL_UnlockSurface (surface2);	1240	SDL_UnlockSurface (surface2);
996		1241
…		…
1056	#if DEBUG	1301	#if DEBUG
1057	VALGRIND_DO_LEAK_CHECK;	1302	VALGRIND_DO_LEAK_CHECK;
1058	#endif	1303	#endif
1059	}	1304	}
1060		1305
		1306	int
		1307	SvREFCNT (SV *sv)
		1308	CODE:
		1309	RETVAL = SvREFCNT (sv);
		1310	OUTPUT:
		1311	RETVAL
		1312
1061	MODULE = Deliantra::Client PACKAGE = DC::Font	1313	MODULE = Deliantra::Client PACKAGE = DC::Font
1062		1314
1063	PROTOTYPES: DISABLE	1315	PROTOTYPES: DISABLE
1064		1316
1065	DC::Font	1317	DC::Font
1066	new_from_file (SV *class, char *path, int id = 0)	1318	new_from_file (SV *klass, char *path, int id = 0)
1067	CODE:	1319	CODE:
1068	{	1320	{
1069	int count;	1321	int count;
1070	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);	1322	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1071	RETVAL = pango_fc_font_description_from_pattern (pattern, 0);	1323	RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
…		…
1100	PROTOTYPE:	1352	PROTOTYPE:
1101	CODE:	1353	CODE:
1102	tc_restore ();	1354	tc_restore ();
1103		1355
1104	DC::Layout	1356	DC::Layout
1105	new (SV *class)	1357	new (SV *klass)
1106	CODE:	1358	CODE:
1107	New (0, RETVAL, 1, struct cf_layout);	1359	RETVAL = new cf_layout;
1108		1360
1109	RETVAL->pl = pango_layout_new (opengl_context);	1361	RETVAL->pl = pango_layout_new (opengl_context);
1110	RETVAL->r = 1.;	1362	RETVAL->r = 1.;
1111	RETVAL->g = 1.;	1363	RETVAL->g = 1.;
1112	RETVAL->b = 1.;	1364	RETVAL->b = 1.;
1113	RETVAL->a = 1.;	1365	RETVAL->a = 1.;
1114	RETVAL->base_height = MIN_FONT_HEIGHT;	1366	RETVAL->base_height = MIN_FONT_HEIGHT;
1115	RETVAL->font = 0;	1367	RETVAL->font = 0;
1116	RETVAL->rc = rc_alloc ();
1117		1368
1118	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);	1369	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1119	layout_update_font (RETVAL);	1370	layout_update_font (RETVAL);
1120	OUTPUT:	1371	OUTPUT:
1121	RETVAL	1372	RETVAL
1122		1373
1123	void	1374	void
1124	DESTROY (DC::Layout self)	1375	DESTROY (DC::Layout self)
1125	CODE:	1376	CODE:
1126	g_object_unref (self->pl);	1377	g_object_unref (self->pl);
1127	rc_free (self->rc);
1128	Safefree (self);	1378	delete self;
1129		1379
1130	void	1380	void
1131	set_text (DC::Layout self, SV *text_)	1381	set_text (DC::Layout self, SV *text_)
1132	CODE:	1382	CODE:
1133	{	1383	{
…		…
1259		1509
1260	void	1510	void
1261	set_height (DC::Layout self, int base_height)	1511	set_height (DC::Layout self, int base_height)
1262	CODE:	1512	CODE:
1263	if (self->base_height != base_height)	1513	if (self->base_height != base_height)
1264	{	1514	{
1265	self->base_height = base_height;	1515	self->base_height = base_height;
1266	layout_update_font (self);	1516	layout_update_font (self);
1267	}	1517	}
1268		1518
1269	void	1519	void
…		…
1387	}	1637	}
1388		1638
1389	void	1639	void
1390	render (DC::Layout self, float x, float y, int flags = 0)	1640	render (DC::Layout self, float x, float y, int flags = 0)
1391	CODE:	1641	CODE:
1392	rc_clear (self->rc);	1642	self->rc.clear ();
1393	pango_opengl_render_layout_subpixel (	1643	pango_opengl_render_layout_subpixel (
1394	self->pl,	1644	self->pl,
1395	self->rc,	1645	&self->rc,
1396	x * PANGO_SCALE, y * PANGO_SCALE,	1646	x * PANGO_SCALE, y * PANGO_SCALE,
1397	self->r, self->g, self->b, self->a,	1647	self->r, self->g, self->b, self->a,
1398	flags	1648	flags
1399	);	1649	);
1400	// we assume that context_change actually clears/frees stuff	1650	// we assume that context_change actually clears/frees stuff
…		…
1411	gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,	1661	gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1412	GL_ONE , GL_ONE_MINUS_SRC_ALPHA);	1662	GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1413	glEnable (GL_ALPHA_TEST);	1663	glEnable (GL_ALPHA_TEST);
1414	glAlphaFunc (GL_GREATER, 7.f / 255.f);	1664	glAlphaFunc (GL_GREATER, 7.f / 255.f);
1415		1665
1416	rc_draw (self->rc);	1666	self->rc.draw ();
1417		1667
1418	glDisable (GL_ALPHA_TEST);	1668	glDisable (GL_ALPHA_TEST);
1419	glDisable (GL_BLEND);	1669	glDisable (GL_BLEND);
1420	glDisable (GL_TEXTURE_2D);	1670	glDisable (GL_TEXTURE_2D);
1421	}	1671	}
…		…
1496	glDisable (GL_ALPHA_TEST);	1746	glDisable (GL_ALPHA_TEST);
1497	glDisable (GL_BLEND);	1747	glDisable (GL_BLEND);
1498	}	1748	}
1499	}	1749	}
1500		1750
		1751	void
		1752	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)
		1753	PROTOTYPE: @
		1754	CODE:
		1755	{
		1756	glEnable (GL_BLEND);
		1757	glBlendFunc (intensity ? GL_SRC_ALPHA : GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
		1758	glEnable (GL_TEXTURE_2D);
		1759	glBindTexture (GL_TEXTURE_2D, name1);
		1760
		1761	glColor3f (intensity, intensity, intensity);
		1762	glPushMatrix ();
		1763	glScalef (1./3, 1./3, 1.);
		1764
		1765	if (blend > 0.f)
		1766	{
		1767	float dx3 = dx * -3.f / w;
		1768	float dy3 = dy * -3.f / h;
		1769	GLfloat env_color[4] = { 0., 0., 0., blend };
		1770
		1771	/* interpolate the two shadow textures */
		1772	/* stage 0 == rgb(glcolor) + alpha(t0) */
		1773	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
		1774
		1775	/* stage 1 == rgb(glcolor) + alpha(interpolate t0, t1, texenv) */
		1776	gl.ActiveTexture (GL_TEXTURE1);
		1777	glEnable (GL_TEXTURE_2D);
		1778	glBindTexture (GL_TEXTURE_2D, name2);
		1779	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
		1780
		1781	/* rgb == rgb(glcolor) */
		1782	glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
		1783	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
		1784	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
		1785
		1786	/* alpha = interpolate t0, t1 by env_alpha */
		1787	glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
		1788
		1789	glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
		1790	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
		1791	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
		1792
		1793	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
		1794	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
		1795
		1796	glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
		1797	glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
		1798
		1799	glBegin (GL_QUADS);
		1800	gl.MultiTexCoord2f (GL_TEXTURE0, 0, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 ); glVertex2i (0, 0);
		1801	gl.MultiTexCoord2f (GL_TEXTURE0, 0, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 , dy3 + t); glVertex2i (0, h);
		1802	gl.MultiTexCoord2f (GL_TEXTURE0, s, t); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 + t); glVertex2i (w, h);
		1803	gl.MultiTexCoord2f (GL_TEXTURE0, s, 0); gl.MultiTexCoord2f (GL_TEXTURE1, dx3 + s, dy3 ); glVertex2i (w, 0);
		1804	glEnd ();
		1805
		1806	glDisable (GL_TEXTURE_2D);
		1807	gl.ActiveTexture (GL_TEXTURE0);
		1808	}
		1809	else
		1810	{
		1811	/* simple blending of one texture, also opengl <1.3 path */
		1812	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
		1813
		1814	glBegin (GL_QUADS);
		1815	glTexCoord2f (0, 0); glVertex2f (0, 0);
		1816	glTexCoord2f (0, t); glVertex2f (0, h);
		1817	glTexCoord2f (s, t); glVertex2f (w, h);
		1818	glTexCoord2f (s, 0); glVertex2f (w, 0);
		1819	glEnd ();
		1820	}
		1821
		1822	/* draw ?-marks or equivalent, this is very clumsy code :/ */
		1823	{
		1824	int x, y;
		1825	int dx3 = dx * 3;
		1826	int dy3 = dy * 3;
		1827
		1828	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		1829	glBindTexture (GL_TEXTURE_2D, hidden_tex);
		1830	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		1831	glTranslatef (-1., -1., 0);
		1832	glBegin (GL_QUADS);
		1833
		1834	for (y = 1; y < h; y += 3)
		1835	{
		1836	int y1 = y - dy3;
		1837	int y1valid = y1 >= 0 && y1 < h;
		1838
		1839	for (x = 1; x < w; x += 3)
		1840	{
		1841	int x1 = x - dx3;
		1842	uint8_t h1 = data1 [x + y * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
		1843	uint8_t h2;
		1844
		1845	if (y1valid && x1 >= 0 && x1 < w)
		1846	h2 = data2 [x1 + y1 * w] == DARKNESS_ADJUST (255 - FOW_DARKNESS);
		1847	else
		1848	h2 = 1; /* out of range == invisible */
		1849
		1850	if (h1 || h2)
		1851	{
		1852	float alpha = h1 == h2 ? 1.f : h1 ? 1.f - blend : blend;
		1853	glColor4f (1., 1., 1., alpha);
		1854
		1855	glTexCoord2f (0, 0.); glVertex2i (x , y );
		1856	glTexCoord2f (0, 1.); glVertex2i (x , y + 3);
		1857	glTexCoord2f (1, 1.); glVertex2i (x + 3, y + 3);
		1858	glTexCoord2f (1, 0.); glVertex2i (x + 3, y );
		1859	}
		1860	}
		1861	}
		1862	}
		1863
		1864	glEnd ();
		1865
		1866	glPopMatrix ();
		1867
		1868	glDisable (GL_TEXTURE_2D);
		1869	glDisable (GL_BLEND);
		1870	}
		1871
1501	IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)	1872	IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1502	CODE:	1873	CODE:
1503	{	1874	{
1504	GLint width;	1875	GLint width;
1505	glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);	1876	glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
…		…
1512	MODULE = Deliantra::Client PACKAGE = DC::Map	1883	MODULE = Deliantra::Client PACKAGE = DC::Map
1513		1884
1514	PROTOTYPES: DISABLE	1885	PROTOTYPES: DISABLE
1515		1886
1516	DC::Map	1887	DC::Map
1517	new (SV *class)	1888	new (SV *klass)
1518	CODE:	1889	CODE:
1519	New (0, RETVAL, 1, struct map);	1890	New (0, RETVAL, 1, mapgrid);
1520	RETVAL->x = 0;	1891	RETVAL->x = 0;
1521	RETVAL->y = 0;	1892	RETVAL->y = 0;
1522	RETVAL->w = 0;	1893	RETVAL->w = 0;
1523	RETVAL->h = 0;	1894	RETVAL->h = 0;
1524	RETVAL->ox = 0;	1895	RETVAL->ox = 0;
…		…
1561		1932
1562	void	1933	void
1563	set_smooth (DC::Map self, int face, int smooth, int level)	1934	set_smooth (DC::Map self, int face, int smooth, int level)
1564	CODE:	1935	CODE:
1565	{	1936	{
1566	tileid texid;	1937	tileid texid;
1567	maptex *tex;	1938	maptex *tex;
1568		1939
1569	if (face < 0 || face >= self->faces)	1940	if (face < 0 || face >= self->faces)
1570	return;	1941	return;
1571		1942
1572	if (smooth < 0 || smooth >= self->faces)	1943	if (smooth < 0 || smooth >= self->faces)
1573	return;	1944	return;
1574		1945
1575	texid = self->face2tile [face];	1946	texid = self->face2tile [face];
1576		1947
1577	if (!texid)	1948	if (!texid)
1578	return;	1949	return;
1579		1950
1580	tex = self->tex + texid;	1951	tex = self->tex + texid;
…		…
1609	//glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);	1980	//glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1610	// use uglier nearest interpolation because linear suffers	1981	// use uglier nearest interpolation because linear suffers
1611	// from transparent color bleeding and ugly wrapping effects.	1982	// from transparent color bleeding and ugly wrapping effects.
1612	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	1983	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1613	}	1984	}
		1985
		1986	void
		1987	expire_textures (DC::Map self, int texid, int count)
		1988	PPCODE:
		1989	for (; texid < self->texs && count; ++texid, --count)
		1990	{
		1991	maptex *tex = self->tex + texid;
		1992
		1993	if (tex->name)
		1994	{
		1995	if (tex->unused)
		1996	{
		1997	tex->name = 0;
		1998	tex->unused = 0;
		1999	XPUSHs (sv_2mortal (newSViv (texid)));
		2000	}
		2001	else
		2002	tex->unused = 1;
		2003	}
		2004	}
1614		2005
1615	int	2006	int
1616	ox (DC::Map self)	2007	ox (DC::Map self)
1617	ALIAS:	2008	ALIAS:
1618	oy = 1	2009	oy = 1
…		…
1650	self->ox += dx; self->x += dx;	2041	self->ox += dx; self->x += dx;
1651	self->oy += dy; self->y += dy;	2042	self->oy += dy; self->y += dy;
1652		2043
1653	while (self->y < 0)	2044	while (self->y < 0)
1654	{	2045	{
1655	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);	2046	prepend (self->row, self->rows, MAP_EXTEND_Y);
1656		2047
1657	self->rows += MAP_EXTEND_Y;	2048	self->rows += MAP_EXTEND_Y;
1658	self->y += MAP_EXTEND_Y;	2049	self->y += MAP_EXTEND_Y;
1659	}	2050	}
1660	}	2051	}
1661		2052
1662	SV *	2053	SV *
1663	map1a_update (DC::Map self, SV *data_, int extmap)	2054	map1a_update (DC::Map self, SV *data_)
1664	CODE:	2055	CODE:
1665	{	2056	{
1666	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);	2057	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1667	uint8_t *data_end = (uint8_t *)SvEND (data_);	2058	uint8_t *data_end = (uint8_t *)SvEND (data_);
1668	mapcell *cell;	2059	mapcell *cell;
…		…
1689		2080
1690	//TODO: don't trust server data to be in-range(!)	2081	//TODO: don't trust server data to be in-range(!)
1691		2082
1692	if (flags & 8)	2083	if (flags & 8)
1693	{	2084	{
		2085	uint8_t ext, cmd;
		2086
1694	if (extmap)	2087	do
1695	{	2088	{
1696	uint8_t ext, cmd;	2089	ext = *data++;
		2090	cmd = ext & 0x7f;
1697		2091
1698	do	2092	if (cmd < 4)
		2093	cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
		2094	else if (cmd == 5) // health
1699	{	2095	{
1700	ext = *data++;
1701	cmd = ext & 0x7f;
1702
1703	if (cmd < 4)
1704	cell->darkness = 255 - ext * 64 + 1;
1705	else if (cmd == 5) // health
1706	{
1707	cell->stat_width = 1;	2096	cell->stat_width = 1;
1708	cell->stat_hp = *data++;	2097	cell->stat_hp = *data++;
1709	}
1710	else if (cmd == 6) // monster width
1711	cell->stat_width = *data++ + 1;
1712	else if (cmd == 0x47)
1713	{
1714	if (*data == 1) cell->player = data [1];
1715	else if (*data == 2) cell->player = data [2] + (data [1] << 8);
1716	else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
1717	else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
1718
1719	data += *data + 1;
1720	}
1721	else if (cmd == 8) // cell flags
1722	cell->flags = *data++;
1723	else if (ext & 0x40) // unknown, multibyte => skip
1724	data += *data + 1;
1725	else
1726	data++;
1727	}	2098	}
1728	while (ext & 0x80);	2099	else if (cmd == 6) // monster width
		2100	cell->stat_width = *data++ + 1;
		2101	else if (cmd == 0x47)
		2102	{
		2103	if (*data == 1) cell->player = data [1];
		2104	else if (*data == 2) cell->player = data [2] + (data [1] << 8);
		2105	else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
		2106	else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
		2107
		2108	data += *data + 1;
		2109	}
		2110	else if (cmd == 8) // cell flags
		2111	cell->flags = *data++;
		2112	else if (ext & 0x40) // unknown, multibyte => skip
		2113	data += *data + 1;
		2114	else
		2115	data++;
1729	}	2116	}
1730	else	2117	while (ext & 0x80);
1731	cell->darkness = *data++ + 1;
1732	}	2118	}
1733		2119
1734	for (z = 0; z <= 2; ++z)	2120	for (z = 0; z <= 2; ++z)
1735	if (flags & (4 >> z))	2121	if (flags & (4 >> z))
1736	{	2122	{
…		…
1739	cell->tile [z] = self->face2tile [face];	2125	cell->tile [z] = self->face2tile [face];
1740		2126
1741	if (cell->tile [z])	2127	if (cell->tile [z])
1742	{	2128	{
1743	maptex *tex = self->tex + cell->tile [z];	2129	maptex *tex = self->tex + cell->tile [z];
		2130	tex->unused = 0;
1744	if (!tex->name)	2131	if (!tex->name)
1745	av_push (missing, newSViv (cell->tile [z]));	2132	av_push (missing, newSViv (cell->tile [z]));
1746		2133
1747	if (tex->smoothtile)	2134	if (tex->smoothtile)
1748	{	2135	{
1749	maptex *smooth = self->tex + tex->smoothtile;	2136	maptex *smooth = self->tex + tex->smoothtile;
		2137	smooth->unused = 0;
1750	if (!smooth->name)	2138	if (!smooth->name)
1751	av_push (missing, newSViv (tex->smoothtile));	2139	av_push (missing, newSViv (tex->smoothtile));
1752	}	2140	}
1753	}	2141	}
1754	}	2142	}
1755	}	2143	}
1756	else	2144	else
1757	cell->darkness = 0;	2145	CELL_CLEAR (cell);
1758	}	2146	}
1759	}	2147	}
1760	OUTPUT:	2148	OUTPUT:
1761	RETVAL	2149	RETVAL
1762		2150
…		…
1782	? self->row + y	2170	? self->row + y
1783	: 0;	2171	: 0;
1784		2172
1785	for (x = x0; x < x1; x++)	2173	for (x = x0; x < x1; x++)
1786	{	2174	{
1787	int r = 32, g = 32, b = 32, a = 192;	2175	unsigned int r = 32, g = 32, b = 32, a = 192;
1788		2176
1789	if (row && row->c0 <= x && x < row->c1)	2177	if (row && row->c0 <= x && x < row->c1)
1790	{	2178	{
1791	mapcell *cell = row->col + (x - row->c0);	2179	mapcell *cell = row->col + (x - row->c0);
1792		2180
…		…
1794	{	2182	{
1795	maptex tex = self->tex [cell->tile [z]];	2183	maptex tex = self->tex [cell->tile [z]];
1796	int a0 = 255 - tex.a;	2184	int a0 = 255 - tex.a;
1797	int a1 = tex.a;	2185	int a1 = tex.a;
1798		2186
1799	r = (r * a0 + tex.r * a1) / 255;	2187	r = div255 (r * a0 + tex.r * a1);
1800	g = (g * a0 + tex.g * a1) / 255;	2188	g = div255 (g * a0 + tex.g * a1);
1801	b = (b * a0 + tex.b * a1) / 255;	2189	b = div255 (b * a0 + tex.b * a1);
1802	a = (a * a0 + tex.a * a1) / 255;	2190	a = div255 (a * a0 + tex.a * a1);
1803	}	2191	}
1804	}	2192	}
1805		2193
1806	*map++ = (r )	2194	*map++ = (r )
1807	| (g << 8)	2195	| (g << 8)
1808	| (b << 16)	2196	| (b << 16)
1809	| (a << 24);	2197	| (a << 24);
1810	}	2198	}
1811	}	2199	}
1812		2200
1813	RETVAL = map_sv;	2201	RETVAL = map_sv;
1814	}	2202	}
1815	OUTPUT:	2203	OUTPUT:
1816	RETVAL	2204	RETVAL
1817		2205
1818	void	2206	void
1819	draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int pdx = 0, int pdy = 0)	2207	draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
1820	CODE:	2208	CODE:
1821	{	2209	{
1822	int x, y, z;	2210	int x, y, z;
1823		2211
1824	HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1825	uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1826	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)	2212	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
1827	smooth_key skey;
1828	int pl_x, pl_y;	2213	int pl_x, pl_y;
1829	maptex pl_tex;	2214	maptex pl_tex;
1830	rc_t *rc = rc_alloc ();	2215	rc_t rc;
		2216	rc_t rc_ov;
1831	rc_key_t key;	2217	rc_key_t key;
1832	rc_array_t *arr;	2218	rc_t::array_t *arr;
1833		2219
1834	pl_tex.name = 0;	2220	pl_tex.name = 0;
1835		2221
1836	// thats current max. sorry.	2222	// that's current max. sorry.
1837	if (sw > 255) sw = 255;	2223	if (sw > 255) sw = 255;
1838	if (sh > 255) sh = 255;	2224	if (sh > 255) sh = 255;
1839
1840	// clear key, in case of extra padding
1841	memset (&skey, 0, sizeof (skey));
1842		2225
1843	memset (&key, 0, sizeof (key));	2226	memset (&key, 0, sizeof (key));
1844	key.r = 255;	2227	key.r = 255;
1845	key.g = 255;	2228	key.g = 255;
1846	key.b = 255;	2229	key.b = 255;
1847	key.a = 255;	2230	key.a = 255;
1848	key.mode = GL_QUADS;	2231	key.mode = GL_QUADS;
1849	key.format = GL_T2F_V3F;	2232	key.format = GL_T2F_V3F;
1850	key.texname = -1;
1851		2233
1852	mx += self->x;	2234	mx += self->x;
1853	my += self->y;	2235	my += self->y;
1854		2236
1855	// first pass: determine smooth_max	2237	// first pass: determine smooth_max
1856	// rather ugly, if you ask me	2238	// rather ugly, if you ask me
1857	// could also be stored inside mapcell and updated on change	2239	// could also be stored inside mapcell and updated on change
1858	memset (smooth_max, 0, sizeof (smooth_max));	2240	memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
1859		2241
1860	for (y = 0; y < sh; y++)	2242	for (y = 0; y < sh; y++)
1861	if (0 <= y + my && y + my < self->rows)	2243	if (0 <= y + my && y + my < self->rows)
1862	{	2244	{
1863	maprow *row = self->row + (y + my);	2245	maprow *row = self->row + (y + my);
…		…
1878	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	2260	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1879	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	2261	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1880		2262
1881	for (z = 0; z <= 2; z++)	2263	for (z = 0; z <= 2; z++)
1882	{	2264	{
1883	memset (smooth_level, 0, sizeof (smooth_level));	2265	std::bitset<256> smooth_level; // one bit for every possible smooth level
		2266	smooth_key skey;
		2267	smooth_hash smooth;
		2268	key.texname = -1;
1884		2269
1885	for (y = 0; y < sh; y++)	2270	for (y = 0; y < sh; y++)
1886	if (0 <= y + my && y + my < self->rows)	2271	if (0 <= y + my && y + my < self->rows)
1887	{	2272	{
1888	maprow *row = self->row + (y + my);	2273	maprow *row = self->row + (y + my);
…		…
1894	tileid tile = cell->tile [z];	2279	tileid tile = cell->tile [z];
1895		2280
1896	if (tile)	2281	if (tile)
1897	{	2282	{
1898	maptex tex = self->tex [tile];	2283	maptex tex = self->tex [tile];
1899	int px = (x + 1) * T - tex.w;	2284	int px, py;
1900	int py = (y + 1) * T - tex.h;
1901		2285
1902	if (key.texname != tex.name)	2286	if (key.texname != tex.name)
1903	{	2287	{
		2288	self->tex [tile].unused = 0;
		2289
1904	if (!tex.name)	2290	if (!tex.name)
1905	tex = self->tex [2]; /* missing, replace by noface */	2291	tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
1906		2292
1907	key.texname = tex.name;	2293	key.texname = tex.name;
1908	arr = rc_array (rc, &key);	2294	arr = &rc.array (key);
1909	}	2295	}
1910		2296
		2297	px = (x + 1) * Th - tex.w;
		2298	py = (y + 1) * Tw - tex.h;
		2299
1911	if (expect_false (cell->player == player) && expect_false (z == 2))	2300	if (ecb_expect_false (cell->player == player) && ecb_expect_false (z == 2))
1912	{	2301	{
1913	pl_x = px;	2302	pl_x = px;
1914	pl_y = py;	2303	pl_y = py;
1915	pl_tex = tex;	2304	pl_tex = tex;
1916	continue;	2305	continue;
1917	}	2306	}
1918		2307
1919	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2308	arr->t2f_v3f (0 , 0 , px , py , 0);
1920	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);	2309	arr->t2f_v3f (0 , tex.t, px , py + tex.h, 0);
1921	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);	2310	arr->t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
1922	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2311	arr->t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
1923
1924	if (expect_false (cell->flags) && expect_false (z == 2))
1925	{
1926	// overlays such as the speech bubble, probably more to come
1927	if (cell->flags & 1)
1928	{
1929	maptex tex = self->tex [1];
1930	int px = x * T + T * 2 / 32;
1931	int py = y * T - T * 6 / 32;
1932
1933	if (tex.name)
1934	{
1935	if (key.texname != tex.name)
1936	{
1937	key.texname = tex.name;
1938	arr = rc_array (rc, &key);
1939	}
1940
1941	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
1942	rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0);
1943	rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
1944	rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0);
1945	}
1946	}
1947	}
1948		2312
1949	// update smooth hash	2313	// update smooth hash
1950	if (tex.smoothtile)	2314	if (tex.smoothtile)
1951	{	2315	{
1952	skey.tile = tex.smoothtile;	2316	skey.tile = tex.smoothtile;
1953	skey.level = tex.smoothlevel;	2317	skey.level = tex.smoothlevel;
1954		2318
1955	smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);	2319	smooth_level[tex.smoothlevel] = 1;
1956		2320
1957	// add bits to current tile and all neighbours. skey.x|y is	2321	// add bits to current tile and all neighbours. skey.x|y is
1958	// shifted +1|+1 so we always stay positive.	2322	// shifted +1|+1 so we always stay positive.
1959		2323
1960	// bits is ___n cccc CCCC bbbb	2324	// bits is ___n cccc CCCC bbbb
…		…
1968		2332
1969	// corners: 1 ┛· 2 ·┗ 4 ·· 8 ··	2333	// corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1970	// ·· ·· ·┏ ┓·	2334	// ·· ·· ·┏ ┓·
1971		2335
1972	// full tile	2336	// full tile
1973	skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);	2337	skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x1000);
1974		2338
1975	// borders	2339	// borders
1976	skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);	2340	skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0091);
1977	skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);	2341	skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0032);
1978	skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);	2342	skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0064);
1979	skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);	2343	skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, skey, 0x00c8);
1980		2344
1981	// corners	2345	// corners
1982	skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);	2346	skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0100);
1983	skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);	2347	skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0200);
1984	skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);	2348	skey.x = x ; skey.y = y ; smooth_or_bits (smooth, skey, 0x0400);
1985	skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);	2349	skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, skey, 0x0800);
		2350	}
		2351	}
		2352
		2353	if (ecb_expect_false (z == 2) && ecb_expect_false (cell->flags))
		2354	{
		2355	// overlays such as the speech bubble, probably more to come
		2356	if (cell->flags & 1)
		2357	{
		2358	rc_key_t key_ov = key;
		2359	maptex tex = self->tex[TEXID_SPEECH];
		2360	int px = x * Tw + Tw * 2 / 32;
		2361	int py = y * Th - Th * 6 / 32;
		2362
		2363	key_ov.texname = tex.name;
		2364	rc_t::array_t &arr = rc_ov.array (key_ov);
		2365
		2366	arr.t2f_v3f (0 , 0 , px , py , 0);
		2367	arr.t2f_v3f (0 , tex.t, px , py + Th, 0);
		2368	arr.t2f_v3f (tex.s, tex.t, px + Tw, py + Th, 0);
		2369	arr.t2f_v3f (tex.s, 0 , px + Tw, py , 0);
1986	}	2370	}
1987	}	2371	}
1988	}	2372	}
1989	}	2373	}
1990		2374
1991	rc_draw (rc);	2375	rc.draw ();
1992	rc_clear (rc);	2376	rc.clear ();
1993		2377
1994	// go through all smoothlevels, lowest to highest, then draw.	2378	// go through all smoothlevels, lowest to highest, then draw.
1995	// this is basically counting sort	2379	// this is basically counting sort
1996	{	2380	{
1997	int w, b;	2381	int w, b;
1998		2382
1999	glEnable (GL_TEXTURE_2D);	2383	glEnable (GL_TEXTURE_2D);
2000	glBegin (GL_QUADS);	2384	glBegin (GL_QUADS);
2001	for (w = 0; w < 256 / 32; ++w)	2385	for (int level = 0; level < smooth_level.size (); ++level)
		2386	if (smooth_level[level])
		2387	for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
2002	{	2388	{
2003	uint32_t smask = smooth_level [w];	2389	smooth_key &skey = it->first;
2004	if (smask)	2390	IV bits = it->second;
2005	for (b = 0; b < 32; ++b)	2391
2006	if (smask & (((uint32_t)1) << b))	2392	if (!(bits & 0x1000)
		2393	&& skey.level == level
		2394	&& level > smooth_max [skey.x][skey.y])
2007	{	2395	{
2008	int level = (w << 5) | b;	2396	maptex tex = self->tex [skey.tile];
		2397	int px = (((int)skey.x) - 1) * Tw;
		2398	int py = (((int)skey.y) - 1) * Th;
		2399	int border = bits & 15;
		2400	int corner = (bits >> 8) & ~(bits >> 4) & 15;
		2401	float dx = tex.s * .0625f; // 16 images/row
		2402	float dy = tex.t * .5f ; // 2 images/column
		2403
2009	HE *he;	2404	if (tex.name)
2010
2011	hv_iterinit (smooth);
2012	while ((he = hv_iternext (smooth)))
2013	{	2405	{
2014	smooth_key *skey = (smooth_key *)HeKEY (he);	2406	// this time avoiding texture state changes
2015	IV bits = SvIVX (HeVAL (he));	2407	// save gobs of state changes.
2016		2408	if (key.texname != tex.name)
2017	if (!(bits & 0x1000)
2018	&& skey->level == level
2019	&& level > smooth_max [skey->x][skey->y])
2020	{	2409	{
2021	maptex tex = self->tex [skey->tile];	2410	self->tex [skey.tile].unused = 0;
2022	int px = (((int)skey->x) - 1) * T;
2023	int py = (((int)skey->y) - 1) * T;
2024	int border = bits & 15;
2025	int corner = (bits >> 8) & ~(bits >> 4) & 15;
2026	float dx = tex.s * .0625f; // 16 images/row
2027	float dy = tex.t * .5f ; // 2 images/column
2028		2411
2029	if (tex.name)
2030	{
2031	// this time avoiding texture state changes
2032	// save gobs of state changes.
2033	if (key.texname != tex.name)
2034	{
2035	glEnd ();	2412	glEnd ();
2036	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);	2413	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2037	glBegin (GL_QUADS);	2414	glBegin (GL_QUADS);
2038	}	2415	}
2039		2416
2040	if (border)	2417	if (border)
2041	{	2418	{
2042	float ox = border * dx;	2419	float ox = border * dx;
2043		2420
2044	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );	2421	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2045	glTexCoord2f (ox , dy ); glVertex2i (px , py + T);	2422	glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2046	glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T);	2423	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2047	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py );	2424	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2048	}	2425	}
2049		2426
2050	if (corner)	2427	if (corner)
2051	{	2428	{
2052	float ox = corner * dx;	2429	float ox = corner * dx;
2053		2430
2054	glTexCoord2f (ox , dy ); glVertex2i (px , py );	2431	glTexCoord2f (ox , dy ); glVertex2i (px , py );
2055	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T);	2432	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2056	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);	2433	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2057	glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py );	2434	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2058	}
2059	}
2060	}	2435	}
2061	}	2436	}
2062	}	2437	}
2063	}	2438	}
2064		2439
2065	glEnd ();	2440	glEnd ();
2066	glDisable (GL_TEXTURE_2D);	2441	glDisable (GL_TEXTURE_2D);
2067	key.texname = -1;	2442	key.texname = -1;
2068	}	2443	}
2069
2070	hv_clear (smooth);
2071	}	2444	}
2072		2445
2073	if (pl_tex.name)	2446	if (pl_tex.name)
2074	{	2447	{
2075	maptex tex = pl_tex;	2448	maptex tex = pl_tex;
2076	int px = pl_x + pdx;	2449	int px = pl_x + sdx;
2077	int py = pl_y + pdy;	2450	int py = pl_y + sdy;
2078		2451
2079	key.texname = tex.name;	2452	key.texname = tex.name;
2080	arr = rc_array (rc, &key);	2453	rc_t::array_t &arr = rc.array (key);
2081		2454
2082	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2455	arr.t2f_v3f (0 , 0 , px , py , 0);
2083	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);	2456	arr.t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2084	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);	2457	arr.t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2085	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2458	arr.t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2086		2459
2087	rc_draw (rc);	2460	rc.draw ();
2088	}	2461	}
2089		2462
		2463	rc_ov.draw ();
		2464	rc_ov.clear ();
		2465
2090	glDisable (GL_BLEND);	2466	glDisable (GL_BLEND);
2091	rc_free (rc);
2092		2467
2093	// top layer: overlays such as the health bar	2468	// top layer: overlays such as the health bar
2094	for (y = 0; y < sh; y++)	2469	for (y = 0; y < sh; y++)
2095	if (0 <= y + my && y + my < self->rows)	2470	if (0 <= y + my && y + my < self->rows)
2096	{	2471	{
…		…
2099	for (x = 0; x < sw; x++)	2474	for (x = 0; x < sw; x++)
2100	if (row->c0 <= x + mx && x + mx < row->c1)	2475	if (row->c0 <= x + mx && x + mx < row->c1)
2101	{	2476	{
2102	mapcell *cell = row->col + (x + mx - row->c0);	2477	mapcell *cell = row->col + (x + mx - row->c0);
2103		2478
2104	int px = x * T;	2479	int px = x * Tw;
2105	int py = y * T;	2480	int py = y * Th;
		2481
		2482	if (ecb_expect_false (cell->player == player))
		2483	{
		2484	px += sdx;
		2485	py += sdy;
		2486	}
2106		2487
2107	if (cell->stat_hp)	2488	if (cell->stat_hp)
2108	{	2489	{
2109	int width = cell->stat_width * T;	2490	int width = cell->stat_width * Tw;
2110	int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;	2491	int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2111		2492
2112	glColor3ub (0, 0, 0);	2493	glColor3ub (0, 0, 0);
2113	glRectf (px + 1, py - thick - 2,	2494	glRectf (px + 1, py - thick - 2,
2114	px + width - 1, py);	2495	px + width - 1, py);
2115		2496
…		…
2121	}	2502	}
2122	}	2503	}
2123	}	2504	}
2124		2505
2125	void	2506	void
2126	draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data)	2507	draw_magicmap (DC::Map self, int w, int h, unsigned char *data)
2127	CODE:	2508	CODE:
2128	{	2509	{
2129	static float color[16][3] = {	2510	static float color[16][3] = {
2130	{ 0.00F, 0.00F, 0.00F },	2511	{ 0.00f, 0.00f, 0.00f },
2131	{ 1.00F, 1.00F, 1.00F },	2512	{ 1.00f, 1.00f, 1.00f },
2132	{ 0.00F, 0.00F, 0.55F },	2513	{ 0.00f, 0.00f, 0.55f },
2133	{ 1.00F, 0.00F, 0.00F },	2514	{ 1.00f, 0.00f, 0.00f },
2134		2515
2135	{ 1.00F, 0.54F, 0.00F },	2516	{ 1.00f, 0.54f, 0.00f },
2136	{ 0.11F, 0.56F, 1.00F },	2517	{ 0.11f, 0.56f, 1.00f },
2137	{ 0.93F, 0.46F, 0.00F },	2518	{ 0.93f, 0.46f, 0.00f },
2138	{ 0.18F, 0.54F, 0.34F },	2519	{ 0.18f, 0.54f, 0.34f },
2139		2520
2140	{ 0.56F, 0.73F, 0.56F },	2521	{ 0.56f, 0.73f, 0.56f },
2141	{ 0.80F, 0.80F, 0.80F },	2522	{ 0.80f, 0.80f, 0.80f },
2142	{ 0.55F, 0.41F, 0.13F },	2523	{ 0.55f, 0.41f, 0.13f },
2143	{ 0.99F, 0.77F, 0.26F },	2524	{ 0.99f, 0.77f, 0.26f },
2144		2525
2145	{ 0.74F, 0.65F, 0.41F },	2526	{ 0.74f, 0.65f, 0.41f },
2146		2527
2147	{ 0.00F, 1.00F, 1.00F },	2528	{ 0.00f, 1.00f, 1.00f },
2148	{ 1.00F, 0.00F, 1.00F },	2529	{ 1.00f, 0.00f, 1.00f },
2149	{ 1.00F, 1.00F, 0.00F },	2530	{ 1.00f, 1.00f, 0.00f },
2150	};	2531	};
2151		2532
2152	int x, y;	2533	int x, y;
2153		2534
2154	glEnable (GL_TEXTURE_2D);	2535	glEnable (GL_TEXTURE_2D);
		2536	/* GL_REPLACE would be correct, as we don't need to modulate alpha,
		2537	* but the nvidia driver (185.18.14) mishandles alpha textures
		2538	* and takes the colour from god knows where instead of using
		2539	* Cp. MODULATE results in the same colour, but slightly different
		2540	* alpha, but atcually gives us the correct colour with nvidia.
		2541	*/
2155	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	2542	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2156	glEnable (GL_BLEND);	2543	glEnable (GL_BLEND);
2157	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	2544	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2158	glBegin (GL_QUADS);	2545	glBegin (GL_QUADS);
2159		2546
2160	for (y = 0; y < h; y++)	2547	for (y = 0; y < h; y++)
…		…
2164		2551
2165	if (m)	2552	if (m)
2166	{	2553	{
2167	float *c = color [m & 15];	2554	float *c = color [m & 15];
2168		2555
2169	float tx1 = m & 0x40 ? 0.5 : 0.;	2556	float tx1 = m & 0x40 ? 0.5f : 0.f;
2170	float tx2 = tx1 + 0.5;	2557	float tx2 = tx1 + 0.5f;
2171		2558
2172	glColor4f (c[0], c[1], c[2], 0.75);	2559	glColor4f (c[0], c[1], c[2], 1);
2173	glTexCoord2f (tx1, 0.); glVertex2i (x , y );	2560	glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2174	glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);	2561	glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2175	glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);	2562	glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2176	glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );	2563	glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2177	}	2564	}
…		…
2185	void	2572	void
2186	fow_texture (DC::Map self, int mx, int my, int sw, int sh)	2573	fow_texture (DC::Map self, int mx, int my, int sw, int sh)
2187	PPCODE:	2574	PPCODE:
2188	{	2575	{
2189	int x, y;	2576	int x, y;
2190	int sw1 = sw + 2;	2577	int sw1 = sw + 2;
2191	int sh1 = sh + 2;	2578	int sh1 = sh + 2;
2192	int sh3 = sh * 3;	2579	int sh3 = sh * 3;
2193	int sw34 = (sw * 3 + 3) & ~3;	2580	int sw3 = sw * 3;
		2581	SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
		2582	uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2194	uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);	2583	uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2195	SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));	2584	memset (darkness1, 0, sw1*sh1);
2196	uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2197		2585
2198	SvPOK_only (darkness3_sv);	2586	SvPOK_only (darkness3_sv);
2199	SvCUR_set (darkness3_sv, sw34 * sh3);	2587	SvCUR_set (darkness3_sv, sw3 * sh3);
2200		2588
2201	mx += self->x - 1;	2589	mx += self->x - 1;
2202	my += self->y - 1;	2590	my += self->y - 1;
2203
2204	memset (darkness1, 255, sw1 * sh1);
2205		2591
2206	for (y = 0; y < sh1; y++)	2592	for (y = 0; y < sh1; y++)
2207	if (0 <= y + my && y + my < self->rows)	2593	if (0 <= y + my && y + my < self->rows)
2208	{	2594	{
2209	maprow *row = self->row + (y + my);	2595	maprow *row = self->row + (y + my);
…		…
2212	if (row->c0 <= x + mx && x + mx < row->c1)	2598	if (row->c0 <= x + mx && x + mx < row->c1)
2213	{	2599	{
2214	mapcell *cell = row->col + (x + mx - row->c0);	2600	mapcell *cell = row->col + (x + mx - row->c0);
2215		2601
2216	darkness1 [y * sw1 + x] = cell->darkness	2602	darkness1 [y * sw1 + x] = cell->darkness
2217	? 255 - (cell->darkness - 1)	2603	? DARKNESS_ADJUST (255 - (cell->darkness - 1))
2218	: 255 - FOW_DARKNESS;	2604	: DARKNESS_ADJUST (255 - FOW_DARKNESS);
2219	}	2605	}
2220	}	2606	}
2221		2607
2222	for (y = 0; y < sh; ++y)	2608	for (y = 0; y < sh; ++y)
2223	for (x = 0; x < sw; ++x)	2609	for (x = 0; x < sw; ++x)
…		…
2242		2628
2243	uint8_t r13 = (d13 + d23 + d12) / 3;	2629	uint8_t r13 = (d13 + d23 + d12) / 3;
2244	uint8_t r23 = d23;	2630	uint8_t r23 = d23;
2245	uint8_t r33 = (d23 + d33 + d32) / 3;	2631	uint8_t r33 = (d23 + d33 + d32) / 3;
2246		2632
2247	darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);	2633	darkness3 [(y * 3 ) * sw3 + (x * 3 )] = MAX (d22, r11);
2248	darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);	2634	darkness3 [(y * 3 ) * sw3 + (x * 3 + 1)] = MAX (d22, r21);
2249	darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);	2635	darkness3 [(y * 3 ) * sw3 + (x * 3 + 2)] = MAX (d22, r31);
2250	darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);	2636	darkness3 [(y * 3 + 1) * sw3 + (x * 3 )] = MAX (d22, r12);
2251	darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);	2637	darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 1)] = MAX (d22, r22); /* this MUST be == d22 */
2252	darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);	2638	darkness3 [(y * 3 + 1) * sw3 + (x * 3 + 2)] = MAX (d22, r32);
2253	darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);	2639	darkness3 [(y * 3 + 2) * sw3 + (x * 3 )] = MAX (d22, r13);
2254	darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);	2640	darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 1)] = MAX (d22, r23);
2255	darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);	2641	darkness3 [(y * 3 + 2) * sw3 + (x * 3 + 2)] = MAX (d22, r33);
2256	}	2642	}
2257		2643
2258	free (darkness1);	2644	free (darkness1);
2259		2645
2260	EXTEND (SP, 3);	2646	EXTEND (SP, 3);
2261	PUSHs (sv_2mortal (newSViv (sw34)));	2647	PUSHs (sv_2mortal (newSViv (sw3)));
2262	PUSHs (sv_2mortal (newSViv (sh3)));	2648	PUSHs (sv_2mortal (newSViv (sh3)));
2263	PUSHs (darkness3_sv);	2649	PUSHs (darkness3_sv);
2264	}	2650	}
2265		2651
2266	SV *	2652	SV *
…		…
2329	else	2715	else
2330	*data++ = 0;	2716	*data++ = 0;
2331	}	2717	}
2332	}	2718	}
2333		2719
2334	/* if size is w*h + 5 then no data has been found */	2720	/* if size is w*h + 5 then no data has been found */
2335	if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)	2721	if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2336	{	2722	{
2337	SvPOK_only (data_sv);	2723	SvPOK_only (data_sv);
2338	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));	2724	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2339	}	2725	}
2340		2726
2341	RETVAL = data_sv;	2727	RETVAL = data_sv;
2342	}	2728	}
2343	OUTPUT:	2729	OUTPUT:
2344	RETVAL	2730	RETVAL
2345		2731
2346	void	2732	void
…		…
2353	STRLEN len;	2739	STRLEN len;
2354	uint8_t *data, *end;	2740	uint8_t *data, *end;
2355		2741
2356	len = SvLEN (data_sv);	2742	len = SvLEN (data_sv);
2357	SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more	2743	SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2358	data = SvPVbyte_nolen (data_sv);	2744	data = (uint8_t *)SvPVbyte_nolen (data_sv);
2359	end = data + len + 8;	2745	end = data + len + 8;
2360		2746
2361	if (len < 5)	2747	if (len < 5)
2362	XSRETURN_EMPTY;	2748	XSRETURN_EMPTY;
2363		2749
…		…
2424	}	2810	}
2425		2811
2426	MODULE = Deliantra::Client PACKAGE = DC::RW	2812	MODULE = Deliantra::Client PACKAGE = DC::RW
2427		2813
2428	DC::RW	2814	DC::RW
2429	new (SV *class, SV *data_sv)	2815	new (SV *klass, SV *data_sv)
2430	CODE:	2816	CODE:
2431	{	2817	{
2432	STRLEN datalen;	2818	STRLEN datalen;
2433	char *data = SvPVbyte (data_sv, datalen);	2819	char *data = SvPVbyte (data_sv, datalen);
2434		2820
…		…
2436	}	2822	}
2437	OUTPUT:	2823	OUTPUT:
2438	RETVAL	2824	RETVAL
2439		2825
2440	DC::RW	2826	DC::RW
2441	new_from_file (SV *class, const char *path, const char *mode = "rb")	2827	new_from_file (SV *klass, const char *path, const char *mode = "rb")
2442	CODE:	2828	CODE:
2443	RETVAL = SDL_RWFromFile (path, mode);	2829	RETVAL = SDL_RWFromFile (path, mode);
2444	OUTPUT:	2830	OUTPUT:
2445	RETVAL	2831	RETVAL
2446		2832
…		…
2464	if (RETVAL < 0)	2850	if (RETVAL < 0)
2465	{	2851	{
2466	RETVAL = Mix_GroupOldest (-1);	2852	RETVAL = Mix_GroupOldest (-1);
2467		2853
2468	if (RETVAL < 0)	2854	if (RETVAL < 0)
		2855	{
		2856	// happens sometimes, maybe it just stopped playing(?)
		2857	RETVAL = Mix_GroupAvailable (-1);
		2858
		2859	if (RETVAL < 0)
2469	XSRETURN_UNDEF;	2860	XSRETURN_UNDEF;
2470		2861	}
		2862	else
2471	Mix_HaltChannel (RETVAL);	2863	Mix_HaltChannel (RETVAL);
2472	}	2864	}
2473		2865
2474	Mix_UnregisterAllEffects (RETVAL);	2866	Mix_UnregisterAllEffects (RETVAL);
2475	Mix_Volume (RETVAL, 128);	2867	Mix_Volume (RETVAL, 128);
2476	}	2868	}
…		…
2523	void	2915	void
2524	set_position_r (DC::Channel self, int dx, int dy, int maxdistance)	2916	set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
2525	CODE:	2917	CODE:
2526	{	2918	{
2527	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));	2919	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
2528	int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI);	2920	int angle = atan2f (dx, -dy) * 180.f / (float)M_PI + 360.f;
2529	Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));	2921	Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
2530	}	2922	}
2531		2923
2532	void	2924	void
2533	set_reverse_stereo (DC::Channel self, int flip)	2925	set_reverse_stereo (DC::Channel self, int flip)
…		…
2536		2928
2537	MODULE = Deliantra::Client PACKAGE = DC::MixChunk	2929	MODULE = Deliantra::Client PACKAGE = DC::MixChunk
2538		2930
2539	PROTOTYPES: DISABLE	2931	PROTOTYPES: DISABLE
2540		2932
		2933	void
		2934	decoders ()
		2935	PPCODE:
		2936	#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
		2937	int i, num = Mix_GetNumChunkDecoders ();
		2938	EXTEND (SP, num);
		2939	for (i = 0; i < num; ++i)
		2940	PUSHs (sv_2mortal (newSVpv (Mix_GetChunkDecoder (i), 0)));
		2941	#else
		2942	XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
		2943	#endif
		2944
2541	DC::MixChunk	2945	DC::MixChunk
2542	new (SV *class, DC::RW rwops)	2946	new (SV *klass, DC::RW rwops)
2543	CODE:	2947	CODE:
2544	RETVAL = Mix_LoadWAV_RW (rwops, 1);	2948	RETVAL = Mix_LoadWAV_RW (rwops, 1);
2545	OUTPUT:	2949	OUTPUT:
2546	RETVAL	2950	RETVAL
2547		2951
…		…
2577	OUTPUT:	2981	OUTPUT:
2578	RETVAL	2982	RETVAL
2579		2983
2580	MODULE = Deliantra::Client PACKAGE = DC::MixMusic	2984	MODULE = Deliantra::Client PACKAGE = DC::MixMusic
2581		2985
		2986	void
		2987	decoders ()
		2988	PPCODE:
		2989	#if SDL_MIXER_MAJOR_VERSION > 1 || SDL_MIXER_MINOR_VERSION > 2 || SDL_MIXER_PATCHLEVEL >= 10
		2990	int i, num = Mix_GetNumMusicDecoders ();
		2991	EXTEND (SP, num);
		2992	for (i = 0; i < num; ++i)
		2993	PUSHs (sv_2mortal (newSVpv (Mix_GetMusicDecoder (i), 0)));
		2994	#else
		2995	XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
		2996	#endif
		2997
2582	int	2998	int
2583	volume (int volume = -1)	2999	volume (int volume = -1)
2584	PROTOTYPE: ;$	3000	PROTOTYPE: ;$
2585	CODE:	3001	CODE:
2586	if (items > 0)	3002	if (items > 0)
…		…
2597	void	3013	void
2598	halt ()	3014	halt ()
2599	CODE:	3015	CODE:
2600	Mix_HaltMusic ();	3016	Mix_HaltMusic ();
2601		3017
		3018	int
		3019	playing ()
		3020	CODE:
		3021	RETVAL = Mix_PlayingMusic ();
		3022	OUTPUT:
		3023	RETVAL
		3024
2602	DC::MixMusic	3025	DC::MixMusic
2603	new (SV *class, DC::RW rwops)	3026	new (SV *klass, DC::RW rwops)
2604	CODE:	3027	CODE:
2605	RETVAL = Mix_LoadMUS_RW (rwops);	3028	RETVAL = Mix_LoadMUS_RW (rwops);
2606	OUTPUT:	3029	OUTPUT:
2607	RETVAL	3030	RETVAL
2608		3031
…		…
2636	} *civ, const_iv[] = {	3059	} *civ, const_iv[] = {
2637	# define const_iv(name) { # name, (IV)name }	3060	# define const_iv(name) { # name, (IV)name }
2638	const_iv (GL_VENDOR),	3061	const_iv (GL_VENDOR),
2639	const_iv (GL_VERSION),	3062	const_iv (GL_VERSION),
2640	const_iv (GL_EXTENSIONS),	3063	const_iv (GL_EXTENSIONS),
		3064	const_iv (GL_MAX_TEXTURE_UNITS),
2641	const_iv (GL_COLOR_MATERIAL),	3065	const_iv (GL_COLOR_MATERIAL),
2642	const_iv (GL_SMOOTH),	3066	const_iv (GL_SMOOTH),
2643	const_iv (GL_FLAT),	3067	const_iv (GL_FLAT),
2644	const_iv (GL_DITHER),	3068	const_iv (GL_DITHER),
2645	const_iv (GL_BLEND),	3069	const_iv (GL_BLEND),
…		…
2657	const_iv (GL_ZERO),	3081	const_iv (GL_ZERO),
2658	const_iv (GL_SRC_ALPHA),	3082	const_iv (GL_SRC_ALPHA),
2659	const_iv (GL_DST_ALPHA),	3083	const_iv (GL_DST_ALPHA),
2660	const_iv (GL_ONE_MINUS_SRC_ALPHA),	3084	const_iv (GL_ONE_MINUS_SRC_ALPHA),
2661	const_iv (GL_ONE_MINUS_DST_ALPHA),	3085	const_iv (GL_ONE_MINUS_DST_ALPHA),
		3086	const_iv (GL_SRC_COLOR),
		3087	const_iv (GL_DST_COLOR),
		3088	const_iv (GL_ONE_MINUS_SRC_COLOR),
		3089	const_iv (GL_ONE_MINUS_DST_COLOR),
2662	const_iv (GL_SRC_ALPHA_SATURATE),	3090	const_iv (GL_SRC_ALPHA_SATURATE),
2663	const_iv (GL_RGB),	3091	const_iv (GL_RGB),
2664	const_iv (GL_RGBA),	3092	const_iv (GL_RGBA),
2665	const_iv (GL_RGBA4),	3093	const_iv (GL_RGBA4),
2666	const_iv (GL_RGBA8),	3094	const_iv (GL_RGBA8),
…		…
2734	const_iv (GL_NICEST),	3162	const_iv (GL_NICEST),
2735	const_iv (GL_V2F),	3163	const_iv (GL_V2F),
2736	const_iv (GL_V3F),	3164	const_iv (GL_V3F),
2737	const_iv (GL_T2F_V3F),	3165	const_iv (GL_T2F_V3F),
2738	const_iv (GL_T2F_N3F_V3F),	3166	const_iv (GL_T2F_N3F_V3F),
		3167	const_iv (GL_FUNC_ADD),
		3168	const_iv (GL_FUNC_SUBTRACT),
		3169	const_iv (GL_FUNC_REVERSE_SUBTRACT),
2739	# undef const_iv	3170	# undef const_iv
2740	};	3171	};
2741		3172
2742	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	3173	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
2743	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	3174	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
2744		3175
2745	texture_av = newAV ();	3176	texture_av = newAV ();
2746	AvREAL_off (texture_av);	3177	AvREAL_off (texture_av);
2747	}	3178	}
2748		3179
…		…
2750	disable_GL_EXT_blend_func_separate ()	3181	disable_GL_EXT_blend_func_separate ()
2751	CODE:	3182	CODE:
2752	gl.BlendFuncSeparate = 0;	3183	gl.BlendFuncSeparate = 0;
2753	gl.BlendFuncSeparateEXT = 0;	3184	gl.BlendFuncSeparateEXT = 0;
2754		3185
2755	char *	3186	void
		3187	apple_nvidia_bug (int enable)
		3188
		3189	const char *
2756	gl_vendor ()	3190	gl_vendor ()
2757	CODE:	3191	CODE:
2758	RETVAL = (char *)glGetString (GL_VENDOR);	3192	RETVAL = (const char *)glGetString (GL_VENDOR);
2759	OUTPUT:	3193	OUTPUT:
2760	RETVAL	3194	RETVAL
2761		3195
2762	char *	3196	const char *
2763	gl_version ()	3197	gl_version ()
2764	CODE:	3198	CODE:
2765	RETVAL = (char *)glGetString (GL_VERSION);	3199	RETVAL = (const char *)glGetString (GL_VERSION);
2766	OUTPUT:	3200	OUTPUT:
2767	RETVAL	3201	RETVAL
2768		3202
2769	char *	3203	const char *
2770	gl_extensions ()	3204	gl_extensions ()
2771	CODE:	3205	CODE:
2772	RETVAL = (char *)glGetString (GL_EXTENSIONS);	3206	RETVAL = (const char *)glGetString (GL_EXTENSIONS);
2773	OUTPUT:	3207	OUTPUT:
2774	RETVAL	3208	RETVAL
2775		3209
2776	const char *glGetString (GLenum pname)	3210	const char *glGetString (GLenum pname)
		3211	CODE:
		3212	RETVAL = (const char *)glGetString (pname);
		3213	OUTPUT:
		3214	RETVAL
2777		3215
2778	GLint glGetInteger (GLenum pname)	3216	GLint glGetInteger (GLenum pname)
2779	CODE:	3217	CODE:
2780	glGetIntegerv (pname, &RETVAL);	3218	glGetIntegerv (pname, &RETVAL);
2781	OUTPUT:	3219	OUTPUT:
…		…
2789		3227
2790	int glGetError ()	3228	int glGetError ()
2791		3229
2792	void glFinish ()	3230	void glFinish ()
2793		3231
		3232	void glFlush ()
		3233
2794	void glClear (int mask)	3234	void glClear (int mask)
2795		3235
2796	void glClearColor (float r, float g, float b, float a = 1.0)	3236	void glClearColor (float r, float g, float b, float a = 1.0)
2797	PROTOTYPE: @	3237	PROTOTYPE: @
2798		3238
…		…
2807	void glBlendFunc (int sfactor, int dfactor)	3247	void glBlendFunc (int sfactor, int dfactor)
2808		3248
2809	void glBlendFuncSeparate (int sa, int da, int saa, int daa)	3249	void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2810	CODE:	3250	CODE:
2811	gl_BlendFuncSeparate (sa, da, saa, daa);	3251	gl_BlendFuncSeparate (sa, da, saa, daa);
		3252
		3253	# void glBlendEquation (int se)
2812		3254
2813	void glDepthMask (int flag)	3255	void glDepthMask (int flag)
2814		3256
2815	void glLogicOp (int opcode)	3257	void glLogicOp (int opcode)
2816		3258
…		…
2851	void glRotate (float angle, float x, float y, float z)	3293	void glRotate (float angle, float x, float y, float z)
2852	CODE:	3294	CODE:
2853	glRotatef (angle, x, y, z);	3295	glRotatef (angle, x, y, z);
2854		3296
2855	void glColor (float r, float g, float b, float a = 1.0)	3297	void glColor (float r, float g, float b, float a = 1.0)
		3298	PROTOTYPE: @
2856	ALIAS:	3299	ALIAS:
2857	glColor_premultiply = 1	3300	glColor_premultiply = 1
2858	CODE:	3301	CODE:
2859	if (ix)	3302	if (ix)
2860	{	3303	{
…		…
2966		3409
2967	void glEndList ()	3410	void glEndList ()
2968		3411
2969	void glCallList (int list)	3412	void glCallList (int list)
2970		3413
		3414	void c_init ()
		3415	CODE:
		3416	glPixelStorei (GL_PACK_ALIGNMENT , 1);
		3417	glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
		3418
2971	MODULE = Deliantra::Client PACKAGE = DC::UI::Base	3419	MODULE = Deliantra::Client PACKAGE = DC::UI::Base
2972		3420
2973	PROTOTYPES: DISABLE	3421	PROTOTYPES: DISABLE
2974		3422
2975	void	3423	void
2976	find_widget (SV *self, NV x, NV y)	3424	find_widget (SV *self, NV x, NV y)
2977	PPCODE:	3425	PPCODE:
2978	{	3426	{
2979	if (within_widget (self, x, y))	3427	if (within_widget (self, x, y))
2980	XPUSHs (self);	3428	XPUSHs (self);
2981	}	3429	}
2982		3430
2983	BOOT:	3431	BOOT:
2984	{	3432	{
…		…
2992		3440
2993	void	3441	void
2994	draw (SV *self)	3442	draw (SV *self)
2995	CODE:	3443	CODE:
2996	{	3444	{
2997	HV *hv;	3445	HV *hv;
2998	SV **svp;	3446	SV **svp;
2999	NV x, y, w, h;	3447	NV x, y, w, h;
3000	SV *draw_x_sv = GvSV (draw_x_gv);	3448	SV *draw_x_sv = GvSV (draw_x_gv);
3001	SV *draw_y_sv = GvSV (draw_y_gv);	3449	SV *draw_y_sv = GvSV (draw_y_gv);
3002	SV *draw_w_sv = GvSV (draw_w_gv);	3450	SV *draw_w_sv = GvSV (draw_w_gv);
3003	SV *draw_h_sv = GvSV (draw_h_gv);	3451	SV *draw_h_sv = GvSV (draw_h_gv);

Diff Legend

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