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.30 by root, Thu Apr 13 23:07:56 2006 UTC vs.
Revision 1.61 by root, Sun Apr 23 21:47:30 2006 UTC

		1	#ifdef _WIN32
		2	# include <malloc.h>
		3	#endif
		4
1	#include "EXTERN.h"	5	#include "EXTERN.h"
2	#include "perl.h"	6	#include "perl.h"
3	#include "XSUB.h"	7	#include "XSUB.h"
4		8
5	#include <string.h>	9	#include <string.h>
6	#include <stdio.h>	10	#include <stdio.h>
7		11
8	#include <SDL.h>	12	#include <SDL.h>
9	#include <SDL_image.h>	13	#include <SDL_image.h>
		14	#include <SDL_mixer.h>
10	#include <SDL_opengl.h>	15	#include <SDL_opengl.h>
11		16
12	#include <glib/gmacros.h>	17	#include <glib/gmacros.h>
13		18
14	#include <pango/pango.h>	19	#include <pango/pango.h>
15	#include <pango/pangofc-fontmap.h>	20	#include <pango/pangofc-fontmap.h>
16	#include <pango/pangoft2.h>	21	#include <pango/pangoft2.h>
17		22
		23	#ifndef _WIN32
18	#include <sys/types.h>	24	# include <sys/types.h>
19	#include <sys/socket.h>	25	# include <sys/socket.h>
20	#include <netinet/in.h>	26	# include <netinet/in.h>
21	#include <netinet/tcp.h>	27	# include <netinet/tcp.h>
22
23	#include <inttypes.h>	28	# include <inttypes.h>
		29	#else
		30	typedef unsigned char uint8_t;
		31	typedef unsigned short uint16_t;
		32	typedef unsigned int uint32_t;
		33	typedef signed char int8_t;
		34	typedef signed short int16_t;
		35	typedef signed int int32_t;
		36	#endif
		37
		38	#include "glext.h"
24		39
25	#define FOW_DARKNESS 32	40	#define FOW_DARKNESS 32
26		41
27	#define MAP_EXTEND_X 32	42	#define MAP_EXTEND_X 32
28	#define MAP_EXTEND_Y 512	43	#define MAP_EXTEND_Y 512
29		44
30	static PangoContext *context;	45	#define MIN_FONT_HEIGHT 8
31	static PangoFontMap *fontmap;	46
		47	typedef Mix_Chunk *CFClient__MixChunk;
		48	typedef Mix_Music *CFClient__MixMusic;
		49
		50	typedef PangoFontDescription *CFClient__Font;
32		51
33	typedef struct cf_layout {	52	typedef struct cf_layout {
34	PangoLayout *pl;	53	PangoLayout *pl;
35	int base_height;	54	int base_height;
		55	CFClient__Font font;
36	} *CFClient__Layout;	56	} *CFClient__Layout;
		57
		58	static CFClient__Font default_font;
		59	static PangoContext *context;
		60	static PangoFontMap *fontmap;
37		61
38	static void	62	static void
39	substitute_func (FcPattern *pattern, gpointer data)	63	substitute_func (FcPattern *pattern, gpointer data)
40	{	64	{
41	FcPatternAddBool (pattern, FC_HINTING , 1);	65	FcPatternAddBool (pattern, FC_HINTING , 1);
42	FcPatternAddBool (pattern, FC_AUTOHINT, 1);	66	FcPatternAddBool (pattern, FC_AUTOHINT, 0);
43	}	67	}
44		68
45	static void	69	static void
46	layout_update (CFClient__Layout self)	70	layout_update_font (CFClient__Layout self)
47	{	71	{
48	/* use a random scale factor to account for unknown descenders, 0.8 works	72	/* use a random scale factor to account for unknown descenders, 0.8 works
49	* reasonably well with bitstream vera	73	* reasonably well with bitstream vera
50	*/	74	*/
51	PangoFontDescription *font = pango_context_get_font_description (context);	75	PangoFontDescription *font = self->font ? self->font : default_font;
52	pango_font_description_set_absolute_size (font, self->base_height * (PANGO_SCALE * 8 / 10));	76
		77	pango_font_description_set_absolute_size (font,
		78	MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
		79
		80	pango_layout_set_font_description (self->pl, font);
53	}	81	}
54		82
55	static void	83	static void
56	layout_get_pixel_size (CFClient__Layout self, int *w, int *h)	84	layout_get_pixel_size (CFClient__Layout self, int *w, int *h)
57	{	85	{
58	layout_update (self);
59
60	pango_layout_get_pixel_size (self->pl, w, h);	86	pango_layout_get_pixel_size (self->pl, w, h);
61		87
62	*w = (*w + 3) & ~3;	88	*w = (*w + 3) & ~3;
63	if (!*w) *w = 1;	89	if (!*w) *w = 1;
64	if (!*h) *h = 1;	90	if (!*h) *h = 1;
65	}	91	}
		92
		93	typedef uint16_t mapface;
66		94
67	typedef struct {	95	typedef struct {
68	GLint name;	96	GLint name;
69	int w, h;	97	int w, h;
70	float s, t;	98	float s, t;
71	} mapface;	99	uint8_t r, g, b, a;
		100	} maptex;
72		101
73	typedef struct {	102	typedef struct {
74	int16_t darkness;	103	int16_t darkness;
75	uint16_t face[3];	104	mapface face[3];
76	} mapcell;	105	} mapcell;
77		106
78	typedef struct {	107	typedef struct {
79	int32_t c0, c1;	108	int32_t c0, c1;
80	mapcell *col;	109	mapcell *col;
81	} maprow;	110	} maprow;
82		111
83	typedef struct map {	112	typedef struct map {
84	int x, y, w, h;	113	int x, y, w, h;
85	int vx, vy;	114	int ox, oy; /* offset to virtual global coordinate system */
86	int faces;	115	int faces;
87	mapface *face;	116	mapface *face;
88		117
		118	int texs;
		119	maptex *tex;
		120
89	uint32_t rows;	121	int32_t rows;
90	maprow *row;	122	maprow *row;
91	} *CFClient__Map;	123	} *CFClient__Map;
92		124
93	static char *	125	static char *
94	prepend (char *ptr, int sze, int inc)	126	prepend (char *ptr, int sze, int inc)
…		…
113	}	145	}
114		146
115	#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))	147	#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
116	#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))	148	#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
117		149
		150	static maprow *
		151	map_get_row (CFClient__Map self, int y)
		152	{
		153	if (0 > y)
		154	{
		155	int extend = - y + MAP_EXTEND_Y;
		156	Prepend (maprow, self->row, self->rows, extend);
		157
		158	self->rows += extend;
		159	self->y += extend;
		160	y += extend;
		161	}
		162	else if (y >= self->rows)
		163	{
		164	int extend = y - self->rows + MAP_EXTEND_Y;
		165	Append (maprow, self->row, self->rows, extend);
		166	self->rows += extend;
		167	}
		168
		169	return self->row + y;
		170	}
		171
		172	static mapcell *
		173	row_get_cell (maprow *row, int x)
		174	{
		175	if (!row->col)
		176	{
		177	Newz (0, row->col, MAP_EXTEND_X, mapcell);
		178	row->c0 = x - MAP_EXTEND_X / 4;
		179	row->c1 = row->c0 + MAP_EXTEND_X;
		180	}
		181
		182	if (row->c0 > x)
		183	{
		184	int extend = row->c0 - x + MAP_EXTEND_X;
		185	Prepend (mapcell, row->col, row->c1 - row->c0, extend);
		186	row->c0 -= extend;
		187	}
		188	else if (x >= row->c1)
		189	{
		190	int extend = x - row->c1 + MAP_EXTEND_X;
		191	Append (mapcell, row->col, row->c1 - row->c0, extend);
		192	row->c1 += extend;
		193	}
		194
		195	return row->col + (x - row->c0);
		196	}
		197
		198	static mapcell *
		199	map_get_cell (CFClient__Map self, int x, int y)
		200	{
		201	return row_get_cell (map_get_row (self, y), x);
		202	}
		203
