[ViewVC] Diff of: cvs/deliantra/Deliantra-Client/Client.xs

Comparing deliantra/Deliantra-Client/Client.xs (file contents):
Revision 1.322 by root, Sun Nov 18 01:43:12 2018 UTC vs.
Revision 1.330 by root, Sun Nov 18 15:24:24 2018 UTC

…		…
32	#include <cstring>	32	#include <cstring>
33	#include <cstdio>	33	#include <cstdio>
34	#include <cstdlib>	34	#include <cstdlib>
35		35
36	#include <utility>	36	#include <utility>
		37	#include <bitset>
37		38
38	#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW	39	#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
39		40
40	#include <SDL.h>	41	#include <SDL.h>
41	#include <SDL_thread.h>	42	#include <SDL_thread.h>
…		…
199	}	200	}
200		201
201	return 0;	202	return 0;
202	}	203	}
203		204
204	typedef struct cf_layout {	205	struct cf_layout {
205	PangoLayout *pl;	206	PangoLayout *pl;
206	float r, g, b, a; // default color for rgba mode	207	float r, g, b, a; // default color for rgba mode
207	int base_height;	208	int base_height;
208	DC__Font font;	209	DC__Font font;
209	rc_t *rc;	210	rc_t rc;
210	} *DC__Layout;	211	};
		212
		213	typedef cf_layout *DC__Layout;
211		214
212	static DC__Font default_font;	215	static DC__Font default_font;
213	static PangoContext *opengl_context;	216	static PangoContext *opengl_context;
214	static PangoFontMap *opengl_fontmap;	217	static PangoFontMap *opengl_fontmap;
215		218
…		…
256	}	259	}
257		260
258	typedef uint16_t tileid;	261	typedef uint16_t tileid;
259	typedef uint16_t faceid;	262	typedef uint16_t faceid;
260		263
261	typedef struct {	264	struct maptex
		265	{
262	GLuint name;	266	GLuint name;
263	int w, h;	267	int w, h;
264	float s, t;	268	float s, t;
265	uint8_t r, g, b, a;	269	uint8_t r, g, b, a;
266	tileid smoothtile;	270	tileid smoothtile;
267	uint8_t smoothlevel;	271	uint8_t smoothlevel;
268	uint8_t unused; /* set to zero on use */	272	uint8_t unused; /* set to zero on use */
269	} maptex;	273	};
270		274
271	typedef struct {	275	struct mapcell
		276	{
272	uint32_t player;	277	uint32_t player;
273	tileid tile[3];	278	tileid tile[3];
274	uint16_t darkness;	279	uint16_t darkness;
275	uint8_t stat_width, stat_hp, flags, smoothmax;	280	uint8_t stat_width, stat_hp, flags, smoothmax;
276	} mapcell;	281	};
277		282
278	typedef struct {	283	struct maprow
		284	{
279	int32_t c0, c1;	285	int32_t c0, c1;
280	mapcell *col;	286	mapcell *col;
281	} maprow;	287	};
282		288
283	typedef struct map {	289	struct mapgrid {
284	int x, y, w, h;	290	int x, y, w, h;
285	int ox, oy; /* offset to virtual global coordinate system */	291	int ox, oy; /* offset to virtual global coordinate system */
286	int faces; tileid *face2tile; // [faceid]	292	int faces; tileid *face2tile; // [faceid]
287	int texs; maptex *tex; // [tileid]	293	int texs; maptex *tex; // [tileid]
288		294
289	int32_t rows;	295	int32_t rows;
290	maprow *row;	296	maprow *row;
291	} *DC__Map;	297	};
292		298
293	static char *	299	typedef mapgrid *DC__Map;
		300
		301	template<typename T>
		302	static void
