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.35 by root, Fri Apr 14 02:03:10 2006 UTC vs.
Revision 1.62 by root, Mon Apr 24 02:41:47 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, 0);	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)
…		…
155	row->col[x - row->c0].darkness = -1;	242	row->col[x - row->c0].darkness = -1;
156	}	243	}
157	}	244	}
158	}	245	}
159		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
160	MODULE = CFClient PACKAGE = CFClient	260	MODULE = CFClient PACKAGE = CFClient
161		261
162	PROTOTYPES: ENABLE	262	PROTOTYPES: ENABLE
163		263
164	BOOT:	264	BOOT:
165	{	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
166	fontmap = pango_ft2_font_map_new ();	376	fontmap = pango_ft2_font_map_new ();
167	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);
168	context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap);	378	context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap);
169	}	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)
170		492
171	void	493	void
172	lowdelay (int fd, int val = 1)	494	lowdelay (int fd, int val = 1)
173	CODE:	495	CODE:
		496	#ifndef _WIN32
174	setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));	497	setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
		498	#endif
175		499
176	char *	500	char *
177	gl_version ()	501	gl_version ()
178	CODE:	502	CODE:
179	RETVAL = (char *)glGetString (GL_VERSION);	503	RETVAL = (char *)glGetString (GL_VERSION);
…		…
189		513
190	void	514	void
191	add_font (char *file)	515	add_font (char *file)
192	CODE:	516	CODE:
193	FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */	517	FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */
194
195	void
196	set_font (char *file)
197	CODE:
198	{
199	int count;
200	FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
201	PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
202	FcPatternDestroy (pattern);
203	pango_context_set_font_description (context, font);
204	}
205		518
206	void	519	void
207	load_image_inline (SV *image_)	520	load_image_inline (SV *image_)
208	ALIAS:	521	ALIAS:
209	load_image_file = 1	522	load_image_file = 1
…		…
216	SDL_RWops *rw = ix	529	SDL_RWops *rw = ix
217	? SDL_RWFromFile (image, "r")	530	? SDL_RWFromFile (image, "r")
218	: SDL_RWFromConstMem (image, image_len);	531	: SDL_RWFromConstMem (image, image_len);
219		532
220	if (!rw)	533	if (!rw)
221	croak ("load_image: unable to open file");	534	croak ("load_image: %s", SDL_GetError ());
222		535
223	surface = IMG_Load_RW (rw, 1);	536	surface = IMG_Load_RW (rw, 1);
224	if (!surface)	537	if (!surface)
225	croak ("load_image: unable to read file");	538	croak ("load_image: %s", SDL_GetError ());
226		539
227	fmt.palette = NULL;	540	fmt.palette = NULL;
228	fmt.BitsPerPixel = 32;	541	fmt.BitsPerPixel = 32;
229	fmt.BytesPerPixel = 4;	542	fmt.BytesPerPixel = 4;
		543	#if SDL_BYTEORDER == SDL_LIL_ENDIAN
230	fmt.Rmask = 0x000000ff;	544	fmt.Rmask = 0x000000ff;
231	fmt.Gmask = 0x0000ff00;	545	fmt.Gmask = 0x0000ff00;
232	fmt.Bmask = 0x00ff0000;	546	fmt.Bmask = 0x00ff0000;
233	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
234	fmt.Rloss = 0;	554	fmt.Rloss = 0;
235	fmt.Gloss = 0;	555	fmt.Gloss = 0;
236	fmt.Bloss = 0;	556	fmt.Bloss = 0;
237	fmt.Aloss = 0;	557	fmt.Aloss = 0;
238	fmt.Rshift = 0;	558	fmt.Rshift = 0;
…		…
242	fmt.colorkey = 0;	562	fmt.colorkey = 0;
243	fmt.alpha = 0;	563	fmt.alpha = 0;
244		564
245	surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);	565	surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
246		566
		567	assert (surface2->pitch == surface2->w * 4);
		568