118	static void	204	static void
119	map_clear (CFClient__Map self)	205	map_clear (CFClient__Map self)
120	{	206	{
121	int r;	207	int r;
122		208
…		…
125		211
126	Safefree (self->row);	212	Safefree (self->row);
127		213
128	self->x = 0;	214	self->x = 0;
129	self->y = 0;	215	self->y = 0;
130	self->vx = 0;	216	self->ox = 0;
131	self->vy = 0;	217	self->oy = 0;
132	self->row = 0;	218	self->row = 0;
133	self->rows = 0;	219	self->rows = 0;
134	}	220	}
135		221
136	static void	222	static void
137	map_blank (CFClient__Map self, int x0, int y0, int w, int h)	223	map_blank (CFClient__Map self, int x0, int y0, int w, int h)
138	{	224	{
139	int x, y;	225	int x, y;
		226	maprow *row;
140		227
141	for (y = y0; y < y0 + h; y++)	228	for (y = y0; y < y0 + h; y++)
142	if (y >= 0)	229	if (y >= 0)
143	{	230	{
144	if (y >= self->rows)	231	if (y >= self->rows)
145	break;	232	break;
146		233
147	maprow *row = self->row + y;	234	row = self->row + y;
148		235
149	for (x = x0; x < x0 + w; x++)	236	for (x = x0; x < x0 + w; x++)
150	if (x >= row->c0)	237	if (x >= row->c0)
151	{	238	{
152	if (x >= row->c1)	239	if (x >= row->c1)
153	break;	240	break;
154		241
155	mapcell *cell = row->col + (x - row->c0);	242	row->col[x - row->c0].darkness = -1;
156	cell->darkness = -1;
157	cell->face [2] = 0;
158	}	243	}
159	}	244	}
160	}	245	}
161		246
		247	static void
		248	music_finished ()
		249	{
		250	SDL_UserEvent ev;
		251
		252	ev.type = SDL_USEREVENT;
		253	ev.code = 0;
		254	ev.data1 = 0;
		255	ev.data2 = 0;
		256
		257	SDL_PushEvent ((SDL_Event *)&ev);
		258	}
		259
162	MODULE = CFClient PACKAGE = CFClient	260	MODULE = CFClient PACKAGE = CFClient
163		261
164	PROTOTYPES: ENABLE	262	PROTOTYPES: ENABLE
165		263
166	BOOT:	264	BOOT:
167	{	265	{
		266	HV *stash = gv_stashpv ("CFClient", 1);
		267	static const struct {
		268	const char *name;
		269	IV iv;
		270	} *civ, const_iv[] = {
		271	# define const_iv(name) { # name, (IV)name }
		272	const_iv (SDL_ACTIVEEVENT),
		273	const_iv (SDL_KEYDOWN),
		274	const_iv (SDL_KEYUP),
		275	const_iv (SDL_MOUSEMOTION),
		276	const_iv (SDL_MOUSEBUTTONDOWN),
		277	const_iv (SDL_MOUSEBUTTONUP),
		278	const_iv (SDL_JOYAXISMOTION),
		279	const_iv (SDL_JOYBALLMOTION),
		280	const_iv (SDL_JOYHATMOTION),
		281	const_iv (SDL_JOYBUTTONDOWN),
		282	const_iv (SDL_JOYBUTTONUP),
		283	const_iv (SDL_QUIT),
		284	const_iv (SDL_SYSWMEVENT),
		285	const_iv (SDL_EVENT_RESERVEDA),
		286	const_iv (SDL_EVENT_RESERVEDB),
		287	const_iv (SDL_VIDEORESIZE),
		288	const_iv (SDL_VIDEOEXPOSE),
		289	const_iv (SDL_USEREVENT),
		290	const_iv (SDLK_KP0),
		291	const_iv (SDLK_KP1),
		292	const_iv (SDLK_KP2),
		293	const_iv (SDLK_KP3),
		294	const_iv (SDLK_KP4),
		295	const_iv (SDLK_KP5),
		296	const_iv (SDLK_KP6),
		297	const_iv (SDLK_KP7),
		298	const_iv (SDLK_KP8),
		299	const_iv (SDLK_KP9),
		300	const_iv (SDLK_KP_PERIOD),
		301	const_iv (SDLK_KP_DIVIDE),
		302	const_iv (SDLK_KP_MULTIPLY),
		303	const_iv (SDLK_KP_MINUS),
		304	const_iv (SDLK_KP_PLUS),
		305	const_iv (SDLK_KP_ENTER),
		306	const_iv (SDLK_KP_EQUALS),
		307	const_iv (SDLK_UP),
		308	const_iv (SDLK_DOWN),
		309	const_iv (SDLK_RIGHT),
		310	const_iv (SDLK_LEFT),
		311	const_iv (SDLK_INSERT),
		312	const_iv (SDLK_HOME),
		313	const_iv (SDLK_END),
		314	const_iv (SDLK_PAGEUP),
		315	const_iv (SDLK_PAGEDOWN),
		316	const_iv (SDLK_F1),
		317	const_iv (SDLK_F2),
		318	const_iv (SDLK_F3),
		319	const_iv (SDLK_F4),
		320	const_iv (SDLK_F5),
		321	const_iv (SDLK_F6),
		322	const_iv (SDLK_F7),
		323	const_iv (SDLK_F8),
		324	const_iv (SDLK_F9),
		325	const_iv (SDLK_F10),
		326	const_iv (SDLK_F11),
		327	const_iv (SDLK_F12),
		328	const_iv (SDLK_F13),
		329	const_iv (SDLK_F14),
		330	const_iv (SDLK_F15),
		331	const_iv (SDLK_NUMLOCK),
		332	const_iv (SDLK_CAPSLOCK),
		333	const_iv (SDLK_SCROLLOCK),
		334	const_iv (SDLK_RSHIFT),
		335	const_iv (SDLK_LSHIFT),
		336	const_iv (SDLK_RCTRL),
		337	const_iv (SDLK_LCTRL),
		338	const_iv (SDLK_RALT),
		339	const_iv (SDLK_LALT),
		340	const_iv (SDLK_RMETA),
		341	const_iv (SDLK_LMETA),
		342	const_iv (SDLK_LSUPER),
		343	const_iv (SDLK_RSUPER),
		344	const_iv (SDLK_MODE),
		345	const_iv (SDLK_COMPOSE),
		346	const_iv (SDLK_HELP),
		347	const_iv (SDLK_PRINT),
		348	const_iv (SDLK_SYSREQ),
		349	const_iv (SDLK_BREAK),
		350	const_iv (SDLK_MENU),
		351	const_iv (SDLK_POWER),
		352	const_iv (SDLK_EURO),
		353	const_iv (SDLK_UNDO),
		354	const_iv (KMOD_NONE),
		355	const_iv (KMOD_LSHIFT),
		356	const_iv (KMOD_RSHIFT),
		357	const_iv (KMOD_LCTRL),
		358	const_iv (KMOD_RCTRL),
		359	const_iv (KMOD_LALT),
		360	const_iv (KMOD_RALT),
		361	const_iv (KMOD_LMETA),
		362	const_iv (KMOD_RMETA),
		363	const_iv (KMOD_NUM),
		364	const_iv (KMOD_CAPS),
		365	const_iv (KMOD_MODE),
		366	const_iv (KMOD_CTRL),
		367	const_iv (KMOD_SHIFT),
		368	const_iv (KMOD_ALT),
		369	const_iv (KMOD_META)
		370	# undef const_iv
		371	};
		372
		373	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
		374	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
		375
168	fontmap = pango_ft2_font_map_new ();	376	fontmap = pango_ft2_font_map_new ();
169	pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)fontmap, substitute_func, 0, 0);	377	pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)fontmap, substitute_func, 0, 0);
170	context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap);	378	context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap);
171	}	379	}
		380
		381	int
		382	SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO)
		383
		384	void
		385	SDL_Quit ()
		386
		387	void
		388	SDL_ListModes ()
		389	PPCODE:
		390	{
		391	SDL_Rect **m;
		392
		393	SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
		394	SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
		395	SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
		396	SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1);
		397
		398	SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0);
		399	SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
		400	SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0);
		401	SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
		402
		403	SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
		404	SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
		405	SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0);
		406
		407	SDL_EnableUNICODE (1);
		408	SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
		409
		410	m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
		411
		412	if (m && m != (SDL_Rect **)-1)
		413	while (*m)
		414	{
		415	AV *av = newAV ();
		416	av_push (av, newSViv ((*m)->w));
		417	av_push (av, newSViv ((*m)->h));
		418	XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
		419
		420	++m;
		421	}
		422	}
		423
		424	int
		425	SDL_SetVideoMode (int w, int h, int fullscreen)
		426	CODE:
		427	RETVAL = !!SDL_SetVideoMode (
		428	w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
		429	);
		430	SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
		431	OUTPUT:
		432	RETVAL
		433
		434	void
		435	SDL_GL_SwapBuffers ()
		436
		437	void
		438	SDL_PollEvent ()
		439	PPCODE:
		440	{
		441	SDL_Event ev;
		442
		443	while (SDL_PollEvent (&ev))
		444	{
		445	HV *hv = newHV ();
		446	hv_store (hv, "type", 4, newSViv (ev.type), 0);
		447	switch (ev.type)
		448	{
		449	case SDL_KEYDOWN:
		450	case SDL_KEYUP:
		451	hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
		452	hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
		453	hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);
		454	hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
		455	break;
		456
		457	case SDL_ACTIVEEVENT:
		458	hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
		459	hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
		460	break;
		461
		462	case SDL_MOUSEMOTION:
		463	hv_store (hv, "state", 5, newSViv (ev.motion.state), 0);
		464	hv_store (hv, "x", 1, newSViv (ev.motion.x), 0);
		465	hv_store (hv, "y", 1, newSViv (ev.motion.y), 0);
		466	hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0);
		467	hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0);
		468	break;
		469
		470	case SDL_MOUSEBUTTONDOWN:
		471	case SDL_MOUSEBUTTONUP:
		472	hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
		473	hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
		474	hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
		475	hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
		476	}
		477
		478	XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
		479	}
		480	}
		481
		482	int
		483	Mix_OpenAudio (int frequency = 22050, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 512)
		484	POSTCALL:
		485	Mix_HookMusicFinished (music_finished);
		486
		487	void
		488	Mix_CloseAudio ()
		489
		490	int
		491	Mix_AllocateChannels (int numchans = -1)
