Esempio n. 1
0
/*
==============
R_DrawCulledPolys
==============
*/
void
R_DrawCulledPolys(void)
{
    surf_t *s;
    msurface_t *pface;

    currententity = &r_worldentity;
    if (r_worldpolysbacktofront) {
	for (s = surface_p - 1; s > &surfaces[1]; s--) {
	    if (!s->spans)
		continue;

	    if (!(s->flags & SURF_DRAWBACKGROUND)) {
		pface = (msurface_t *)s->data;
		R_RenderPoly(pface, 15);
	    }
	}
    } else {
	for (s = &surfaces[1]; s < surface_p; s++) {
	    if (!s->spans)
		continue;

	    if (!(s->flags & SURF_DRAWBACKGROUND)) {
		pface = (msurface_t *)s->data;
		R_RenderPoly(pface, 15);
	    }
	}
    }
}
Esempio n. 2
0
/*
================
R_ZDrawSubmodelPolys
================
*/
void R_ZDrawSubmodelPolys(model_t * pmodel)
{
    int i, numsurfaces;
    msurface_t *psurf;
    float dot;
    mplane_t *pplane;

    psurf = &pmodel->surfaces[pmodel->firstmodelsurface];
    numsurfaces = pmodel->nummodelsurfaces;

    for (i = 0; i < numsurfaces; i++, psurf++) {
        // find which side of the node we are on
        pplane = psurf->plane;

        dot = DotProduct(modelorg, pplane->normal) - pplane->dist;

        // draw the polygon
        if (((psurf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON))
                || (!(psurf->flags & SURF_PLANEBACK)
                    && (dot > BACKFACE_EPSILON))) {
            // FIXME: use bounding-box-based frustum clipping info?
            R_RenderPoly(psurf, 15);
        }
    }
}
Esempio n. 3
0
/*
================
R_RenderWorld
================
*/
void R_RenderWorld (void)
{
	int			i;
	model_t		*clmodel;
	btofpoly_t	btofpolys[MAX_BTOFPOLYS];

	pbtofpolys = btofpolys;

	currententity = &cl_entities[0];
	VectorCopy (r_origin, modelorg);
	clmodel = currententity->model;
	r_pcurrentvertbase = clmodel->vertexes;

	R_RecursiveWorldNode (clmodel->nodes, 15);

// if the driver wants the polygons back to front, play the visible ones back
// in that order
	if (r_worldpolysbacktofront)
	{
		for (i=numbtofpolys-1 ; i>=0 ; i--)
		{
			R_RenderPoly (btofpolys[i].psurf, btofpolys[i].clipflags);
		}
	}
}
Esempio n. 4
0
/*
================
R_RenderWorld
================
*/
void R_RenderWorld (void)
{
	int			i;
	model_t		*clmodel;
	btofpoly_t	btofpolys[MAX_BTOFPOLYS];

	GpError("A",8);

	pbtofpolys = btofpolys;

	currententity = &cl_entities[0];
	VectorCopy (r_origin, modelorg);

#ifdef USE_PQ_OPT1
	modelorg_fxp[0]=(int)(r_origin[0]*524288.0);
	modelorg_fxp[1]=(int)(r_origin[1]*524288.0);
	modelorg_fxp[2]=(int)(r_origin[2]*524288.0);

	//modelorg_fxp[0]=(int)(r_origin[0]*65536.0);
	//modelorg_fxp[1]=(int)(r_origin[1]*65536.0);
	//modelorg_fxp[2]=(int)(r_origin[2]*65536.0);

	vright_fxp[0]=(int)(256.0/vright[0]);
	if (!vright_fxp[0]) vright_fxp[0]=0x7fffffff;
	vright_fxp[1]=(int)(256.0/vright[1]);
	if (!vright_fxp[1]) vright_fxp[1]=0x7fffffff;
	vright_fxp[2]=(int)(256.0/vright[2]);
	if (!vright_fxp[2]) vright_fxp[2]=0x7fffffff;

	vpn_fxp[0]=(int)(256.0/vpn[0]);
	if (!vpn_fxp[0]) vpn_fxp[0]=0x7fffffff;
	vpn_fxp[1]=(int)(256.0/vpn[1]);
	if (!vpn_fxp[1]) vpn_fxp[1]=0x7fffffff;
	vpn_fxp[2]=(int)(256.0/vpn[2]);
	if (!vpn_fxp[2]) vpn_fxp[2]=0x7fffffff;

	vup_fxp[0]=(int)(256.0/vup[0]);
	if (!vup_fxp[0]) vup_fxp[0]=0x7fffffff;
	vup_fxp[1]=(int)(256.0/vup[1]);
	if (!vup_fxp[1]) vup_fxp[1]=0x7fffffff;
	vup_fxp[2]=(int)(256.0/vup[2]);
	if (!vup_fxp[2]) vup_fxp[2]=0x7fffffff;

#endif

	clmodel = currententity->model;
	r_pcurrentvertbase = clmodel->vertexes;

#ifdef USE_PQ_OPT2
	r_pcurrentvertbase_fxp = clmodel->vertexes_fxp;
#endif
#ifdef USE_PQ_OPT1
	//Dan Fixed point conversion stuff
	for (i=0; i<4; i++) {
		clipplanes_fxp[i][0]=(int)(view_clipplanes[i].normal[0]*65536.0);
		clipplanes_fxp[i][1]=(int)(view_clipplanes[i].normal[1]*65536.0);
		clipplanes_fxp[i][2]=(int)(view_clipplanes[i].normal[2]*65536.0);
		clipdist_fxp[i]		=(int)(view_clipplanes[i].dist*65536.0);
#ifdef USE_PQ_OPT2
		view_clipplanes_fxp[i].leftedge=view_clipplanes[i].leftedge;
		view_clipplanes_fxp[i].rightedge=view_clipplanes[i].rightedge;
		if (!view_clipplanes[i].normal[0]) view_clipplanes_fxp[i].normal[0]=2<<29;
		else view_clipplanes_fxp[i].normal[0]=(int)(4096.0f/view_clipplanes[i].normal[0]);
		if (!view_clipplanes[i].normal[0]) view_clipplanes_fxp[i].normal[0]=2<<29;

		if (!view_clipplanes[i].normal[1]) view_clipplanes_fxp[i].normal[1]=2<<29;
		else view_clipplanes_fxp[i].normal[1]=(int)(4096.0f/view_clipplanes[i].normal[1]);
		if (!view_clipplanes[i].normal[1]) view_clipplanes_fxp[i].normal[1]=2<<29;

		if (!view_clipplanes[i].normal[2]) view_clipplanes_fxp[i].normal[2]=2<<29;
		else view_clipplanes_fxp[i].normal[2]=(int)(4096.0f/view_clipplanes[i].normal[2]);
		if (!view_clipplanes[i].normal[2]) view_clipplanes_fxp[i].normal[2]=2<<29;

		view_clipplanes_fxp[i].dist=(int)(view_clipplanes[i].dist*128.0f);
#endif
#if defined(_X86_)&&defined(DEBUG)
		LogFloat(view_clipplanes[i].normal[0], "view_clipplanes[i].normal[0]", i, -1);
		LogFloat(view_clipplanes[i].normal[1], "view_clipplanes[i].normal[1]", i, -1);
		LogFloat(view_clipplanes[i].normal[2], "view_clipplanes[i].normal[2]", i, -1);
#endif
	}
#endif

	R_RecursiveWorldNode (clmodel->nodes, 15);

// if the driver wants the polygons back to front, play the visible ones back
// in that order
	if (r_worldpolysbacktofront)
	{
		for (i=numbtofpolys-1 ; i>=0 ; i--)
		{
			R_RenderPoly (btofpolys[i].psurf, btofpolys[i].clipflags);
		}
	}

}
Esempio n. 5
0
/*
================
R_RecursiveWorldNode
================
*/
void R_RecursiveWorldNode (mnode_t *node, int clipflags)
{
	int			i, c, side, *pindex;
	mplane_t	*plane;
	msurface_t	*surf, **mark;
	mleaf_t		*pleaf;
	double		dot;
#ifdef USE_PQ_OPT1
	int			d_fxp;
#else
	double		d;
	vec3_t		acceptpt, rejectpt;
#endif

	if (node->contents == CONTENTS_SOLID)
		return;		// solid

	if (node->visframe != r_visframecount)
		return;

// cull the clipping planes if not trivial accept
// FIXME: the compiler is doing a lousy job of optimizing here; it could be
//  twice as fast in ASM
	if (clipflags)
	{
		for (i=0 ; i<4 ; i++)
		{
			if (! (clipflags & (1<<i)) )
				continue;	// don't need to clip against it

		// generate accept and reject points
		// FIXME: do with fast look-ups or integer tests based on the sign bit
		// of the floating point values
			pindex = pfrustum_indexes[i];
#ifdef USE_PQ_OPT1
			d_fxp=node->minmaxs[pindex[0]]*clipplanes_fxp[i][0]+node->minmaxs[pindex[1]]*clipplanes_fxp[i][1]+node->minmaxs[pindex[2]]*clipplanes_fxp[i][2];
			d_fxp-=clipdist_fxp[i];

			if (d_fxp <= 0)
				return;

			d_fxp=node->minmaxs[pindex[3]]*clipplanes_fxp[i][0]+node->minmaxs[pindex[4]]*clipplanes_fxp[i][1]+node->minmaxs[pindex[5]]*clipplanes_fxp[i][2];
			d_fxp-=clipdist_fxp[i];

			if (d_fxp >= 0)
				clipflags &= ~(1<<i);	// node is entirely on screen
#else
			rejectpt[0] = (float)node->minmaxs[pindex[0]];
			rejectpt[1] = (float)node->minmaxs[pindex[1]];
			rejectpt[2] = (float)node->minmaxs[pindex[2]];

			d = DotProduct (rejectpt, view_clipplanes[i].normal);
			d -= view_clipplanes[i].dist;

			if (d <= 0)
				return;

			acceptpt[0] = (float)node->minmaxs[pindex[3+0]];
			acceptpt[1] = (float)node->minmaxs[pindex[3+1]];
			acceptpt[2] = (float)node->minmaxs[pindex[3+2]];

			d = DotProduct (acceptpt, view_clipplanes[i].normal);
			d -= view_clipplanes[i].dist;

			if (d >= 0)
				clipflags &= ~(1<<i);	// node is entirely on screen
#endif
		}
	}

// if a leaf node, draw stuff
	if (node->contents < 0)
	{
		pleaf = (mleaf_t *)node;

		mark = pleaf->firstmarksurface;
		c = pleaf->nummarksurfaces;

		if (c)
		{
			do
			{
				(*mark)->visframe = r_framecount;
				mark++;
			} while (--c);
		}

	// deal with model fragments in this leaf
		if (pleaf->efrags)
		{
			R_StoreEfrags (&pleaf->efrags);
		}

		pleaf->key = r_currentkey;
		r_currentkey++;		// all bmodels in a leaf share the same key
	}
	else
	{
	// node is just a decision point, so go down the apropriate sides

	// find which side of the node we are on
		plane = node->plane;

		switch (plane->type)
		{
		case PLANE_X:
			dot = modelorg[0] - plane->dist;
			break;
		case PLANE_Y:
			dot = modelorg[1] - plane->dist;
			break;
		case PLANE_Z:
			dot = modelorg[2] - plane->dist;
			break;
		default:
			dot = DotProduct (modelorg, plane->normal) - plane->dist;
			break;
		}

		if (dot >= 0)
			side = 0;
		else
			side = 1;

	// recurse down the children, front side first
		R_RecursiveWorldNode (node->children[side], clipflags);

	// draw stuff
		c = node->numsurfaces;

		if (c)
		{
			surf = cl.worldmodel->surfaces + node->firstsurface;

			if (dot < -BACKFACE_EPSILON)
			{
				do
				{
					if ((surf->flags & SURF_PLANEBACK) &&
						(surf->visframe == r_framecount))

					{
						if (r_drawpolys)
						{
							if (r_worldpolysbacktofront)
							{
								if (numbtofpolys < MAX_BTOFPOLYS)
								{
									pbtofpolys[numbtofpolys].clipflags =
											clipflags;
									pbtofpolys[numbtofpolys].psurf = surf;
									numbtofpolys++;
								}
							}
							else
							{
								R_RenderPoly (surf, clipflags);
							}
						}
						else
						{

							R_RenderFace (surf, clipflags);

						}
					}

					surf++;
				} while (--c);
			}
			else if (dot > BACKFACE_EPSILON)
			{
				do
				{
					if (!(surf->flags & SURF_PLANEBACK) &&
						(surf->visframe == r_framecount))

					{
						if (r_drawpolys)
						{
							if (r_worldpolysbacktofront)
							{
								if (numbtofpolys < MAX_BTOFPOLYS)
								{
									pbtofpolys[numbtofpolys].clipflags =
											clipflags;
									pbtofpolys[numbtofpolys].psurf = surf;
									numbtofpolys++;
								}
							}
							else
							{
								R_RenderPoly (surf, clipflags);
							}
						}
						else
						{

							R_RenderFace (surf, clipflags);

						}
					}

					surf++;
				} while (--c);
			}

		// all surfaces on the same node share the same sequence number
			r_currentkey++;
		}

	// recurse down the back side
		R_RecursiveWorldNode (node->children[!side], clipflags);

	}
}