247	EXTEND (SP, 5);	569	EXTEND (SP, 5);
248	PUSHs (sv_2mortal (newSViv (surface2->w)));	570	PUSHs (sv_2mortal (newSViv (surface2->w)));
249	PUSHs (sv_2mortal (newSViv (surface2->h)));	571	PUSHs (sv_2mortal (newSViv (surface2->h)));
250	SDL_LockSurface (surface2);	572	SDL_LockSurface (surface2);
251	PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));	573	PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
252	SDL_UnlockSurface (surface2);	574	SDL_UnlockSurface (surface2);
253	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)));
254	PUSHs (sv_2mortal (newSViv (GL_RGBA)));	576	PUSHs (sv_2mortal (newSViv (GL_RGBA)));
255	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_INT_8_8_8_8_REV)));	577	PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
256		578
257	SDL_FreeSurface (surface);	579	SDL_FreeSurface (surface);
258	SDL_FreeSurface (surface2);	580	SDL_FreeSurface (surface2);
259	}	581	}
260		582
261	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
262	fatal (char *message)	609	fatal (char *message)
263	CODE:	610	CODE:
264	#ifdef WIN32	611	#ifdef _WIN32
265	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);
266	#else	613	#else
267	fprintf (stderr, "%s\n", message);	614	fprintf (stderr, "FATAL: %s\n", message);
268	#endif	615	#endif
269	exit (1);	616	exit (1);
270		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
271	MODULE = CFClient PACKAGE = CFClient::Layout	642	MODULE = CFClient PACKAGE = CFClient::Layout
272		643
273	CFClient::Layout	644	CFClient::Layout
274	new (SV *class, int base_height = 10)	645	new (SV *class, int base_height = MIN_FONT_HEIGHT)
275	CODE:	646	CODE:
276	New (0, RETVAL, 1, struct cf_layout);	647	New (0, RETVAL, 1, struct cf_layout);
		648	RETVAL->pl = pango_layout_new (context);
277	RETVAL->base_height = base_height;	649	RETVAL->base_height = base_height;
278	RETVAL->pl = pango_layout_new (context);	650	RETVAL->font = 0;
279	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);
280	OUTPUT:	653	OUTPUT:
281	RETVAL	654	RETVAL
282		655
283	void	656	void
284	DESTROY (CFClient::Layout self)	657	DESTROY (CFClient::Layout self)
…		…
304	char *text = SvPVutf8 (text_, textlen);	677	char *text = SvPVutf8 (text_, textlen);
305		678
306	pango_layout_set_markup (self->pl, text, textlen);	679	pango_layout_set_markup (self->pl, text, textlen);
307	}	680	}
308		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
309	void	699	void
310	set_height (CFClient::Layout self, int base_height)	700	set_height (CFClient::Layout self, int base_height)
311	CODE:	701	CODE:
		702	if (self->base_height != base_height)
		703	{
312	self->base_height = base_height;	704	self->base_height = base_height;
		705	layout_update_font (self);
		706	}