172		492
173	void	493	void
174	lowdelay (int fd, int val = 1)	494	lowdelay (int fd, int val = 1)
175	CODE:	495	CODE:
		496	#ifndef _WIN32
176	setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));	497	setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
		498	#endif
177		499
178	char *	500	char *
179	gl_version ()	501	gl_version ()
180	CODE:	502	CODE:
181	RETVAL = (char *)glGetString (GL_VERSION);	503	RETVAL = (char *)glGetString (GL_VERSION);
…		…
191		513
192	void	514	void
193	add_font (char *file)	515	add_font (char *file)
194	CODE:	516	CODE:
195	FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */	517	FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */
196
197	void
198	set_font (char *file)
199	CODE:
200	{
201	int count;
202	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
203	PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
204	FcPatternDestroy (pattern);
205	pango_context_set_font_description (context, font);
206	}
207		518
208	void	519	void
209	load_image_inline (SV *image_)	520	load_image_inline (SV *image_)
210	ALIAS:	521	ALIAS:
211	load_image_file = 1	522	load_image_file = 1
…		…
218	SDL_RWops *rw = ix	529	SDL_RWops *rw = ix
219	? SDL_RWFromFile (image, "r")	530	? SDL_RWFromFile (image, "r")
220	: SDL_RWFromConstMem (image, image_len);	531	: SDL_RWFromConstMem (image, image_len);
221		532
222	if (!rw)	533	if (!rw)
223	croak ("load_image: unable to open file");	534	croak ("load_image: %s", SDL_GetError ());
224		535
225	surface = IMG_Load_RW (rw, 1);	536	surface = IMG_Load_RW (rw, 1);
226	if (!surface)	537	if (!surface)
227	croak ("load_image: unable to read file");	538	croak ("load_image: %s", SDL_GetError ());
228		539
229	fmt.palette = NULL;	540	fmt.palette = NULL;
230	fmt.BitsPerPixel = 32;	541	fmt.BitsPerPixel = 32;
231	fmt.BytesPerPixel = 4;	542	fmt.BytesPerPixel = 4;
		543	#if SDL_BYTEORDER == SDL_LIL_ENDIAN
232	fmt.Rmask = 0x000000ff;	544	fmt.Rmask = 0x000000ff;
233	fmt.Gmask = 0x0000ff00;	545	fmt.Gmask = 0x0000ff00;
234	fmt.Bmask = 0x00ff0000;	546	fmt.Bmask = 0x00ff0000;
235	fmt.Amask = 0xff000000;	547	fmt.Amask = 0xff000000;
		548	#else
		549	fmt.Rmask = 0xff000000;
		550	fmt.Gmask = 0x00ff0000;
		551	fmt.Bmask = 0x0000ff00;
		552	fmt.Amask = 0x000000ff;
		553	#endif
236	fmt.Rloss = 0;	554	fmt.Rloss = 0;
237	fmt.Gloss = 0;	555	fmt.Gloss = 0;
238	fmt.Bloss = 0;	556	fmt.Bloss = 0;
239	fmt.Aloss = 0;	557	fmt.Aloss = 0;
240	fmt.Rshift = 0;	558	fmt.Rshift = 0;
…		…
244	fmt.colorkey = 0;	562	fmt.colorkey = 0;
245	fmt.alpha = 0;	563	fmt.alpha = 0;
246		564
247	surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);	565	surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
248		566
		567	assert (surface2->pitch == surface2->w * 4);
		568