294	prepend (char *ptr, int sze, int inc)	303	prepend (T *&ptr, int sze, int inc)
295	{	304	{
296	char *p;	305	T *p;
297		306
298	New (0, p, sze + inc, char);	307	Newxz (p, sze + inc, T);
299	Zero (p, inc, char);
300	Move (ptr, p + inc, sze, char);	308	Move (ptr, p + inc, sze, T);
301	Safefree (ptr);	309	Safefree (ptr);
302		310
303	return p;	311	ptr = p;
304	}	312	}
305		313
306	static char *	314	template<typename T>
307	append (char *ptr, int sze, int inc)
308	{
309	Renew (ptr, sze + inc, char);
310	Zero (ptr + sze, inc, char);
311
312	return ptr;
313	}
314
315	#define Append(type,ptr,sze,inc) (ptr) = (type )append ((char )ptr, (sze) * sizeof (type), (inc) * sizeof (type))
316	#define Prepend(type,ptr,sze,inc) (ptr) = (type )prepend ((char )ptr, (sze) * sizeof (type), (inc) * sizeof (type))
317
318	static void	315	static void
		316	append (T *&ptr, int sze, int inc)
		317	{
		318	Renew (ptr, sze + inc, T);
		319	Zero (ptr + sze, inc, T);
		320	}
		321
		322	static void
