| 0,0 → 1,442 |
|---|
| /* |
| 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 the Free Software |
| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| |
| */ |
| // d_sprite.c: software top-level rasterization driver module for drawing |
| // sprites |
| |
| #include "quakedef.h" |
| #include "d_local.h" |
| |
| static int sprite_height; |
| static int minindex, maxindex; |
| static sspan_t *sprite_spans; |
| |
| #if !id386 |
| |
| /* |
| ===================== |
| D_SpriteDrawSpans |
| ===================== |
| */ |
| void D_SpriteDrawSpans (sspan_t *pspan) |
| { |
| int count, spancount, izistep; |
| int izi; |
| byte *pbase, *pdest; |
| fixed16_t s, t, snext, tnext, sstep, tstep; |
| float sdivz, tdivz, zi, z, du, dv, spancountminus1; |
| float sdivz8stepu, tdivz8stepu, zi8stepu; |
| byte btemp; |
| short *pz; |
| |
| sstep = 0; // keep compiler happy |
| tstep = 0; // ditto |
| |
| pbase = cacheblock; |
| |
| sdivz8stepu = d_sdivzstepu * 8; |
| tdivz8stepu = d_tdivzstepu * 8; |
| zi8stepu = d_zistepu * 8; |
| |
| // we count on FP exceptions being turned off to avoid range problems |
| izistep = (int)(d_zistepu * 0x8000 * 0x10000); |
| |
| do |
| { |
| pdest = (byte *)d_viewbuffer + (screenwidth * pspan->v) + pspan->u; |
| pz = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u; |
| |
| count = pspan->count; |
| |
| if (count <= 0) |
| goto NextSpan; |
| |
| // calculate the initial s/z, t/z, 1/z, s, and t and clamp |
| du = (float)pspan->u; |
| dv = (float)pspan->v; |
| |
| sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu; |
| tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu; |
| zi = d_ziorigin + dv*d_zistepv + du*d_zistepu; |
| z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
| // we count on FP exceptions being turned off to avoid range problems |
| izi = (int)(zi * 0x8000 * 0x10000); |
| |
| s = (int)(sdivz * z) + sadjust; |
| if (s > bbextents) |
| s = bbextents; |
| else if (s < 0) |
| s = 0; |
| |
| t = (int)(tdivz * z) + tadjust; |
| if (t > bbextentt) |
| t = bbextentt; |
| else if (t < 0) |
| t = 0; |
| |
| do |
| { |
| // calculate s and t at the far end of the span |
| if (count >= 8) |
| spancount = 8; |
| else |
| spancount = count; |
| |
| count -= spancount; |
| |
| if (count) |
| { |
| // calculate s/z, t/z, zi->fixed s and t at far end of span, |
| // calculate s and t steps across span by shifting |
| sdivz += sdivz8stepu; |
| tdivz += tdivz8stepu; |
| zi += zi8stepu; |
| z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
| |
| snext = (int)(sdivz * z) + sadjust; |
| if (snext > bbextents) |
| snext = bbextents; |
| else if (snext < 8) |
| snext = 8; // prevent round-off error on <0 steps from |
| // from causing overstepping & running off the |
| // edge of the texture |
| |
| tnext = (int)(tdivz * z) + tadjust; |
| if (tnext > bbextentt) |
| tnext = bbextentt; |
| else if (tnext < 8) |
| tnext = 8; // guard against round-off error on <0 steps |
| |
| sstep = (snext - s) >> 3; |
| tstep = (tnext - t) >> 3; |
| } |
| else |
| { |
| // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so |
| // can't step off polygon), clamp, calculate s and t steps across |
| // span by division, biasing steps low so we don't run off the |
| // texture |
| spancountminus1 = (float)(spancount - 1); |
| sdivz += d_sdivzstepu * spancountminus1; |
| tdivz += d_tdivzstepu * spancountminus1; |
| zi += d_zistepu * spancountminus1; |
| z = (float)0x10000 / zi; // prescale to 16.16 fixed-point |
| snext = (int)(sdivz * z) + sadjust; |
| if (snext > bbextents) |
| snext = bbextents; |
| else if (snext < 8) |
| snext = 8; // prevent round-off error on <0 steps from |
| // from causing overstepping & running off the |
| // edge of the texture |
| |
| tnext = (int)(tdivz * z) + tadjust; |
| if (tnext > bbextentt) |
| tnext = bbextentt; |
| else if (tnext < 8) |
| tnext = 8; // guard against round-off error on <0 steps |
| |
| if (spancount > 1) |
| { |
| sstep = (snext - s) / (spancount - 1); |
| tstep = (tnext - t) / (spancount - 1); |
| } |
| } |
| |
| do |
| { |
| btemp = *(pbase + (s >> 16) + (t >> 16) * cachewidth); |
| if (btemp != 255) |
| { |
| if (*pz <= (izi >> 16)) |
| { |
| *pz = izi >> 16; |
| *pdest = btemp; |
| } |
| } |
| |
| izi += izistep; |
| pdest++; |
| pz++; |
| s += sstep; |
| t += tstep; |
| } while (--spancount > 0); |
| |
| s = snext; |
| t = tnext; |
| |
| } while (count > 0); |
| |
| NextSpan: |
| pspan++; |
| |
| } while (pspan->count != DS_SPAN_LIST_END); |
| } |
| |
| #endif |
| |
| |
| /* |
| ===================== |
| D_SpriteScanLeftEdge |
| ===================== |
| */ |
| void D_SpriteScanLeftEdge (void) |
| { |
| int i, v, itop, ibottom, lmaxindex; |
| emitpoint_t *pvert, *pnext; |
| sspan_t *pspan; |
| float du, dv, vtop, vbottom, slope; |
| fixed16_t u, u_step; |
| |
| pspan = sprite_spans; |
| i = minindex; |
| if (i == 0) |
| i = r_spritedesc.nump; |
| |
| lmaxindex = maxindex; |
| if (lmaxindex == 0) |
| lmaxindex = r_spritedesc.nump; |
| |
| vtop = ceil (r_spritedesc.pverts[i].v); |
| |
| do |
| { |
| pvert = &r_spritedesc.pverts[i]; |
| pnext = pvert - 1; |
| |
| vbottom = ceil (pnext->v); |
| |
| if (vtop < vbottom) |
| { |
| du = pnext->u - pvert->u; |
| dv = pnext->v - pvert->v; |
| slope = du / dv; |
| u_step = (int)(slope * 0x10000); |
| // adjust u to ceil the integer portion |
| u = (int)((pvert->u + (slope * (vtop - pvert->v))) * 0x10000) + |
| (0x10000 - 1); |
| itop = (int)vtop; |
| ibottom = (int)vbottom; |
| |
| for (v=itop ; v<ibottom ; v++) |
| { |
| pspan->u = u >> 16; |
| pspan->v = v; |
| u += u_step; |
| pspan++; |
| } |
| } |
| |
| vtop = vbottom; |
| |
| i--; |
| if (i == 0) |
| i = r_spritedesc.nump; |
| |
| } while (i != lmaxindex); |
| } |
| |
| |
| /* |
| ===================== |
| D_SpriteScanRightEdge |
| ===================== |
| */ |
| void D_SpriteScanRightEdge (void) |
| { |
| int i, v, itop, ibottom; |
| emitpoint_t *pvert, *pnext; |
| sspan_t *pspan; |
| float du, dv, vtop, vbottom, slope, uvert, unext, vvert, vnext; |
| fixed16_t u, u_step; |
| |
| pspan = sprite_spans; |
| i = minindex; |
| |
| vvert = r_spritedesc.pverts[i].v; |
| if (vvert < r_refdef.fvrecty_adj) |
| vvert = r_refdef.fvrecty_adj; |
| if (vvert > r_refdef.fvrectbottom_adj) |
| vvert = r_refdef.fvrectbottom_adj; |
| |
| vtop = ceil (vvert); |
| |
| do |
| { |
| pvert = &r_spritedesc.pverts[i]; |
| pnext = pvert + 1; |
| |
| vnext = pnext->v; |
| if (vnext < r_refdef.fvrecty_adj) |
| vnext = r_refdef.fvrecty_adj; |
| if (vnext > r_refdef.fvrectbottom_adj) |
| vnext = r_refdef.fvrectbottom_adj; |
| |
| vbottom = ceil (vnext); |
| |
| if (vtop < vbottom) |
| { |
| uvert = pvert->u; |
| if (uvert < r_refdef.fvrectx_adj) |
| uvert = r_refdef.fvrectx_adj; |
| if (uvert > r_refdef.fvrectright_adj) |
| uvert = r_refdef.fvrectright_adj; |
| |
| unext = pnext->u; |
| if (unext < r_refdef.fvrectx_adj) |
| unext = r_refdef.fvrectx_adj; |
| if (unext > r_refdef.fvrectright_adj) |
| unext = r_refdef.fvrectright_adj; |
| |
| du = unext - uvert; |
| dv = vnext - vvert; |
| slope = du / dv; |
| u_step = (int)(slope * 0x10000); |
| // adjust u to ceil the integer portion |
| u = (int)((uvert + (slope * (vtop - vvert))) * 0x10000) + |
| (0x10000 - 1); |
| itop = (int)vtop; |
| ibottom = (int)vbottom; |
| |
| for (v=itop ; v<ibottom ; v++) |
| { |
| pspan->count = (u >> 16) - pspan->u; |
| u += u_step; |
| pspan++; |
| } |
| } |
| |
| vtop = vbottom; |
| vvert = vnext; |
| |
| i++; |
| if (i == r_spritedesc.nump) |
| i = 0; |
| |
| } while (i != maxindex); |
| |
| pspan->count = DS_SPAN_LIST_END; // mark the end of the span list |
| } |
| |
| |
| /* |
| ===================== |
| D_SpriteCalculateGradients |
| ===================== |
| */ |
| void D_SpriteCalculateGradients (void) |
| { |
| vec3_t p_normal, p_saxis, p_taxis, p_temp1; |
| float distinv; |
| |
| TransformVector (r_spritedesc.vpn, p_normal); |
| TransformVector (r_spritedesc.vright, p_saxis); |
| TransformVector (r_spritedesc.vup, p_taxis); |
| VectorInverse (p_taxis); |
| |
| distinv = 1.0 / (-DotProduct (modelorg, r_spritedesc.vpn)); |
| |
| d_sdivzstepu = p_saxis[0] * xscaleinv; |
| d_tdivzstepu = p_taxis[0] * xscaleinv; |
| |
| d_sdivzstepv = -p_saxis[1] * yscaleinv; |
| d_tdivzstepv = -p_taxis[1] * yscaleinv; |
| |
| d_zistepu = p_normal[0] * xscaleinv * distinv; |
| d_zistepv = -p_normal[1] * yscaleinv * distinv; |
| |
| d_sdivzorigin = p_saxis[2] - xcenter * d_sdivzstepu - |
| ycenter * d_sdivzstepv; |
| d_tdivzorigin = p_taxis[2] - xcenter * d_tdivzstepu - |
| ycenter * d_tdivzstepv; |
| d_ziorigin = p_normal[2] * distinv - xcenter * d_zistepu - |
| ycenter * d_zistepv; |
| |
| TransformVector (modelorg, p_temp1); |
| |
| sadjust = ((fixed16_t)(DotProduct (p_temp1, p_saxis) * 0x10000 + 0.5)) - |
| (-(cachewidth >> 1) << 16); |
| tadjust = ((fixed16_t)(DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5)) - |
| (-(sprite_height >> 1) << 16); |
| |
| // -1 (-epsilon) so we never wander off the edge of the texture |
| bbextents = (cachewidth << 16) - 1; |
| bbextentt = (sprite_height << 16) - 1; |
| } |
| |
| |
| /* |
| ===================== |
| D_DrawSprite |
| ===================== |
| */ |
| void D_DrawSprite (void) |
| { |
| int i, nump; |
| float ymin, ymax; |
| emitpoint_t *pverts; |
| sspan_t spans[MAXHEIGHT+1]; |
| |
| sprite_spans = spans; |
| |
| // find the top and bottom vertices, and make sure there's at least one scan to |
| // draw |
| ymin = 999999.9; |
| ymax = -999999.9; |
| pverts = r_spritedesc.pverts; |
| |
| for (i=0 ; i<r_spritedesc.nump ; i++) |
| { |
| if (pverts->v < ymin) |
| { |
| ymin = pverts->v; |
| minindex = i; |
| } |
| |
| if (pverts->v > ymax) |
| { |
| ymax = pverts->v; |
| maxindex = i; |
| } |
| |
| pverts++; |
| } |
| |
| ymin = ceil (ymin); |
| ymax = ceil (ymax); |
| |
| if (ymin >= ymax) |
| return; // doesn't cross any scans at all |
| |
| cachewidth = r_spritedesc.pspriteframe->width; |
| sprite_height = r_spritedesc.pspriteframe->height; |
| cacheblock = (byte *)&r_spritedesc.pspriteframe->pixels[0]; |
| |
| // copy the first vertex to the last vertex, so we don't have to deal with |
| // wrapping |
| nump = r_spritedesc.nump; |
| pverts = r_spritedesc.pverts; |
| pverts[nump] = pverts[0]; |
| |
| D_SpriteCalculateGradients (); |
| D_SpriteScanLeftEdge (); |
| D_SpriteScanRightEdge (); |
| D_SpriteDrawSpans (sprite_spans); |
| } |
| |