249	EXTEND (SP, 5);	569	EXTEND (SP, 5);
250	PUSHs (sv_2mortal (newSViv (surface2->w)));	570	PUSHs (sv_2mortal (newSViv (surface2->w)));
251	PUSHs (sv_2mortal (newSViv (surface2->h)));	571	PUSHs (sv_2mortal (newSViv (surface2->h)));
252	SDL_LockSurface (surface2);	572	SDL_LockSurface (surface2);
253	PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));	573	PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
254	SDL_UnlockSurface (surface2);	574	SDL_UnlockSurface (surface2);
255	PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));	575	PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
256	PUSHs (sv_2mortal (newSViv (GL_RGBA)));	576	PUSHs (sv_2mortal (newSViv (GL_RGBA)));
257	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_INT_8_8_8_8_REV)));	577	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
258		578
259	SDL_FreeSurface (surface);	579	SDL_FreeSurface (surface);
260	SDL_FreeSurface (surface2);	580	SDL_FreeSurface (surface2);
261	}	581	}
262		582
263	void	583	void
		584	average (int x, int y, uint32_t *data)
		585	PPCODE:
		586	{
		587	uint32_t r = 0, g = 0, b = 0, a = 0;
		588
		589	x = y = x * y;
		590
		591	while (x--)
		592	{
		593	uint32_t p = *data++;
		594
		595	r += (p ) & 255;
		596	g += (p >> 8) & 255;
		597	b += (p >> 16) & 255;
		598	a += (p >> 24) & 255;
		599	}
		600
		601	EXTEND (SP, 4);
		602	PUSHs (sv_2mortal (newSViv (r / y)));
		603	PUSHs (sv_2mortal (newSViv (g / y)));
		604	PUSHs (sv_2mortal (newSViv (b / y)));
		605	PUSHs (sv_2mortal (newSViv (a / y)));
		606	}
		607
		608	void
264	fatal (char *message)	609	fatal (char *message)
265	CODE:	610	CODE:
266	#ifdef WIN32	611	#ifdef _WIN32
267	MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND);	612	MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND);
268	#else	613	#else
269	fprintf (stderr, "%s\n", message);	614	fprintf (stderr, "FATAL: %s\n", message);
270	#endif	615	#endif
271	exit (1);	616	exit (1);
272		617
		618	MODULE = CFClient PACKAGE = CFClient::Font
		619
		620	CFClient::Font
		621	new_from_file (SV *class, char *path)
		622	CODE:
		623	{
		624	int count;
		625	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, 0, 0, &count);
		626	RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
		627	FcPatternDestroy (pattern);
		628	}
		629	OUTPUT:
		630	RETVAL
		631
		632	void
		633	DESTROY (CFClient::Font self)
		634	CODE:
		635	pango_font_description_free (self);
		636
		637	void
		638	make_default (CFClient::Font self)
		639	CODE:
		640	default_font = self;
		641
273	MODULE = CFClient PACKAGE = CFClient::Layout	642	MODULE = CFClient PACKAGE = CFClient::Layout
274		643
275	CFClient::Layout	644	CFClient::Layout
276	new (SV *class, int base_height = 10)	645	new (SV *class, int base_height = MIN_FONT_HEIGHT)
277	CODE:	646	CODE:
278	New (0, RETVAL, 1, struct cf_layout);	647	New (0, RETVAL, 1, struct cf_layout);
		648	RETVAL->pl = pango_layout_new (context);
279	RETVAL->base_height = base_height;	649	RETVAL->base_height = base_height;
280	RETVAL->pl = pango_layout_new (context);	650	RETVAL->font = 0;
281	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);	651	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
		652	pango_layout_set_font_description (RETVAL->pl, default_font);
282	OUTPUT:	653	OUTPUT:
283	RETVAL	654	RETVAL
284		655
285	void	656	void
286	DESTROY (CFClient::Layout self)	657	DESTROY (CFClient::Layout self)
287	CODE:	658	CODE:
288	g_object_unref (self->pl);	659	g_object_unref (self->pl);
289	Safefree (self);	660	Safefree (self);
290		661
291	void	662	void
292	set_markup (CFClient::Layout self, SV *text_)	663	set_text (CFClient::Layout self, SV *text_)
293	CODE:	664	CODE:
294	{	665	{
295	STRLEN textlen;	666	STRLEN textlen;
296	char *text = SvPVutf8 (text_, textlen);	667	char *text = SvPVutf8 (text_, textlen);
297		668
		669	pango_layout_set_text (self->pl, text, textlen);
		670	}
		671
		672	void
		673	set_markup (CFClient::Layout self, SV *text_)
		674	CODE:
		675	{
		676	STRLEN textlen;
		677	char *text = SvPVutf8 (text_, textlen);
		678
298	pango_layout_set_markup (self->pl, text, textlen);	679	pango_layout_set_markup (self->pl, text, textlen);
299	}	680	}
300		681
		682	SV *
		683	get_text (CFClient::Layout self)
		684	CODE:
		685	RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
		686	SvUTF8_on (RETVAL);
		687	OUTPUT:
		688	RETVAL
		689
		690	void
		691	set_font (CFClient::Layout self, CFClient::Font font = 0)
		692	CODE:
		693	if (self->font != font)
		694	{
		695	self->font = font;
		696	layout_update_font (self);
		697	}
		698
301	void	699	void
302	set_height (CFClient::Layout self, int base_height)	700	set_height (CFClient::Layout self, int base_height)
303	CODE:	701	CODE:
		702	if (self->base_height != base_height)
		703	{
304	self->base_height = base_height;	704	self->base_height = base_height;
		705	layout_update_font (self);
		706	}