313		707
314	void	708	void
315	set_width (CFClient::Layout self, int max_width = -1)	709	set_width (CFClient::Layout self, int max_width = -1)
316	CODE:	710	CODE:
317	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);
…		…
320	size (CFClient::Layout self)	714	size (CFClient::Layout self)
321	PPCODE:	715	PPCODE:
322	{	716	{
323	int w, h;	717	int w, h;
324		718
325	layout_update (self);
326	layout_get_pixel_size (self, &w, &h);	719	layout_get_pixel_size (self, &w, &h);
327		720
328	EXTEND (SP, 2);	721	EXTEND (SP, 2);
329	PUSHs (sv_2mortal (newSViv (w)));	722	PUSHs (sv_2mortal (newSViv (w)));
330	PUSHs (sv_2mortal (newSViv (h)));	723	PUSHs (sv_2mortal (newSViv (h)));
…		…
333	int	726	int
334	xy_to_index (CFClient::Layout self, int x, int y)	727	xy_to_index (CFClient::Layout self, int x, int y)
335	CODE:	728	CODE:
336	{	729	{
337	int index, trailing;	730	int index, trailing;
338
339	layout_update (self);
340	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);
341
342	RETVAL = index;	732	RETVAL = index;
343	}	733	}
344	OUTPUT:	734	OUTPUT:
345	RETVAL	735	RETVAL
346		736
347	void	737	void
348	cursor_pos (CFClient::Layout self, int index)	738	cursor_pos (CFClient::Layout self, int index)
349	PPCODE:	739	PPCODE:
350	{	740	{
351	PangoRectangle strong_pos;	741	PangoRectangle strong_pos;
352	layout_update (self);
353	pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);	742	pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
354		743
355	EXTEND (SP, 3);	744	EXTEND (SP, 3);
356	PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));	745	PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
357	PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));	746	PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
…		…
364	{	753	{
365	SV *retval;	754	SV *retval;
366	int w, h;	755	int w, h;
367	FT_Bitmap bitmap;	756	FT_Bitmap bitmap;
368		757
369	layout_update (self);
370	layout_get_pixel_size (self, &w, &h);	758	layout_get_pixel_size (self, &w, &h);
371		759
372	retval = newSV (w * h);	760	retval = newSV (w * h);
373	SvPOK_only (retval);	761	SvPOK_only (retval);
374	SvCUR_set (retval, w * h);	762	SvCUR_set (retval, w * h);
…		…
391	}	779	}
392		780
393	MODULE = CFClient PACKAGE = CFClient::Texture	781	MODULE = CFClient PACKAGE = CFClient::Texture
394		782
395	void	783	void
396	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)
397	PROTOTYPE: $$$;$$	785	PROTOTYPE: $$$;$$
398	CODE:	786	CODE:
399	{	787	{
400	HV *hv = (HV *)SvRV (self);	788	HV *hv = (HV *)SvRV (self);
401	double s = SvNV (*hv_fetch (hv, "s", 1, 1));	789	float s = SvNV (*hv_fetch (hv, "s", 1, 1));
402	double t = SvNV (*hv_fetch (hv, "t", 1, 1));	790	float t = SvNV (*hv_fetch (hv, "t", 1, 1));
403	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));
404		793
405	if (items < 5)	794	if (items < 5)
406	{	795	{
407	w = SvNV (*hv_fetch (hv, "w", 1, 1));	796	w = SvNV (*hv_fetch (hv, "w", 1, 1));
408	h = SvNV (*hv_fetch (hv, "h", 1, 1));	797	h = SvNV (*hv_fetch (hv, "h", 1, 1));
409	}	798	}
410		799
411	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	}
412	glBegin (GL_QUADS);	805	glBegin (GL_QUADS);
413	glTexCoord2d (0, 0); glVertex2d (x , y );	806	glTexCoord2f (0, 0); glVertex2f (x , y );
414	glTexCoord2d (0, t); glVertex2d (x , y + h);	807	glTexCoord2f (0, t); glVertex2f (x , y + h);
415	glTexCoord2d (s, t); glVertex2d (x + w, y + h);	808	glTexCoord2f (s, t); glVertex2f (x + w, y + h);
416	glTexCoord2d (s, 0); glVertex2d (x + w, y );	809	glTexCoord2f (s, 0); glVertex2f (x + w, y );
417	glEnd ();	810	glEnd ();
418	}	811	}
419		812
420	MODULE = CFClient PACKAGE = CFClient::Map	813	MODULE = CFClient PACKAGE = CFClient::Map
421		814
422	CFClient::Map	815	CFClient::Map
423	new (SV *class, int map_width, int map_height)	816	new (SV *class, int map_width, int map_height)
424	CODE:	817	CODE:
425	New (0, RETVAL, 1, struct map);	818	New (0, RETVAL, 1, struct map);
426	RETVAL->x = 0;	819	RETVAL->x = 0;
427	RETVAL->y = 0;	820	RETVAL->y = 0;
428	RETVAL->w = map_width;	821	RETVAL->w = map_width;
429	RETVAL->h = map_height;	822	RETVAL->h = map_height;
430	RETVAL->vx = 0;	823	RETVAL->ox = 0;
431	RETVAL->vy = 0;	824	RETVAL->oy = 0;
432	RETVAL->faces = 8192;	825	RETVAL->faces = 8192;
433	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);
434	RETVAL->rows = 0;	829	RETVAL->rows = 0;
435	RETVAL->row = 0;	830	RETVAL->row = 0;
436	OUTPUT:	831	OUTPUT:
437	RETVAL	832	RETVAL
438		833
…		…
449	clear (CFClient::Map self)	844	clear (CFClient::Map self)
450	CODE:	845	CODE:
451	map_clear (self);	846	map_clear (self);
452		847
453	void	848	void
454	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)
455	CODE:	850	CODE:
456	{	851	{
457	while (self->faces < face)	852	while (self->faces <= face)
458	{	853	{
459	Append (mapface, self->face, self->faces, self->faces);	854	Append (mapface, self->face, self->faces, self->faces);
460	self->faces *= 2;	855	self->faces *= 2;
461	}	856	}
462		857
463	self->face [face].name = name;
464	self->face [face].w = w;	858	self->face [face] = texid;
465	self->face [face].h = h;
466	self->face [face].s = s;
467	self->face [face].t = t;
468	}	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
469		898
470	void	899	void
471	scroll (CFClient::Map self, int dx, int dy)	900	scroll (CFClient::Map self, int dx, int dy)
472	CODE:	901	CODE:
473	{	902	{
…		…
479	if (dy > 0)	908	if (dy > 0)
480	map_blank (self, self->x, self->y, self->w, dy - 1);	909	map_blank (self, self->x, self->y, self->w, dy - 1);
481	else if (dy < 0)	910	else if (dy < 0)
482	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);
483		912
484	self->x += dx;	913	self->ox += dx; self->x += dx;
485	self->y += dy;	914	self->oy += dy; self->y += dy;
486		915
487	while (self->y < 0)	916	while (self->y < 0)
488	{	917	{
489	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);	918	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
490		919
…		…
497	map1a_update (CFClient::Map self, SV *data_)	926	map1a_update (CFClient::Map self, SV *data_)
498	CODE:	927	CODE:
499	{	928	{
500	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);	929	uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
501	uint8_t *data_end = (uint8_t *)SvEND (data_);	930	uint8_t *data_end = (uint8_t *)SvEND (data_);
502		931	mapcell *cell;
		932	int x, y, flags;
		933
503	while (data < data_end)	934	while (data < data_end)
504	{	935	{
505	int flags = (data [0] << 8) + data [1]; data += 2;	936	flags = (data [0] << 8) + data [1]; data += 2;
506		937
507	int x = ((flags >> 10) & 63) + self->x;	938	x = ((flags >> 10) & 63) + self->x;
508	int y = ((flags >> 4) & 63) + self->y;	939	y = ((flags >> 4) & 63) + self->y;
509		940
510	while (y >= self->rows)	941	cell = map_get_cell (self, x, y);
511	{
512	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
513
514	self->rows += MAP_EXTEND_Y;
515	}
516
517	maprow *row = self->row + y;
518
519	if (!row->col)
520	{
521	Newz (0, row->col, MAP_EXTEND_X, mapcell);
522	row->c0 = self->x - MAP_EXTEND_X / 4;
523	row->c1 = row->c0 + MAP_EXTEND_X;
524	}
525
526	if (row->c0 > x)
527	{
528	int extend = row->c0 - x + MAP_EXTEND_X;
529	Prepend (mapcell, row->col, row->c1 - row->c0, extend);
530	row->c0 -= extend;
531	}
532	else if (x >= row->c1)
533	{
534	int extend = x - row->c1 + MAP_EXTEND_X;
535	Append (mapcell, row->col, row->c1 - row->c0, extend);
536	row->c1 += extend;
537	}
538
539	assert (y >= 0);
540	assert (y < self->rows);
541	assert (x >= row->c0);
542	assert (x < row->c1);
543	mapcell *cell = row->col + (x - row->c0);
544		942
545	if (flags & 15)	943	if (flags & 15)
546	{	944	{
547	if (cell->darkness < 0 && x < self->w && y < self->h)	945	if (cell->darkness < 0)
548	{	946	{
549	cell->darkness = 0;	947	cell->darkness = 0;
550	cell->face [0] = 0;	948	cell->face [0] = 0;
551	cell->face [1] = 0;	949	cell->face [1] = 0;
552	cell->face [2] = 0;	950	cell->face [2] = 0;
553	}	951	}
554		952
555	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(!)
556		956
557	if (flags & 4)	957	if (flags & 4)
558	{	958	{
559	cell->face [0] = (data [0] << 8) + data [1]; data += 2;	959	cell->face [0] = self->face [(data [0] << 8) + data [1]]; data += 2;
560	}	960	}
561		961
562	if (flags & 2)	962	if (flags & 2)
563	{	963	{
564	cell->face [1] = (data [0] << 8) + data [1]; data += 2;	964	cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2;
565	}	965	}
566		966
567	if (flags & 1)	967	if (flags & 1)
568	{	968	{
569	cell->face [2] = (data [0] << 8) + data [1]; data += 2;	969	cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
570	}	970	}
571	}	971	}
572	else	972	else
573	cell->darkness = -1;	973	cell->darkness = -1;
574	}	974	}
575	}	975	}
576		976
577	void	977	SV *
578	draw (CFClient::Map self, int x0, int y0, int sw, int sh)	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++)
		1000	{
		1001	int r = 32, g = 32, b = 32, a = 192;
		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);
		1029	}
		1030	}
		1031
		1032	RETVAL = map_sv;
		1033	}
		1034	OUTPUT:
		1035	RETVAL
		1036
		1037	void
		1038	draw (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh)
