HLFX.Ru Forum - R

HLFX.Ru Forum (https://hlfx.ru/forum/index.php)
- Half-Life SDK (https://hlfx.ru/forum/forumdisplay.php?forumid=8)
-- R_MarkLeaves (https://hlfx.ru/forum/showthread.php?threadid=2701)

1	void R_MarkLeaves (void)

3	byte *vis;

4	mnode_t *node;

  int		i;

7	if (r_oldviewleaf == r_viewleaf)

    return;

10	r_visframecount++;

11	r_oldviewleaf = r_viewleaf;

13	vis = Mod_LeafPVS (r_viewleaf, cl.worldmodel);

15	for (i=0 ; i<cl.worldmodel->numleafs ; i++)

17	if (vis[i>>3] & (1<<(i&7)))

19	node = (mnode_t *)&cl.worldmodel->leafs[i+1];

do

22	if (node->visframe == r_visframecount)

          break;

24	node->visframe = r_visframecount;

25	node = node->parent;

26	} while (node);

if (vis[i>>3] & (1<<(i&7)))

node = (mnode_t *)&cl.worldmodel->leafs[i+1];

Гугли статьи, читай комментарии в исходниках.
Я сомневаюсь, что кто-то тут всё бросит и начнёт читать лекцию об устройстве BSP в 3д-играх. Хотя кто знает?

Ну блин, я бы не отказался)
Пойду сам разберусь.
Оно мне в принципе и не надо, но для общего развития пригодилось бы.
Тогда вопрос:
Движок то старый, разчитан на медленные видяхи, есть ли смысл проверять невидимые участки карты - сама проверка не займет ли больше времени чем рисование ??

Огромное спасибо!

Побежал мучить свою программу

Я тут решил разбить все плоскости карты на треугольники.
Треугольники делаю по рёбрам фейса, точки плоскости беру методом из quake 1: ( рисует фейсы по крайней мере правильно )

1	numverts = 0;

2	for (i=0 ; i<fa->numedges ; i++)

4	lindex = loadmodel->surfedges[fa->firstedge + i];

6	if (lindex > 0)

7	vec = loadmodel->vertexes[loadmodel->edges[lindex].v[0]].position;

  else

9	vec = loadmodel->vertexes[loadmodel->edges[-lindex].v[1]].position;

10	VectorCopy (vec, verts[numverts]);

11	numverts++;

/*

2	=================

3	Mod_BuildPolygon

4	=================

*/

6	static void Mod_BuildPolygon( msurface_t surf, int numVerts, const float verts )

8	float s, t;

9	uint index, bufSize;

10	mtexinfo_t *texinfo = surf->texinfo;

11	int i, numElems;

12	byte *buffer;

13	vec3_t normal;

14	mesh_t *mesh;

16	// allocate mesh

17	numElems = (numVerts - 2) * 3;

19	// mesh + ( align vertex, align normal, (st + lmst) + elem * numElems) * numVerts;

20	bufSize = sizeof( mesh_t ) + numVerts * ( sizeof( vec4_t ) + sizeof( vec4_t ) + sizeof( vec4_t )) + numElems * sizeof( elem_t );

22	buffer = Mod_Malloc( loadmodel, bufSize );

24	mesh = (mesh_t *)buffer;

25	buffer += sizeof( mesh_t );

26	mesh->numVerts = numVerts;

27	mesh->numElems = numElems;

29	// setup pointers

30	mesh->vertexArray = (vec4_t *)buffer;

31	buffer += numVerts * sizeof( vec4_t );

32	mesh->normalsArray = (vec4_t *)buffer;

33	buffer += numVerts * sizeof( vec4_t );

34	mesh->stCoordArray = (vec2_t *)buffer;

35	buffer += numVerts * sizeof( vec2_t );

36	mesh->lmCoordArray = (vec2_t *)buffer;

37	buffer += numVerts * sizeof( vec2_t );

38	mesh->elems = (elem_t *)buffer;

39	buffer += numElems * sizeof( elem_t );

41	mesh->next = surf->mesh;

42	surf->mesh = mesh;

44	// create indices

45	for( i = 0, index = 2; i < mesh->numElems; i += 3, index++ )

47	mesh->elems[i+0] = 0;

48	mesh->elems[i+1] = index - 1;

49	mesh->elems[i+2] = index;

52	// setup normal

53	if( surf->flags & SURF_PLANEBACK )

54	VectorNegate( surf->plane->normal, normal );

55	else VectorCopy( surf->plane->normal, normal );

57	VectorNormalize( normal );

59	// create vertices

60	mesh->numVerts = numVerts;

62	for( i = 0; i < numVerts; i++, verts += 3 )

    // vertex

65	VectorCopy( verts, mesh->vertexArray[ i ] );

66	VectorCopy( normal, mesh->normalsArray[ i ] );

68	mesh->vertexArray[ i ][3] = 1.0f;

69	mesh->normalsArray[ i ][3] = 1.0f;

71	// texture coordinates

72	s = DotProduct( verts, texinfo->vecs[0] ) + texinfo->vecs[0][3];

73	if( texinfo->width != -1 ) s /= texinfo->width;

74	else s /= surf->shader->stages[0].textures[0]->width;

76	t = DotProduct( verts, texinfo->vecs[1] ) + texinfo->vecs[1][3];

77	if( texinfo->height != -1 ) t /= texinfo->height;

78	else t /= surf->shader->stages[0].textures[0]->height;

80	mesh->stCoordArray[ i ][0] = s;

81	mesh->stCoordArray[ i ][1] = t;

83	// lightmap texture coordinates

84	s = DotProduct( verts, texinfo->vecs[0] ) + texinfo->vecs[0][3] - surf->textureMins[0];

85	s += surf->lmS * LM_SAMPLE_SIZE;

86	s += LM_SAMPLE_SIZE >> 1;

87	s /= LIGHTMAP_TEXTURE_WIDTH * LM_SAMPLE_SIZE;

89	t = DotProduct( verts, texinfo->vecs[1] ) + texinfo->vecs[1][3] - surf->textureMins[1];

90	t += surf->lmT * LM_SAMPLE_SIZE;

91	t += LM_SAMPLE_SIZE >> 1;

92	t /= LIGHTMAP_TEXTURE_HEIGHT * LM_SAMPLE_SIZE;

94	mesh->lmCoordArray[ i ][0] = s;

95	mesh->lmCoordArray[ i ][1] = t;

1	typedef struct mesh_s

3	int numVerts;

4	int numElems;

6	vec4_t *vertexArray;

7	vec4_t *normalsArray;

8	vec2_t *stCoordArray;

9	vec2_t *lmCoordArray;

10	rgba_t *colorsArray;

11	elem_t *elems;

13	struct mesh_s *next; // temporary chain of subdivided surfaces

} mesh_t;

LIGHTMAP_TEXTURE_WIDTH и LIGHTMAP_TEXTURE_HEIGHT равны размеру твоих лайтмап в движке. Обычно это 256 х 256, халфа использует 128х128. LM_SAMPLE_SIZE - 16 (захардкоденное значение разрешения лайтмапы для хл1\ку1\ку2). Менять нельзя ни в коем случае.