305		707
306	void	708	void
307	set_width (CFClient::Layout self, int max_width = -1)	709	set_width (CFClient::Layout self, int max_width = -1)
308	CODE:	710	CODE:
309	pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);	711	pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
…		…
312	size (CFClient::Layout self)	714	size (CFClient::Layout self)
313	PPCODE:	715	PPCODE:
314	{	716	{
315	int w, h;	717	int w, h;
316		718
317	layout_update (self);
318	layout_get_pixel_size (self, &w, &h);	719	layout_get_pixel_size (self, &w, &h);
319		720
320	EXTEND (SP, 2);	721	EXTEND (SP, 2);
321	PUSHs (sv_2mortal (newSViv (w)));	722	PUSHs (sv_2mortal (newSViv (w)));
322	PUSHs (sv_2mortal (newSViv (h)));	723	PUSHs (sv_2mortal (newSViv (h)));
…		…
325	int	726	int
326	xy_to_index (CFClient::Layout self, int x, int y)	727	xy_to_index (CFClient::Layout self, int x, int y)
327	CODE:	728	CODE:
328	{	729	{
329	int index, trailing;	730	int index, trailing;
330
331	layout_update (self);
332	pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);	731	pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
333
334	RETVAL = index;	732	RETVAL = index;
335	}	733	}
336	OUTPUT:	734	OUTPUT:
337	RETVAL	735	RETVAL
338		736
339	void	737	void
340	cursor_pos (CFClient::Layout self, int index)	738	cursor_pos (CFClient::Layout self, int index)
341	PPCODE:	739	PPCODE:
342	{	740	{
343	PangoRectangle strong_pos;	741	PangoRectangle strong_pos;
344	layout_update (self);
345	pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);	742	pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
346		743
347	EXTEND (SP, 3);	744	EXTEND (SP, 3);
348	PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));	745	PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
349	PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));	746	PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
…		…
356	{	753	{
357	SV *retval;	754	SV *retval;
358	int w, h;	755	int w, h;
359	FT_Bitmap bitmap;	756	FT_Bitmap bitmap;
360		757
361	layout_update (self);
362	layout_get_pixel_size (self, &w, &h);	758	layout_get_pixel_size (self, &w, &h);
363		759
364	retval = newSV (w * h);	760	retval = newSV (w * h);
365	SvPOK_only (retval);	761	SvPOK_only (retval);
366	SvCUR_set (retval, w * h);	762	SvCUR_set (retval, w * h);
…		…
383	}	779	}
384		780
385	MODULE = CFClient PACKAGE = CFClient::Texture	781	MODULE = CFClient PACKAGE = CFClient::Texture
386		782
387	void	783	void
388	draw_quad (SV *self, double x, double y, double w = 0, double h = 0)	784	draw_quad (SV *self, float x, float y, float w = 0, float h = 0)
389	PROTOTYPE: $$$;$$	785	PROTOTYPE: $$$;$$
390	CODE:	786	CODE:
391	{	787	{
392	HV *hv = (HV *)SvRV (self);	788	HV *hv = (HV *)SvRV (self);
393	double s = SvNV (*hv_fetch (hv, "s", 1, 1));	789	float s = SvNV (*hv_fetch (hv, "s", 1, 1));
394	double t = SvNV (*hv_fetch (hv, "t", 1, 1));	790	float t = SvNV (*hv_fetch (hv, "t", 1, 1));
395	int name = SvIV (*hv_fetch (hv, "name", 4, 1));	791	int name = SvIV (*hv_fetch (hv, "name", 4, 1));
		792	int wrap_mode = SvIV (*hv_fetch (hv, "wrap_mode", 9, 1));
396		793
397	if (items < 5)	794	if (items < 5)
398	{	795	{
399	w = SvNV (*hv_fetch (hv, "w", 1, 1));	796	w = SvNV (*hv_fetch (hv, "w", 1, 1));
400	h = SvNV (*hv_fetch (hv, "h", 1, 1));	797	h = SvNV (*hv_fetch (hv, "h", 1, 1));
401	}	798	}
402		799
403	glBindTexture (GL_TEXTURE_2D, name);	800	glBindTexture (GL_TEXTURE_2D, name);
		801	if (wrap_mode) {
		802	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		803	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
		804	}
404	glBegin (GL_QUADS);	805	glBegin (GL_QUADS);
405	glTexCoord2d (0, 0); glVertex2d (x , y );	806	glTexCoord2f (0, 0); glVertex2f (x , y );
406	glTexCoord2d (0, t); glVertex2d (x , y + h);	807	glTexCoord2f (0, t); glVertex2f (x , y + h);
407	glTexCoord2d (s, t); glVertex2d (x + w, y + h);	808	glTexCoord2f (s, t); glVertex2f (x + w, y + h);
408	glTexCoord2d (s, 0); glVertex2d (x + w, y );	809	glTexCoord2f (s, 0); glVertex2f (x + w, y );
409	glEnd ();	810	glEnd ();
410	}	811	}
411		812
412	MODULE = CFClient PACKAGE = CFClient::Map	813	MODULE = CFClient PACKAGE = CFClient::Map
413		814
414	CFClient::Map	815	CFClient::Map
415	new (SV *class, int map_width, int map_height)	816	new (SV *class, int map_width, int map_height)
416	CODE:	817	CODE:
417	New (0, RETVAL, 1, struct map);	818	New (0, RETVAL, 1, struct map);
418	RETVAL->x = 0;	819	RETVAL->x = 0;
419	RETVAL->y = 0;	820	RETVAL->y = 0;
420	RETVAL->w = map_width;	821	RETVAL->w = map_width;
421	RETVAL->h = map_height;	822	RETVAL->h = map_height;
422	RETVAL->vx = 0;	823	RETVAL->ox = 0;
423	RETVAL->vy = 0;	824	RETVAL->oy = 0;
424	RETVAL->faces = 8192;	825	RETVAL->faces = 8192;
425	Newz (0, RETVAL->face, RETVAL->faces, mapface);	826	Newz (0, RETVAL->face, RETVAL->faces, mapface);
		827	RETVAL->texs = 8192;
		828	Newz (0, RETVAL->tex, RETVAL->texs, maptex);