579	PPCODE:	1039	PPCODE:
580	{	1040	{
		1041	int vx, vy;
		1042	int x, y, z;
		1043	int last_name;
		1044	mapface face;
581	int sw4 = (sw + 3) & ~3;	1045	int sw4 = (sw + 3) & ~3;
582	SV *darkness_sv = sv_2mortal (newSV (sw4 * sh));	1046	SV *darkness_sv = sv_2mortal (newSV (sw4 * sh));
583	uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv);	1047	uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv);
584		1048
		1049	memset (darkness, 255, sw4 * sh);
585	SvPOK_only (darkness_sv);	1050	SvPOK_only (darkness_sv);
586	SvCUR_set (darkness_sv, sw4 * sh);	1051	SvCUR_set (darkness_sv, sw4 * sh);
587		1052
		1053	vx = self->x + (self->w - sw) / 2 - shift_x;
		1054	vy = self->y + (self->h - sh) / 2 - shift_y;
		1055
		1056	/*
588	int vx = self->vx = self->w >= sw	1057	int vx = self->vx = self->w >= sw
589	? self->x + (self->w - sw) / 2	1058	? self->x + (self->w - sw) / 2
590	: 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));
591		1060
592	int vy = self->vy = self->h >= sh	1061	int vy = self->vy = self->h >= sh
593	? self->y + (self->h - sh) / 2	1062	? self->y + (self->h - sh) / 2
594	: 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	*/
595		1065
596	glColor4ub (255, 255, 255, 255);	1066	glColor4ub (255, 255, 255, 255);
597		1067
598	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	1068	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
599	glEnable (GL_BLEND);	1069	glEnable (GL_BLEND);
600	glEnable (GL_TEXTURE_2D);	1070	glEnable (GL_TEXTURE_2D);
601	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	1071	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
602		1072
603	int x, y, z;
604
605	int last_name = 0;
606
607	glBegin (GL_QUADS);	1073	glBegin (GL_QUADS);
		1074
		1075	last_name = 0;
