mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-15 09:21:33 +00:00
325 lines
8 KiB
C
325 lines
8 KiB
C
/*
|
|
d_edge.c
|
|
|
|
(description)
|
|
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#define NH_DEFINE
|
|
#include "namehack.h"
|
|
|
|
#include "QF/cvar.h"
|
|
#include "QF/render.h"
|
|
#include "QF/sys.h"
|
|
|
|
#include "QF/scene/entity.h"
|
|
|
|
#include "d_local.h"
|
|
#include "r_internal.h"
|
|
#include "vid_internal.h"
|
|
#include "vid_sw.h"
|
|
|
|
static int miplevel;
|
|
|
|
float sw32_scale_for_mip;
|
|
|
|
static vec3_t transformed_modelorg;
|
|
|
|
|
|
void
|
|
sw32_D_DrawPoly (void)
|
|
{
|
|
// this driver takes spans, not polygons
|
|
}
|
|
|
|
|
|
int
|
|
sw32_D_MipLevelForScale (float scale)
|
|
{
|
|
int lmiplevel;
|
|
|
|
if (scale >= sw32_d_scalemip[0])
|
|
lmiplevel = 0;
|
|
else if (scale >= sw32_d_scalemip[1])
|
|
lmiplevel = 1;
|
|
else if (scale >= sw32_d_scalemip[2])
|
|
lmiplevel = 2;
|
|
else
|
|
lmiplevel = 3;
|
|
|
|
if (lmiplevel < sw32_d_minmip)
|
|
lmiplevel = sw32_d_minmip;
|
|
|
|
return lmiplevel;
|
|
}
|
|
|
|
// FIXME: clean this up
|
|
|
|
static void
|
|
D_DrawSolidSurface (surf_t *surf, int color)
|
|
{
|
|
espan_t *span;
|
|
|
|
switch(sw32_ctx->pixbytes) {
|
|
case 1:
|
|
{
|
|
byte *pdest, pix;
|
|
int u, u2;
|
|
|
|
pix = color;
|
|
for (span = surf->spans; span; span = span->pnext)
|
|
{
|
|
pdest = (byte *) sw32_d_viewbuffer + sw32_screenwidth * span->v;
|
|
u = span->u;
|
|
u2 = span->u + span->count - 1;
|
|
for (;u <= u2; u++)
|
|
pdest[u] = pix;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
short *pdest, pix;
|
|
int u, u2;
|
|
|
|
pix = sw32_8to16table[color];
|
|
for (span = surf->spans; span; span = span->pnext)
|
|
{
|
|
pdest = (short *) sw32_d_viewbuffer + sw32_screenwidth * span->v;
|
|
u = span->u;
|
|
u2 = span->u + span->count - 1;
|
|
for (;u <= u2; u++)
|
|
pdest[u] = pix;
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
int *pdest, pix;
|
|
int u, u2;
|
|
|
|
pix = d_8to24table[color];
|
|
for (span = surf->spans; span; span = span->pnext)
|
|
{
|
|
pdest = (int *) sw32_d_viewbuffer + sw32_screenwidth * span->v;
|
|
u = span->u;
|
|
u2 = span->u + span->count - 1;
|
|
for (;u <= u2; u++)
|
|
pdest[u] = pix;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
Sys_Error("D_DrawSolidSurface: unsupported r_pixbytes %i",
|
|
sw32_ctx->pixbytes);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
D_CalcGradients (msurface_t *pface)
|
|
{
|
|
float mipscale, t;
|
|
vec3_t p_temp1, p_saxis, p_taxis;
|
|
|
|
mipscale = 1.0 / (float) (1 << miplevel);
|
|
|
|
sw32_TransformVector (pface->texinfo->vecs[0], p_saxis);
|
|
sw32_TransformVector (pface->texinfo->vecs[1], p_taxis);
|
|
|
|
t = sw32_xscaleinv * mipscale;
|
|
sw32_d_sdivzstepu = p_saxis[0] * t;
|
|
sw32_d_tdivzstepu = p_taxis[0] * t;
|
|
|
|
t = sw32_yscaleinv * mipscale;
|
|
sw32_d_sdivzstepv = -p_saxis[1] * t;
|
|
sw32_d_tdivzstepv = -p_taxis[1] * t;
|
|
|
|
sw32_d_sdivzorigin = p_saxis[2] * mipscale -
|
|
sw32_xcenter * sw32_d_sdivzstepu -
|
|
sw32_ycenter * sw32_d_sdivzstepv;
|
|
sw32_d_tdivzorigin = p_taxis[2] * mipscale -
|
|
sw32_xcenter * sw32_d_tdivzstepu -
|
|
sw32_ycenter * sw32_d_tdivzstepv;
|
|
|
|
VectorScale (transformed_modelorg, mipscale, p_temp1);
|
|
|
|
t = 0x10000 * mipscale;
|
|
sw32_sadjust = ((fixed16_t) (DotProduct (p_temp1, p_saxis) * 0x10000 + 0.5)) -
|
|
((pface->texturemins[0] << 16) >> miplevel)
|
|
+ pface->texinfo->vecs[0][3] * t;
|
|
sw32_tadjust = ((fixed16_t) (DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5)) -
|
|
((pface->texturemins[1] << 16) >> miplevel)
|
|
+ pface->texinfo->vecs[1][3] * t;
|
|
|
|
// -1 (-epsilon) so we never wander off the edge of the texture
|
|
sw32_bbextents = ((pface->extents[0] << 16) >> miplevel) - 1;
|
|
sw32_bbextentt = ((pface->extents[1] << 16) >> miplevel) - 1;
|
|
}
|
|
|
|
|
|
void
|
|
sw32_D_DrawSurfaces (void)
|
|
{
|
|
surf_t *s;
|
|
msurface_t *pface;
|
|
surfcache_t *pcurrentcache;
|
|
vec3_t world_transformed_modelorg;
|
|
vec3_t local_modelorg;
|
|
|
|
currententity = &r_worldentity;
|
|
sw32_TransformVector (modelorg, transformed_modelorg);
|
|
VectorCopy (transformed_modelorg, world_transformed_modelorg);
|
|
|
|
// TODO: could preset a lot of this at mode set time
|
|
if (r_drawflat->int_val) {
|
|
for (s = &sw32_surfaces[1]; s < sw32_surface_p; s++) {
|
|
if (!s->spans)
|
|
continue;
|
|
|
|
d_zistepu = s->d_zistepu;
|
|
d_zistepv = s->d_zistepv;
|
|
d_ziorigin = s->d_ziorigin;
|
|
|
|
D_DrawSolidSurface (s, ((intptr_t) s->data & 0xFF));
|
|
sw32_D_DrawZSpans (s->spans);
|
|
}
|
|
} else {
|
|
for (s = &sw32_surfaces[1]; s < sw32_surface_p; s++) {
|
|
if (!s->spans)
|
|
continue;
|
|
|
|
sw32_r_drawnpolycount++;
|
|
|
|
d_zistepu = s->d_zistepu;
|
|
d_zistepv = s->d_zistepv;
|
|
d_ziorigin = s->d_ziorigin;
|
|
|
|
if (s->flags & SURF_DRAWSKY) {
|
|
if (!sw32_r_skymade) {
|
|
sw32_R_MakeSky ();
|
|
}
|
|
|
|
sw32_D_DrawSkyScans (s->spans);
|
|
sw32_D_DrawZSpans (s->spans);
|
|
} else if (s->flags & SURF_DRAWBACKGROUND) {
|
|
// set up a gradient for the background surface that places
|
|
// it effectively at infinity distance from the viewpoint
|
|
d_zistepu = 0;
|
|
d_zistepv = 0;
|
|
d_ziorigin = -0.9;
|
|
|
|
D_DrawSolidSurface (s, r_clearcolor->int_val & 0xFF);
|
|
sw32_D_DrawZSpans (s->spans);
|
|
} else if (s->flags & SURF_DRAWTURB) {
|
|
pface = s->data;
|
|
miplevel = 0;
|
|
sw32_cacheblock = ((byte *) pface->texinfo->texture +
|
|
pface->texinfo->texture->offsets[0]);
|
|
sw32_cachewidth = 64;
|
|
|
|
if (s->insubmodel) {
|
|
// FIXME: we don't want to do all this for every polygon!
|
|
// TODO: store once at start of frame
|
|
currententity = s->entity; // FIXME: make this passed in
|
|
// to sw32_R_RotateBmodel ()
|
|
VectorSubtract (r_origin,
|
|
Transform_GetWorldPosition (currententity->transform),
|
|
local_modelorg);
|
|
sw32_TransformVector (local_modelorg, transformed_modelorg);
|
|
|
|
sw32_R_RotateBmodel (); // FIXME: don't mess with the
|
|
// frustum, make entity passed in
|
|
}
|
|
|
|
D_CalcGradients (pface);
|
|
|
|
sw32_Turbulent (s->spans);
|
|
sw32_D_DrawZSpans (s->spans);
|
|
|
|
if (s->insubmodel) {
|
|
// restore the old drawing state
|
|
// FIXME: we don't want to do this every time!
|
|
// TODO: speed up
|
|
|
|
currententity = &r_worldentity;
|
|
VectorCopy (world_transformed_modelorg,
|
|
transformed_modelorg);
|
|
VectorCopy (base_vpn, vpn);
|
|
VectorCopy (base_vup, vup);
|
|
VectorCopy (base_vright, vright);
|
|
VectorCopy (base_modelorg, modelorg);
|
|
sw32_R_TransformFrustum ();
|
|
}
|
|
} else {
|
|
if (s->insubmodel) {
|
|
// FIXME: we don't want to do all this for every polygon!
|
|
// TODO: store once at start of frame
|
|
currententity = s->entity; // FIXME: make this passed in
|
|
// to sw32_R_RotateBmodel ()
|
|
VectorSubtract (r_origin,
|
|
Transform_GetWorldPosition (currententity->transform),
|
|
local_modelorg);
|
|
sw32_TransformVector (local_modelorg, transformed_modelorg);
|
|
|
|
sw32_R_RotateBmodel (); // FIXME: don't mess with the
|
|
// frustum, make entity passed in
|
|
}
|
|
|
|
pface = s->data;
|
|
miplevel = sw32_D_MipLevelForScale (s->nearzi * sw32_scale_for_mip
|
|
* pface->texinfo->mipadjust);
|
|
|
|
// FIXME: make this passed in to D_CacheSurface
|
|
pcurrentcache = sw32_D_CacheSurface (pface, miplevel);
|
|
|
|
sw32_cacheblock = (byte *) pcurrentcache->data;
|
|
sw32_cachewidth = pcurrentcache->width;
|
|
|
|
D_CalcGradients (pface);
|
|
|
|
sw32_D_DrawSpans (s->spans);
|
|
|
|
sw32_D_DrawZSpans (s->spans);
|
|
|
|
if (s->insubmodel) {
|
|
// restore the old drawing state
|
|
// FIXME: we don't want to do this every time!
|
|
// TODO: speed up
|
|
|
|
VectorCopy (world_transformed_modelorg,
|
|
transformed_modelorg);
|
|
VectorCopy (base_vpn, vpn);
|
|
VectorCopy (base_vup, vup);
|
|
VectorCopy (base_vright, vright);
|
|
VectorCopy (base_modelorg, modelorg);
|
|
sw32_R_TransformFrustum ();
|
|
currententity = &r_worldentity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|