319	need_facenum (struct map *self, faceid face)	323	need_facenum (struct mapgrid *self, faceid face)
320	{	324	{
321	while (self->faces <= face)	325	while (self->faces <= face)
322	{	326	{
323	Append (tileid, self->face2tile, self->faces, self->faces);	327	append (self->face2tile, self->faces, self->faces);
324	self->faces *= 2;	328	self->faces *= 2;
325	}	329	}
326	}	330	}
327		331
328	static void	332	static void
329	need_texid (struct map *self, int texid)	333	need_texid (struct mapgrid *self, int texid)
330	{	334	{
331	while (self->texs <= texid)	335	while (self->texs <= texid)
332	{	336	{
333	Append (maptex, self->tex, self->texs, self->texs);	337	append (self->tex, self->texs, self->texs);
334	self->texs *= 2;	338	self->texs *= 2;
335	}	339	}
336	}	340	}
337		341
338	static maprow *	342	static maprow *
339	map_get_row (DC__Map self, int y)	343	map_get_row (mapgrid *self, int y)
340	{	344	{
341	if (0 > y)	345	if (0 > y)
342	{	346	{
343	int extend = - y + MAP_EXTEND_Y;	347	int extend = - y + MAP_EXTEND_Y;
344	Prepend (maprow, self->row, self->rows, extend);	348	prepend (self->row, self->rows, extend);
345		349
346	self->rows += extend;	350	self->rows += extend;
347	self->y += extend;	351	self->y += extend;
348	y += extend;	352	y += extend;
349	}	353	}
350	else if (y >= self->rows)	354	else if (y >= self->rows)
351	{	355	{
352	int extend = y - self->rows + MAP_EXTEND_Y;	356	int extend = y - self->rows + MAP_EXTEND_Y;
353	Append (maprow, self->row, self->rows, extend);	357	append (self->row, self->rows, extend);
354	self->rows += extend;	358	self->rows += extend;
355	}	359	}
356		360
357	return self->row + y;	361	return self->row + y;
358	}	362	}
…		…
368	}	372	}
369		373
370	if (row->c0 > x)	374	if (row->c0 > x)
371	{	375	{
372	int extend = row->c0 - x + MAP_EXTEND_X;	376	int extend = row->c0 - x + MAP_EXTEND_X;
373	Prepend (mapcell, row->col, row->c1 - row->c0, extend);	377	prepend (row->col, row->c1 - row->c0, extend);
374	row->c0 -= extend;	378	row->c0 -= extend;
375	}	379	}
376	else if (x >= row->c1)	380	else if (x >= row->c1)
377	{	381	{
378	int extend = x - row->c1 + MAP_EXTEND_X;	382	int extend = x - row->c1 + MAP_EXTEND_X;
379	Append (mapcell, row->col, row->c1 - row->c0, extend);	383	append (row->col, row->c1 - row->c0, extend);
380	row->c1 += extend;	384	row->c1 += extend;
381	}	385	}
382		386
383	return row->col + (x - row->c0);	387	return row->col + (x - row->c0);
384	}	388	}
385		389
386	static mapcell *	390	static mapcell *
387	map_get_cell (DC__Map self, int x, int y)	391	map_get_cell (mapgrid *self, int x, int y)
388	{	392	{
389	return row_get_cell (map_get_row (self, y), x);	393	return row_get_cell (map_get_row (self, y), x);
390	}	394	}
391		395
392	static void	396	static void
393	map_clear (DC__Map self)	397	map_clear (mapgrid *self)
394	{	398	{
395	int r;	399	int r;
396		400
397	for (r = 0; r < self->rows; r++)	401	for (r = 0; r < self->rows; r++)
398	Safefree (self->row[r].col);	402	Safefree (self->row[r].col);
…		…
416	(cell)->flags = 0; \	420	(cell)->flags = 0; \
417	(cell)->player = 0; \	421	(cell)->player = 0; \
418	} while (0)	422	} while (0)
419		423
420	static void	424	static void
421	map_blank (DC__Map self, int x0, int y0, int w, int h)	425	map_blank (mapgrid *self, int x0, int y0, int w, int h)
422	{	426	{
423	int x, y;	427	int x, y;
424	maprow *row;	428	maprow *row;
425	mapcell *cell;	429	mapcell *cell;
426		430
…		…
1361	tc_restore ();	1365	tc_restore ();
1362		1366
1363	DC::Layout	1367	DC::Layout
1364	new (SV *klass)	1368	new (SV *klass)
1365	CODE:	1369	CODE:
1366	New (0, RETVAL, 1, struct cf_layout);	1370	RETVAL = new cf_layout;
1367		1371
1368	RETVAL->pl = pango_layout_new (opengl_context);	1372	RETVAL->pl = pango_layout_new (opengl_context);
1369	RETVAL->r = 1.;	1373	RETVAL->r = 1.;
1370	RETVAL->g = 1.;	1374	RETVAL->g = 1.;
1371	RETVAL->b = 1.;	1375	RETVAL->b = 1.;
1372	RETVAL->a = 1.;	1376	RETVAL->a = 1.;
1373	RETVAL->base_height = MIN_FONT_HEIGHT;	1377	RETVAL->base_height = MIN_FONT_HEIGHT;
1374	RETVAL->font = 0;	1378	RETVAL->font = 0;
1375	RETVAL->rc = rc_alloc ();
1376		1379
1377	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);	1380	pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1378	layout_update_font (RETVAL);	1381	layout_update_font (RETVAL);
1379	OUTPUT:	1382	OUTPUT:
1380	RETVAL	1383	RETVAL
1381		1384
1382	void	1385	void
1383	DESTROY (DC::Layout self)	1386	DESTROY (DC::Layout self)
1384	CODE:	1387	CODE:
1385	g_object_unref (self->pl);	1388	g_object_unref (self->pl);
1386	rc_free (self->rc);
1387	Safefree (self);	1389	delete self;
1388		1390
1389	void	1391	void
1390	set_text (DC::Layout self, SV *text_)	1392	set_text (DC::Layout self, SV *text_)
1391	CODE:	1393	CODE:
1392	{	1394	{
…		…
1646	}	1648	}
1647		1649
1648	void	1650	void
1649	render (DC::Layout self, float x, float y, int flags = 0)	1651	render (DC::Layout self, float x, float y, int flags = 0)
1650	CODE:	1652	CODE:
1651	rc_clear (self->rc);	1653	self->rc.clear ();
1652	pango_opengl_render_layout_subpixel (	1654	pango_opengl_render_layout_subpixel (
1653	self->pl,	1655	self->pl,
1654	self->rc,	1656	&self->rc,
1655	x * PANGO_SCALE, y * PANGO_SCALE,	1657	x * PANGO_SCALE, y * PANGO_SCALE,
1656	self->r, self->g, self->b, self->a,	1658	self->r, self->g, self->b, self->a,
1657	flags	1659	flags
1658	);	1660	);
1659	// we assume that context_change actually clears/frees stuff	1661	// we assume that context_change actually clears/frees stuff
…		…
1670	gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,	1672	gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1671	GL_ONE , GL_ONE_MINUS_SRC_ALPHA);	1673	GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1672	glEnable (GL_ALPHA_TEST);	1674	glEnable (GL_ALPHA_TEST);
1673	glAlphaFunc (GL_GREATER, 7.f / 255.f);	1675	glAlphaFunc (GL_GREATER, 7.f / 255.f);
1674		1676
1675	rc_draw (self->rc);	1677	self->rc.draw ();
1676		1678
1677	glDisable (GL_ALPHA_TEST);	1679	glDisable (GL_ALPHA_TEST);
1678	glDisable (GL_BLEND);	1680	glDisable (GL_BLEND);
1679	glDisable (GL_TEXTURE_2D);	1681	glDisable (GL_TEXTURE_2D);
1680	}	1682	}
…		…
1894	PROTOTYPES: DISABLE	1896	PROTOTYPES: DISABLE
1895		1897
1896	DC::Map	1898	DC::Map
1897	new (SV *klass)	1899	new (SV *klass)
1898	CODE:	1900	CODE:
1899	New (0, RETVAL, 1, struct map);	1901	New (0, RETVAL, 1, mapgrid);
1900	RETVAL->x = 0;	1902	RETVAL->x = 0;
1901	RETVAL->y = 0;	1903	RETVAL->y = 0;
1902	RETVAL->w = 0;	1904	RETVAL->w = 0;
1903	RETVAL->h = 0;	1905	RETVAL->h = 0;
1904	RETVAL->ox = 0;	1906	RETVAL->ox = 0;
…		…
2050	self->ox += dx; self->x += dx;	2052	self->ox += dx; self->x += dx;
2051	self->oy += dy; self->y += dy;	2053	self->oy += dy; self->y += dy;
2052		2054
2053	while (self->y < 0)	2055	while (self->y < 0)
2054	{	2056	{
2055	Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);	2057	prepend (self->row, self->rows, MAP_EXTEND_Y);
2056		2058
2057	self->rows += MAP_EXTEND_Y;	2059	self->rows += MAP_EXTEND_Y;
2058	self->y += MAP_EXTEND_Y;	2060	self->y += MAP_EXTEND_Y;
2059	}	2061	}
2060	}	2062	}
…		…
2216	draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)	2218	draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
2217	CODE:	2219	CODE:
2218	{	2220	{
2219	int x, y, z;	2221	int x, y, z;
2220		2222
2221	uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
2222	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)	2223	static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
2223	smooth_key skey;
2224	int pl_x, pl_y;	2224	int pl_x, pl_y;
2225	maptex pl_tex;	2225	maptex pl_tex;
2226	rc_t *rc = rc_alloc ();	2226	rc_t rc;
2227	rc_t *rc_ov = rc_alloc ();	2227	rc_t rc_ov;
2228	rc_key_t key;	2228	rc_key_t key;
2229	rc_array_t *arr;	2229	rc_t::array_t *arr;
2230		2230
2231	pl_tex.name = 0;	2231	pl_tex.name = 0;
2232		2232
2233	// that's current max. sorry.	2233	// that's current max. sorry.
2234	if (sw > 255) sw = 255;	2234	if (sw > 255) sw = 255;
2235	if (sh > 255) sh = 255;	2235	if (sh > 255) sh = 255;
2236
2237	// clear key, in case of extra padding
2238	memset (&skey, 0, sizeof (skey));
2239		2236
2240	memset (&key, 0, sizeof (key));	2237	memset (&key, 0, sizeof (key));
2241	key.r = 255;	2238	key.r = 255;
2242	key.g = 255;	2239	key.g = 255;
2243	key.b = 255;	2240	key.b = 255;
…		…
2249	my += self->y;	2246	my += self->y;
2250		2247
2251	// first pass: determine smooth_max	2248	// first pass: determine smooth_max
2252	// rather ugly, if you ask me	2249	// rather ugly, if you ask me
2253	// could also be stored inside mapcell and updated on change	2250	// could also be stored inside mapcell and updated on change
2254	memset (smooth_max, 0, sizeof (smooth_max));	2251	memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
2255		2252
2256	for (y = 0; y < sh; y++)	2253	for (y = 0; y < sh; y++)
2257	if (0 <= y + my && y + my < self->rows)	2254	if (0 <= y + my && y + my < self->rows)
2258	{	2255	{
2259	maprow *row = self->row + (y + my);	2256	maprow *row = self->row + (y + my);
…		…
2274	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	2271	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2275	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	2272	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2276		2273
2277	for (z = 0; z <= 2; z++)	2274	for (z = 0; z <= 2; z++)
2278	{	2275	{
		2276	std::bitset<256> smooth_level; // one bit for every possible smooth level
		2277	smooth_key skey;
2279	smooth_hash smooth;	2278	smooth_hash smooth;
2280	memset (smooth_level, 0, sizeof (smooth_level));
2281	key.texname = -1;	2279	key.texname = -1;
2282		2280
2283	for (y = 0; y < sh; y++)	2281	for (y = 0; y < sh; y++)
2284	if (0 <= y + my && y + my < self->rows)	2282	if (0 <= y + my && y + my < self->rows)
2285	{	2283	{
…		…
2302		2300
2303	if (!tex.name)	2301	if (!tex.name)
2304	tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */	2302	tex = self->tex [TEXID_NOFACE]; /* missing, replace by noface */
2305		2303
2306	key.texname = tex.name;	2304	key.texname = tex.name;
2307	arr = rc_array (rc, &key);	2305	arr = &rc.array (key);
2308	}	2306	}
2309		2307
2310	px = (x + 1) * Th - tex.w;	2308	px = (x + 1) * Th - tex.w;
2311	py = (y + 1) * Tw - tex.h;	2309	py = (y + 1) * Tw - tex.h;
2312		2310
…		…
2316	pl_y = py;	2314	pl_y = py;
2317	pl_tex = tex;	2315	pl_tex = tex;
2318	continue;	2316	continue;
2319	}	2317	}
2320		2318
2321	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2319	arr->t2f_v3f (0 , 0 , px , py , 0);
2322	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);	2320	arr->t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2323	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);	2321	arr->t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2324	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2322	arr->t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2325		2323
2326	// update smooth hash	2324	// update smooth hash
2327	if (tex.smoothtile)	2325	if (tex.smoothtile)
2328	{	2326	{
2329	skey.tile = tex.smoothtile;	2327	skey.tile = tex.smoothtile;
2330	skey.level = tex.smoothlevel;	2328	skey.level = tex.smoothlevel;
2331		2329
2332	smooth_level [tex.smoothlevel >> 5] \|= ((uint32_t)1) << (tex.smoothlevel & 31);	2330	smooth_level[tex.smoothlevel] = 1;
2333		2331
2334	// add bits to current tile and all neighbours. skey.x\|y is	2332	// add bits to current tile and all neighbours. skey.x\|y is
2335	// shifted +1\|+1 so we always stay positive.	2333	// shifted +1\|+1 so we always stay positive.
2336		2334
2337	// bits is ___n cccc CCCC bbbb	2335	// bits is ___n cccc CCCC bbbb
…		…
2367	{	2365	{
2368	// overlays such as the speech bubble, probably more to come	2366	// overlays such as the speech bubble, probably more to come
2369	if (cell->flags & 1)	2367	if (cell->flags & 1)
2370	{	2368	{
2371	rc_key_t key_ov = key;	2369	rc_key_t key_ov = key;
2372	maptex tex = self->tex [TEXID_SPEECH];	2370	maptex tex = self->tex[TEXID_SPEECH];
2373	rc_array_t *arr;
2374	int px = x * Tw + Tw * 2 / 32;	2371	int px = x * Tw + Tw * 2 / 32;
2375	int py = y * Th - Th * 6 / 32;	2372	int py = y * Th - Th * 6 / 32;
2376		2373
2377	key_ov.texname = tex.name;	2374	key_ov.texname = tex.name;
2378	arr = rc_array (rc_ov, &key_ov);	2375	rc_t::array_t &arr = rc_ov.array (key_ov);
2379		2376
2380	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2377	arr.t2f_v3f (0 , 0 , px , py , 0);
2381	rc_t2f_v3f (arr, 0 , tex.t, px , py + Th, 0);	2378	arr.t2f_v3f (0 , tex.t, px , py + Th, 0);
2382	rc_t2f_v3f (arr, tex.s, tex.t, px + Tw, py + Th, 0);	2379	arr.t2f_v3f (tex.s, tex.t, px + Tw, py + Th, 0);
2383	rc_t2f_v3f (arr, tex.s, 0 , px + Tw, py , 0);	2380	arr.t2f_v3f (tex.s, 0 , px + Tw, py , 0);
2384	}	2381	}
2385	}	2382	}
2386	}	2383	}
2387	}	2384	}
2388		2385
2389	rc_draw (rc);	2386	rc.draw ();
2390	rc_clear (rc);	2387	rc.clear ();
2391		2388
2392	// go through all smoothlevels, lowest to highest, then draw.	2389	// go through all smoothlevels, lowest to highest, then draw.
2393	// this is basically counting sort	2390	// this is basically counting sort
2394	{	2391	{
2395	int w, b;	2392	int w, b;
2396		2393
2397	glEnable (GL_TEXTURE_2D);	2394	glEnable (GL_TEXTURE_2D);
2398	glBegin (GL_QUADS);	2395	glBegin (GL_QUADS);
2399	for (w = 0; w < 256 / 32; ++w)	2396	for (int level = 0; level < smooth_level.size (); ++level)
		2397	if (smooth_level[level])
		2398	for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
2400	{	2399	{
2401	uint32_t smask = smooth_level [w];	2400	smooth_key &skey = it->first;
2402	if (smask)	2401	IV bits = it->second;
2403	for (b = 0; b < 32; ++b)	2402
2404	if (smask & (((uint32_t)1) << b))	2403	if (!(bits & 0x1000)
		2404	&& skey.level == level
		2405	&& level > smooth_max [skey.x][skey.y])
2405	{	2406	{
2406	int level = (w << 5) \| b;	2407	maptex tex = self->tex [skey.tile];
		2408	int px = (((int)skey.x) - 1) * Tw;
		2409	int py = (((int)skey.y) - 1) * Th;
		2410	int border = bits & 15;
		2411	int corner = (bits >> 8) & ~(bits >> 4) & 15;
		2412	float dx = tex.s * .0625f; // 16 images/row
		2413	float dy = tex.t * .5f ; // 2 images/column
		2414
2407	HE *he;	2415	if (tex.name)
2408
2409	for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
2410	{	2416	{
2411	smooth_key &skey = it->first;	2417	// this time avoiding texture state changes
2412	IV bits = it->second;	2418	// save gobs of state changes.
2413		2419	if (key.texname != tex.name)
2414	if (!(bits & 0x1000)
2415	&& skey.level == level
2416	&& level > smooth_max [skey.x][skey.y])
2417	{	2420	{
2418	maptex tex = self->tex [skey.tile];
2419	int px = (((int)skey.x) - 1) * Tw;
2420	int py = (((int)skey.y) - 1) * Th;
2421	int border = bits & 15;
2422	int corner = (bits >> 8) & ~(bits >> 4) & 15;
2423	float dx = tex.s * .0625f; // 16 images/row
2424	float dy = tex.t * .5f ; // 2 images/column
2425
2426	if (tex.name)
2427	{
2428	// this time avoiding texture state changes
2429	// save gobs of state changes.
2430	if (key.texname != tex.name)
2431	{
2432	self->tex [skey.tile].unused = 0;	2421	self->tex [skey.tile].unused = 0;
2433		2422
2434	glEnd ();	2423	glEnd ();
2435	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);	2424	glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2436	glBegin (GL_QUADS);	2425	glBegin (GL_QUADS);
2437	}	2426	}
2438		2427
2439	if (border)	2428	if (border)
2440	{	2429	{
2441	float ox = border * dx;	2430	float ox = border * dx;
2442		2431
2443	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );	2432	glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2444	glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);	2433	glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2445	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);	2434	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2446	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );	2435	glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2447	}	2436	}
2448		2437
2449	if (corner)	2438	if (corner)
2450	{	2439	{
2451	float ox = corner * dx;	2440	float ox = corner * dx;
2452		2441
2453	glTexCoord2f (ox , dy ); glVertex2i (px , py );	2442	glTexCoord2f (ox , dy ); glVertex2i (px , py );
2454	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);	2443	glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2455	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);	2444	glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2456	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );	2445	glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2457	}
2458	}
2459	}	2446	}
2460	}	2447	}
2461	}	2448	}
2462	}	2449	}
2463		2450
2464	glEnd ();	2451	glEnd ();
2465	glDisable (GL_TEXTURE_2D);	2452	glDisable (GL_TEXTURE_2D);
2466	key.texname = -1;	2453	key.texname = -1;
2467	}	2454	}
…		…
2472	maptex tex = pl_tex;	2459	maptex tex = pl_tex;
2473	int px = pl_x + sdx;	2460	int px = pl_x + sdx;
2474	int py = pl_y + sdy;	2461	int py = pl_y + sdy;
2475		2462
2476	key.texname = tex.name;	2463	key.texname = tex.name;
2477	arr = rc_array (rc, &key);	2464	rc_t::array_t &arr = rc.array (key);
2478		2465
2479	rc_t2f_v3f (arr, 0 , 0 , px , py , 0);	2466	arr.t2f_v3f (0 , 0 , px , py , 0);
2480	rc_t2f_v3f (arr, 0 , tex.t, px , py + tex.h, 0);	2467	arr.t2f_v3f (0 , tex.t, px , py + tex.h, 0);
2481	rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);	2468	arr.t2f_v3f (tex.s, tex.t, px + tex.w, py + tex.h, 0);
2482	rc_t2f_v3f (arr, tex.s, 0 , px + tex.w, py , 0);	2469	arr.t2f_v3f (tex.s, 0 , px + tex.w, py , 0);
2483		2470
2484	rc_draw (rc);	2471	rc.draw ();
2485	}	2472	}
2486		2473
2487	rc_draw (rc_ov);	2474	rc_ov.draw ();
2488	rc_clear (rc_ov);	2475	rc_ov.clear ();
2489		2476
2490	glDisable (GL_BLEND);	2477	glDisable (GL_BLEND);
2491	rc_free (rc);
2492	rc_free (rc_ov);
2493		2478
2494	// top layer: overlays such as the health bar	2479	// top layer: overlays such as the health bar
2495	for (y = 0; y < sh; y++)	2480	for (y = 0; y < sh; y++)
2496	if (0 <= y + my && y + my < self->rows)	2481	if (0 <= y + my && y + my < self->rows)
2497	{	2482	{

Diff Legend

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

Comparing deliantra/Deliantra-Client/Client.xs (file contents): Revision 1.322 by root, Sun Nov 18 01:43:12 2018 UTC vs. Revision 1.330 by root, Sun Nov 18 15:24:24 2018 UTC

Diff Legend

Comparing deliantra/Deliantra-Client/Client.xs (file contents):
Revision 1.322 by root, Sun Nov 18 01:43:12 2018 UTC vs.
Revision 1.330 by root, Sun Nov 18 15:24:24 2018 UTC