608		1076
609	for (z = 0; z < 3; z++)	1077	for (z = 0; z < 3; z++)
610	for (y = 0; y < sh; y++)	1078	for (y = 0; y < sh; y++)
611	if (0 <= y + vy && y + vy < self->rows)	1079	if (0 <= y + vy && y + vy < self->rows)
612	{	1080	{
…		…
619		1087
620	darkness[y * sw4 + x] = cell->darkness < 0	1088	darkness[y * sw4 + x] = cell->darkness < 0
621	? 255 - FOW_DARKNESS	1089	? 255 - FOW_DARKNESS
622	: 255 - cell->darkness;	1090	: 255 - cell->darkness;
623		1091
624	uint16_t face = cell->face [z];	1092	face = cell->face [z];
625		1093
626	if (face)	1094	if (face)
627	{	1095	{
628	mapface tex = self->face [face];	1096	maptex tex = self->tex [face];
629		1097
630	int px = (x + 1) * 32 - tex.w;	1098	int px = (x + 1) * 32 - tex.w;
631	int py = (y + 1) * 32 - tex.h;	1099	int py = (y + 1) * 32 - tex.h;
632		1100
633	if (last_name != tex.name)	1101	if (last_name != tex.name)
…		…
655	PUSHs (sv_2mortal (newSViv (sw4)));	1123	PUSHs (sv_2mortal (newSViv (sw4)));
656	PUSHs (sv_2mortal (newSViv (sh)));	1124	PUSHs (sv_2mortal (newSViv (sh)));
657	PUSHs (darkness_sv);	1125	PUSHs (darkness_sv);
658	}	1126	}
659		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 = 1.)
		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