426	RETVAL->rows = 0;	829	RETVAL->rows = 0;
427	RETVAL->row = 0;	830	RETVAL->row = 0;
428	OUTPUT:	831	OUTPUT:
429	RETVAL	832	RETVAL
430		833
…		…
441	clear (CFClient::Map self)	844	clear (CFClient::Map self)
442	CODE:	845	CODE:
443	map_clear (self);	846	map_clear (self);
444		847
445	void	848	void
446	set_texture (CFClient::Map self, int face, int name, int w, int h, float s, float t)	849	set_face (CFClient::Map self, int face, int texid)
447	CODE:	850	CODE:
448	{	851	{
449	while (self->faces < face)	852	while (self->faces <= face)
450	{	853	{
451	Append (mapface, self->face, self->faces, self->faces);	854	Append (mapface, self->face, self->faces, self->faces);
452	self->faces *= 2;	855	self->faces *= 2;
453	}	856	}
454		857
455	self->face [face].name = name;
456	self->face [face].w = w;	858	self->face [face] = texid;
457	self->face [face].h = h;
458	self->face [face].s = s;
459	self->face [face].t = t;
460	}	859	}
		860
		861	void
		862	set_texture (CFClient::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
		863	CODE:
		864	{
		865	while (self->texs <= texid)
		866	{
		867	Append (maptex, self->tex, self->texs, self->texs);
		868	self->texs *= 2;
		869	}
		870
		871	{
		872	maptex *tex = self->tex + texid;
		873
		874	tex->name = name;
		875	tex->w = w;
		876	tex->h = h;
		877	tex->s = s;
		878	tex->t = t;
		879	tex->r = r;
		880	tex->g = g;
		881	tex->b = b;
		882	tex->a = a;
		883	}
		884	}
		885
		886	int
		887	ox (CFClient::Map self)
		888	ALIAS:
		889	oy = 1
		890	CODE:
		891	switch (ix)
		892	{
		893	case 0: RETVAL = self->ox; break;
		894	case 1: RETVAL = self->oy; break;
		895	}
		896	OUTPUT:
		897	RETVAL
461		898
462	void	899	void
463	scroll (CFClient::Map self, int dx, int dy)	900	scroll (CFClient::Map self, int dx, int dy)
464	CODE:	901	CODE:
465	{	902	{
…		…
471	if (dy > 0)	908	if (dy > 0)
472	map_blank (self, self->x, self->y, self->w, dy - 1);	909	map_blank (self, self->x, self->y, self->w, dy - 1);
473	else if (dy < 0)	910	else if (dy < 0)
474	map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy);	911	map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy);
475		912
476	self->x += dx;	913	self->ox += dx; self->x += dx;
477	self->y += dy;	914	self->oy += dy; self->y += dy;
478		915
479	while (self->y < 0)	916	while (self->y < 0)
480	{	917	{
481	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);	918	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
482		919
…		…
489	map1a_update (CFClient::Map self, SV *data_)	926	map1a_update (CFClient::Map self, SV *data_)
490	CODE:	927	CODE:
491	{	928	{
492	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);	929	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
493	uint8_t *data_end = (uint8_t *)SvEND (data_);	930	uint8_t *data_end = (uint8_t *)SvEND (data_);
494		931	mapcell *cell;
		932	int x, y, flags;
		933
495	while (data < data_end)	934	while (data < data_end)
496	{	935	{
497	int flags = (data [0] << 8) + data [1]; data += 2;	936	flags = (data [0] << 8) + data [1]; data += 2;
498		937
499	int x = ((flags >> 10) & 63) + self->x;	938	x = ((flags >> 10) & 63) + self->x;
500	int y = ((flags >> 4) & 63) + self->y;	939	y = ((flags >> 4) & 63) + self->y;
501		940
502	while (y >= self->rows)	941	cell = map_get_cell (self, x, y);
503	{
504	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
505
506	self->rows += MAP_EXTEND_Y;
507	}
508
509	maprow *row = self->row + y;
510
511	if (!row->col)
512	{
513	Newz (0, row->col, MAP_EXTEND_X, mapcell);
514	row->c0 = self->x - MAP_EXTEND_X / 4;
515	row->c1 = row->c0 + MAP_EXTEND_X;
516	}
517
518	if (row->c0 > x)
519	{
520	int extend = row->c0 - x + MAP_EXTEND_X;
521	Prepend (mapcell, row->col, row->c1 - row->c0, extend);
522	row->c0 -= extend;
523	}
524	else if (x >= row->c1)
525	{
526	int extend = x - row->c1 + MAP_EXTEND_X;
527	Append (mapcell, row->col, row->c1 - row->c0, extend);
528	row->c1 += extend;
529	}
530
531	assert (y >= 0);
532	assert (y < self->rows);
533	assert (x >= row->c0);
534	assert (x < row->c1);
535	mapcell *cell = row->col + (x - row->c0);
536		942
537	if (flags & 15)	943	if (flags & 15)
538	{	944	{
539	if (cell->darkness < 0 && x < self->w && y < self->h)	945	if (cell->darkness < 0)
540	{	946	{
541	cell->darkness = 0;	947	cell->darkness = 0;
542	cell->face [0] = 0;	948	cell->face [0] = 0;
543	cell->face [1] = 0;	949	cell->face [1] = 0;
544	cell->face [2] = 0;	950	cell->face [2] = 0;
545	}	951	}
546		952
547	cell->darkness = flags & 8 ? *data++ : 255;	953	cell->darkness = flags & 8 ? *data++ : 255;
		954
		955	//TODO: don't trust server data to be in-range(!)
548		956
549	if (flags & 4)	957	if (flags & 4)
550	{	958	{
551	cell->face [0] = (data [0] << 8) + data [1]; data += 2;	959	cell->face [0] = self->face [(data [0] << 8) + data [1]]; data += 2;
552	}	960	}
553		961
554	if (flags & 2)	962	if (flags & 2)
555	{	963	{
556	cell->face [1] = (data [0] << 8) + data [1]; data += 2;	964	cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2;
557	}	965	}
558		966
559	if (flags & 1)	967	if (flags & 1)
560	{	968	{
561	cell->face [2] = (data [0] << 8) + data [1]; data += 2;	969	cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
562	}	970	}
563	}	971	}
564	else	972	else
		973	cell->darkness = -1;
		974	}
		975	}
		976
		977	SV *
		978	mapmap (CFClient::Map self, int x0, int y0, int w, int h)
		979	CODE:
		980	{
		981	int x1, x;
		982	int y1, y;
		983	int z;
		984	SV *map_sv = newSV (w * h * sizeof (uint32_t));
		985	uint32_t *map = (uint32_t *)SvPVX (map_sv);
		986
		987	SvPOK_only (map_sv);
		988	SvCUR_set (map_sv, w * h * sizeof (uint32_t));
		989
		990	x0 += self->x; x1 = x0 + w;
		991	y0 += self->y; y1 = y0 + h;
		992
		993	for (y = y0; y < y1; y++)
		994	{
		995	maprow *row = 0 <= y && y < self->rows
		996	? self->row + y
		997	: 0;
		998
		999	for (x = x0; x < x1; x++)
565	{	1000	{
566	cell->darkness = -1;	1001	int r = 32, g = 32, b = 32, a = 192;
567	cell->face [2] = 0;	1002
		1003	if (row && row->c0 <= x && x < row->c1)
		1004	{
		1005	mapcell *cell = row->col + (x - row->c0);
		1006
		1007	for (z = 0; z <= 0; z++)
		1008	{
		1009	mapface face = cell->face [z];
		1010
		1011	if (face)
		1012	{
		1013	maptex tex = self->tex [face];
		1014	int a0 = 255 - tex.a;
		1015	int a1 = tex.a;
		1016
		1017	r = (r * a0 + tex.r * a1) / 255;
		1018	g = (g * a0 + tex.g * a1) / 255;
		1019	b = (b * a0 + tex.b * a1) / 255;
		1020	a = (a * a0 + tex.a * a1) / 255;
		1021	}
		1022	}
		1023	}
		1024
		1025	*map++ = (r )
		1026	| (g << 8)
		1027	| (b << 16)
		1028	| (a << 24);
568	}	1029	}
569	}	1030	}
570	}
571		1031
		1032	RETVAL = map_sv;
		1033	}
		1034	OUTPUT:
		1035	RETVAL
		1036
572	void	1037	void
573	draw (CFClient::Map self, int x0, int y0, int sw, int sh)	1038	draw (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh)
574	CODE:	1039	PPCODE:
575	{	1040	{
		1041	int vx, vy;
		1042	int x, y, z;
		1043	int last_name;
		1044	mapface face;
		1045	int sw4 = (sw + 3) & ~3;
		1046	SV *darkness_sv = sv_2mortal (newSV (sw4 * sh));
		1047	uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv);
		1048
		1049	memset (darkness, 255, sw4 * sh);
		1050	SvPOK_only (darkness_sv);
		1051	SvCUR_set (darkness_sv, sw4 * sh);
		1052
		1053	vx = self->x + (self->w - sw) / 2 - shift_x;
		1054	vy = self->y + (self->h - sh) / 2 - shift_y;
		1055
		1056	/*
576	int vx = self->vx = self->w >= sw	1057	int vx = self->vx = self->w >= sw
577	? self->x + (self->w - sw) / 2	1058	? self->x + (self->w - sw) / 2
578	: MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));	1059	: MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
579		1060
580	int vy = self->vy = self->h >= sh	1061	int vy = self->vy = self->h >= sh
581	? self->y + (self->h - sh) / 2	1062	? self->y + (self->h - sh) / 2
582	: MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));	1063	: MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
		1064	*/
583		1065
584	glColor4ub (255, 255, 255, 255);	1066	glColor4ub (255, 255, 255, 255);
585		1067
586	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	1068	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
587	glEnable (GL_BLEND);	1069	glEnable (GL_BLEND);
588	glEnable (GL_TEXTURE_2D);	1070	glEnable (GL_TEXTURE_2D);
589	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	1071	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
590		1072
591	int x, y, z;
592
593	int last_name = 0;
594
595	glBegin (GL_QUADS);	1073	glBegin (GL_QUADS);
		1074
		1075	last_name = 0;
596		1076
597	for (z = 0; z < 3; z++)	1077	for (z = 0; z < 3; z++)
598	for (y = 0; y < sh; y++)	1078	for (y = 0; y < sh; y++)
599	if (0 <= y + vy && y + vy < self->rows)	1079	if (0 <= y + vy && y + vy < self->rows)
600	{	1080	{
…		…
602		1082
603	for (x = 0; x < sw; x++)	1083	for (x = 0; x < sw; x++)
604	if (row->c0 <= x + vx && x + vx < row->c1)	1084	if (row->c0 <= x + vx && x + vx < row->c1)
605	{	1085	{
606	mapcell *cell = row->col + (x + vx - row->c0);	1086	mapcell *cell = row->col + (x + vx - row->c0);
		1087
		1088	darkness[y * sw4 + x] = cell->darkness < 0
		1089	? 255 - FOW_DARKNESS
		1090	: 255 - cell->darkness;
		1091
607	uint16_t face = cell->face [z];	1092	face = cell->face [z];
608		1093
609	if (face)	1094	if (face)
610	{	1095	{
611	mapface tex = self->face [face];	1096	maptex tex = self->tex [face];
612		1097
613	int px = (x + 1) * 32 - tex.w;	1098	int px = (x + 1) * 32 - tex.w;
614	int py = (y + 1) * 32 - tex.h;	1099	int py = (y + 1) * 32 - tex.h;
615		1100
616	if (last_name != tex.name)	1101	if (last_name != tex.name)
…		…
628	}	1113	}
629	}	1114	}
630	}	1115	}
631		1116
632	glEnd ();	1117	glEnd ();
633	}
634		1118
		1119	glDisable (GL_TEXTURE_2D);
		1120	glDisable (GL_BLEND);
		1121
		1122	EXTEND (SP, 3);
		1123	PUSHs (sv_2mortal (newSViv (sw4)));
		1124	PUSHs (sv_2mortal (newSViv (sh)));
		1125	PUSHs (darkness_sv);
		1126	}
		1127
		1128	SV *
		1129	get_rect (CFClient::Map self, int x0, int y0, int w, int h)
		1130	CODE:
		1131	{
		1132	int x, y, x1, y1;
		1133	SV *data_sv = newSV (w * h * 7 + 5);
		1134	uint8_t *data = (uint8_t *)SvPVX (data_sv);
		1135
		1136	*data++ = 0; /* version 0 format */
		1137	*data++ = w >> 8; *data++ = w;
		1138	*data++ = h >> 8; *data++ = h;
		1139
		1140	// we need to do this 'cause we don't keep an absolute coord system for rows
		1141	// TODO: treat rows as we treat columns
		1142	map_get_row (self, y0 + self->y - self->oy);//D
		1143	map_get_row (self, y0 + self->y - self->oy + h - 1);//D
		1144
		1145	x0 += self->x - self->ox;
		1146	y0 += self->y - self->oy;
		1147
		1148	x1 = x0 + w;
		1149	y1 = y0 + h;
		1150
		1151	for (y = y0; y < y1; y++)
		1152	{
		1153	maprow *row = 0 <= y && y < self->rows
		1154	? self->row + y
		1155	: 0;
		1156
		1157	for (x = x0; x < x1; x++)
		1158	{
		1159	if (row && row->c0 <= x && x < row->c1)
		1160	{
		1161	mapcell *cell = row->col + (x - row->c0);
		1162	uint8_t flags = 0;
		1163
		1164	if (cell->face [0]) flags |= 1;
		1165	if (cell->face [1]) flags |= 2;
		1166	if (cell->face [2]) flags |= 4;
		1167
		1168	*data++ = flags;
		1169
		1170	if (flags & 1)
		1171	{
		1172	*data++ = cell->face [0] >> 8;
		1173	*data++ = cell->face [0];
		1174	}
		1175
		1176	if (flags & 2)
		1177	{
		1178	*data++ = cell->face [1] >> 8;
		1179	*data++ = cell->face [1];
		1180	}
		1181
		1182	if (flags & 4)
		1183	{
		1184	*data++ = cell->face [2] >> 8;
		1185	*data++ = cell->face [2];
		1186	}
		1187	}
		1188	else
		1189	*data++ = 0;
		1190	}
		1191	}
		1192
		1193	SvPOK_only (data_sv);
		1194	SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
		1195	RETVAL = data_sv;
		1196	}
		1197	OUTPUT:
		1198	RETVAL
		1199
		1200	void
		1201	set_rect (CFClient::Map self, int x0, int y0, uint8_t *data)
		1202	PPCODE:
		1203	{
		1204	int x, y, z;
		1205	int w, h;
		1206	int x1, y1;
		1207
		1208	if (*data++ != 0)
		1209	return; /* version mismatch */
		1210
		1211	w = *data++ << 8; w |= *data++;
		1212	h = *data++ << 8; h |= *data++;
		1213
		1214	// we need to do this 'cause we don't keep an absolute coord system for rows
		1215	// TODO: treat rows as we treat columns
		1216	map_get_row (self, y0 + self->y - self->oy);//D
		1217	map_get_row (self, y0 + self->y - self->oy + h - 1);//D
		1218
		1219	x0 += self->x - self->ox;
		1220	y0 += self->y - self->oy;
		1221
		1222	x1 = x0 + w;
		1223	y1 = y0 + h;
		1224
		1225	for (y = y0; y < y1; y++)
		1226	{
		1227	maprow *row = map_get_row (self, y);
		1228
		1229	for (x = x0; x < x1; x++)
		1230	{
		1231	uint8_t flags = *data++;
		1232
		1233	if (flags)
		1234	{
		1235	mapface face[3] = { 0, 0, 0 };
		1236
		1237	mapcell *cell = row_get_cell (row, x);
		1238
		1239	if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; }
		1240	if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; }
		1241	if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; }
		1242
		1243	if (cell->darkness <= 0)
		1244	{
		1245	cell->darkness = -1;
		1246
		1247	for (z = 0; z <= 2; z++)
		1248	{
		1249	cell->face[z] = face[z];
		1250
		1251	if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name))
		1252	XPUSHs (sv_2mortal (newSViv (face[z])));
		1253	}
		1254	}
		1255	}
		1256	}
		1257	}
		1258	}
		1259
		1260	MODULE = CFClient PACKAGE = CFClient::MixChunk
		1261
		1262	CFClient::MixChunk
		1263	new_from_file (SV *class, char *path)
		1264	CODE:
		1265	RETVAL = Mix_LoadWAV (path);
		1266	OUTPUT:
		1267	RETVAL
		1268
		1269	void
		1270	DESTROY (CFClient::MixChunk self)
		1271	CODE:
		1272	Mix_FreeChunk (self);
		1273
		1274	int
		1275	volume (CFClient::MixChunk self, int volume = -1)
		1276	CODE:
		1277	RETVAL = Mix_VolumeChunk (self, volume);
		1278	OUTPUT:
		1279	RETVAL
		1280
		1281	int
		1282	play (CFClient::MixChunk self, int channel = -1, int loops = 0, int ticks = -1)
		1283	CODE:
		1284	RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
		1285	OUTPUT:
		1286	RETVAL
		1287
		1288	MODULE = CFClient PACKAGE = CFClient::MixMusic
		1289
		1290	int
		1291	volume (int volume = -1)
		1292	CODE:
		1293	RETVAL = Mix_VolumeMusic (volume);
		1294	OUTPUT:
		1295	RETVAL
		1296
		1297	CFClient::MixMusic
		1298	new_from_file (SV *class, char *path)
		1299	CODE:
		1300	RETVAL = Mix_LoadMUS (path);
		1301	OUTPUT:
		1302	RETVAL
		1303
		1304	void
		1305	DESTROY (CFClient::MixMusic self)
		1306	CODE:
		1307	Mix_FreeMusic (self);
		1308
		1309	int
		1310	play (CFClient::MixMusic self, int loops = -1)
		1311	CODE:
		1312	RETVAL = Mix_PlayMusic (self, loops);
		1313	OUTPUT:
		1314	RETVAL
		1315
		1316	MODULE = CFClient PACKAGE = CFClient::OpenGL
		1317
		1318	BOOT:
		1319	{
		1320	HV *stash = gv_stashpv ("CFClient::OpenGL", 1);
		1321	static const struct {
		1322	const char *name;
		1323	IV iv;
		1324	} *civ, const_iv[] = {
		1325	# define const_iv(name) { # name, (IV)name }
		1326	const_iv (GL_COLOR_MATERIAL),
		1327	const_iv (GL_SMOOTH),
		1328	const_iv (GL_FLAT),
		1329	const_iv (GL_BLEND),
		1330	const_iv (GL_AND),
		1331	const_iv (GL_SRC_ALPHA),
		1332	const_iv (GL_ONE_MINUS_SRC_ALPHA),
		1333	const_iv (GL_RGB),
		1334	const_iv (GL_RGBA),
		1335	const_iv (GL_UNSIGNED_BYTE),
		1336	const_iv (GL_ALPHA4),
		1337	const_iv (GL_ALPHA),
		1338	const_iv (GL_FLOAT),
		1339	const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
		1340	const_iv (GL_COMPILE),
		1341	const_iv (GL_TEXTURE_1D),
		1342	const_iv (GL_TEXTURE_2D),
		1343	const_iv (GL_TEXTURE_ENV),
		1344	const_iv (GL_TEXTURE_MAG_FILTER),
		1345	const_iv (GL_TEXTURE_MIN_FILTER),
		1346	const_iv (GL_TEXTURE_ENV_MODE),
		1347	const_iv (GL_TEXTURE_WRAP_S),
		1348	const_iv (GL_TEXTURE_WRAP_T),
		1349	const_iv (GL_CLAMP),
		1350	const_iv (GL_REPEAT),
		1351	const_iv (GL_NEAREST),
		1352	const_iv (GL_LINEAR),
		1353	const_iv (GL_NEAREST_MIPMAP_NEAREST),
		1354	const_iv (GL_LINEAR_MIPMAP_NEAREST),
		1355	const_iv (GL_NEAREST_MIPMAP_LINEAR),
		1356	const_iv (GL_LINEAR_MIPMAP_LINEAR),
		1357	const_iv (GL_GENERATE_MIPMAP),
		1358	const_iv (GL_LINEAR),
		1359	const_iv (GL_MODULATE),
		1360	const_iv (GL_REPLACE),
		1361	const_iv (GL_COLOR_BUFFER_BIT),
		1362	const_iv (GL_PROJECTION),
		1363	const_iv (GL_MODELVIEW),
		1364	const_iv (GL_COLOR_LOGIC_OP),
		1365	const_iv (GL_CONVOLUTION_2D),
		1366	const_iv (GL_CONVOLUTION_BORDER_MODE),
		1367	const_iv (GL_CONSTANT_BORDER),
		1368	const_iv (GL_LINES),
		1369	const_iv (GL_QUADS),
		1370	const_iv (GL_LINE_LOOP),
		1371	const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
		1372	const_iv (GL_FASTEST),
		1373	# undef const_iv
		1374	};
		1375
		1376	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
		1377	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
		1378	}
		1379
		1380	int glGetError ()
		1381
		1382	void glClear (int mask)
		1383
		1384	void glClearColor (float r, float g, float b, float a = 1.0)
		1385	PROTOTYPE: @
		1386
		1387	void glEnable (int cap)
		1388
		1389	void glDisable (int cap)
		1390
		1391	void glShadeModel (int mode)
		1392
		1393	void glHint (int target, int mode)
		1394
		1395	void glBlendFunc (int sfactor, int dfactor)
		1396
		1397	void glLogicOp (int opcode)
		1398
		1399	void glMatrixMode (int mode)
		1400
		1401	void glPushMatrix ()
		1402
		1403	void glPopMatrix ()
		1404
		1405	void glLoadIdentity ()
		1406
		1407	void glOrtho (double left, double right, double bottom, double top, double near, double far)
		1408
		1409	void glViewport (int x, int y, int width, int height)
		1410
		1411	void glTranslate (float x, float y, float z = 0.)
		1412	CODE:
		1413	glTranslatef (x, y, z);
		1414
		1415	void glScale (float x, float y, float z)
		1416	CODE:
		1417	glScalef (x, y, z);
		1418
		1419	void glRotate (float angle, float x, float y, float z)
		1420	CODE:
		1421	glRotatef (angle, x, y, z);
		1422
		1423	void glBegin (int mode)
		1424
		1425	void glEnd ()
		1426
		1427	void glColor (float r, float g, float b, float a = 1.0)
		1428	PROTOTYPE: @
		1429	CODE:
		1430	glColor4f (r, g, b, a);
		1431
		1432	void glVertex (float x, float y, float z = 0.)
		1433	CODE:
		1434	glVertex3f (x, y, z);
		1435
		1436	void glTexCoord (float s, float t)
		1437	CODE:
		1438	glTexCoord2f (s, t);
		1439
		1440	void glTexEnv (int target, int pname, float param)
		1441	CODE:
		1442	glTexEnvf (target, pname, param);
		1443
		1444	void glTexParameter (int target, int pname, float param)
		1445	CODE:
		1446	glTexParameterf (target, pname, param);
		1447
		1448	void glBindTexture (int target, int name)
		1449
		1450	void glConvolutionParameter (int target, int pname, float params)
		1451	CODE:
		1452	glConvolutionParameterf (target, pname, params);
		1453
		1454	void glConvolutionFilter2D (int target, int internalformat, int width, int height, int format, int type, char *data)
		1455
		1456	void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)
		1457
		1458	void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
		1459
		1460	int glGenTexture ()
		1461	CODE:
		1462	{
		1463	GLuint name;
		1464	glGenTextures (1, &name);
		1465	RETVAL = name;
		1466	}
		1467	OUTPUT:
		1468	RETVAL
		1469
		1470	void glDeleteTexture (int name)
		1471	CODE:
		1472	{
		1473	GLuint name_ = name;
		1474	glDeleteTextures (1, &name_);
		1475	}
		1476
		1477	int glGenList ()
		1478	CODE:
		1479	RETVAL = glGenLists (1);
		1480	OUTPUT:
		1481	RETVAL
		1482
		1483	void glDeleteList (int list)
		1484	CODE:
		1485	glDeleteLists (list, 1);
		1486
		1487	void glNewList (int list, int mode = GL_COMPILE)
		1488
		1489	void glEndList ()
		1490
		1491	void glCallList (int list)
		1492

Diff Legend

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