diff --git a/src/r_draw.c b/src/r_draw.c
index db64805a44d36bf30d591e37e55e456ce354b632..5c91f87e831abbd4d394c20b9e30f6329c828ddb 100644
--- a/src/r_draw.c
+++ b/src/r_draw.c
@@ -960,6 +960,7 @@ void R_DrawViewBorder(void)
// ==========================================================================
#include "r_draw8.c"
+#include "r_draw8_npo2.c"
// ==========================================================================
// INCLUDE 16bpp DRAWING CODE HERE
diff --git a/src/r_draw.h b/src/r_draw.h
index d7a098f32b00eb737180918664fe77901cc82bd3..95ab80ed2820635c7f2581117491eddc2ba13c78 100644
--- a/src/r_draw.h
+++ b/src/r_draw.h
@@ -140,43 +140,56 @@ void R_DrawViewBorder(void);
void R_DrawColumn_8(void);
void R_DrawShadeColumn_8(void);
void R_DrawTranslucentColumn_8(void);
-
-#ifdef USEASM
-void ASMCALL R_DrawColumn_8_ASM(void);
-void ASMCALL R_DrawShadeColumn_8_ASM(void);
-void ASMCALL R_DrawTranslucentColumn_8_ASM(void);
-void ASMCALL R_Draw2sMultiPatchColumn_8_ASM(void);
-
-void ASMCALL R_DrawColumn_8_MMX(void);
-
-void ASMCALL R_Draw2sMultiPatchColumn_8_MMX(void);
-void ASMCALL R_DrawSpan_8_MMX(void);
-#endif
-
void R_DrawTranslatedColumn_8(void);
void R_DrawTranslatedTranslucentColumn_8(void);
+void R_Draw2sMultiPatchColumn_8(void);
+void R_Draw2sMultiPatchTranslucentColumn_8(void);
+void R_DrawFogColumn_8(void);
+void R_DrawColumnShadowed_8(void);
+
void R_DrawSpan_8(void);
+void R_DrawSplat_8(void);
+void R_DrawTranslucentSpan_8(void);
+void R_DrawTranslucentSplat_8(void);
#ifdef ESLOPE
-void R_CalcTiltedLighting(fixed_t start, fixed_t end);
void R_DrawTiltedSpan_8(void);
void R_DrawTiltedTranslucentSpan_8(void);
void R_DrawTiltedSplat_8(void);
+void R_CalcTiltedLighting(fixed_t start, fixed_t end);
+extern INT32 tiltlighting[MAXVIDWIDTH];
#endif
-void R_DrawSplat_8(void);
-void R_DrawTranslucentSplat_8(void);
-void R_DrawTranslucentSpan_8(void);
-void R_Draw2sMultiPatchColumn_8(void);
-void R_Draw2sMultiPatchTranslucentColumn_8(void);
-void R_DrawFogSpan_8(void);
-void R_DrawFogColumn_8(void);
-void R_DrawColumnShadowed_8(void);
-
#ifndef NOWATER
void R_DrawTranslucentWaterSpan_8(void);
-
extern INT32 ds_bgofs;
extern INT32 ds_waterofs;
#endif
+void R_DrawFogSpan_8(void);
+
+// Lactozilla: Non-powers-of-two
+void R_DrawSpan_NPO2_8(void);
+void R_DrawTranslucentSpan_NPO2_8(void);
+void R_DrawSplat_NPO2_8(void);
+void R_DrawTranslucentSplat_NPO2_8(void);
+#ifdef ESLOPE
+void R_DrawTiltedSpan_NPO2_8(void);
+void R_DrawTiltedTranslucentSpan_NPO2_8(void);
+void R_DrawTiltedSplat_NPO2_8(void);
+#endif
+#ifndef NOWATER
+void R_DrawTranslucentWaterSpan_NPO2_8(void);
+#endif
+
+#ifdef USEASM
+void ASMCALL R_DrawColumn_8_ASM(void);
+void ASMCALL R_DrawShadeColumn_8_ASM(void);
+void ASMCALL R_DrawTranslucentColumn_8_ASM(void);
+void ASMCALL R_Draw2sMultiPatchColumn_8_ASM(void);
+
+void ASMCALL R_DrawColumn_8_MMX(void);
+
+void ASMCALL R_Draw2sMultiPatchColumn_8_MMX(void);
+void ASMCALL R_DrawSpan_8_MMX(void);
+#endif
// ------------------
// 16bpp DRAWING CODE
diff --git a/src/r_draw8.c b/src/r_draw8.c
index db9bc4c3c4495d2b23e9723f117cdcb691fef0b4..a6a400945a661ff1a026e8a271fb9208042779ed 100644
--- a/src/r_draw8.c
+++ b/src/r_draw8.c
@@ -562,11 +562,8 @@ void R_DrawSpan_8 (void)
// bit per power of two (obviously)
// Ok, because I was able to eliminate the variable spot below, this function is now FASTER
// than the original span renderer. Whodathunkit?
- if (ds_powersoftwo)
- {
- xposition <<= nflatshiftup; yposition <<= nflatshiftup;
- xstep <<= nflatshiftup; ystep <<= nflatshiftup;
- }
+ xposition <<= nflatshiftup; yposition <<= nflatshiftup;
+ xstep <<= nflatshiftup; ystep <<= nflatshiftup;
source = ds_source;
colormap = ds_colormap;
@@ -575,82 +572,58 @@ void R_DrawSpan_8 (void)
if (dest+8 > deststop)
return;
- if (!ds_powersoftwo)
+ while (count >= 8)
{
- while (count-- && dest <= deststop)
- {
- fixed_t x = (xposition >> FRACBITS);
- fixed_t y = (yposition >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest++ = colormap[source[((y * ds_flatwidth) + x)]];
- xposition += xstep;
- yposition += ystep;
- }
+ // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
+ // have the uber complicated math to calculate it now, so that was a memory write we didn't
+ // need!
+ dest[0] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[1] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[2] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[3] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[4] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[5] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[6] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[7] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest += 8;
+ count -= 8;
}
- else
+ while (count-- && dest <= deststop)
{
- while (count >= 8)
- {
- // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
- // have the uber complicated math to calculate it now, so that was a memory write we didn't
- // need!
- dest[0] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
-
- dest[1] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
-
- dest[2] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
-
- dest[3] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
-
- dest[4] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
-
- dest[5] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
-
- dest[6] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
-
- dest[7] = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
-
- dest += 8;
- count -= 8;
- }
- while (count-- && dest <= deststop)
- {
- *dest++ = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
- xposition += xstep;
- yposition += ystep;
- }
+ *dest++ = colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]];
+ xposition += xstep;
+ yposition += ystep;
}
}
#ifdef ESLOPE
// R_CalcTiltedLighting
// Exactly what it says on the tin. I wish I wasn't too lazy to explain things properly.
-static INT32 tiltlighting[MAXVIDWIDTH];
+INT32 tiltlighting[MAXVIDWIDTH];
void R_CalcTiltedLighting(fixed_t start, fixed_t end)
{
// ZDoom uses a different lighting setup to us, and I couldn't figure out how to adapt their version
@@ -724,24 +697,7 @@ void R_DrawTiltedSpan_8(void)
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest = colormap[source[((y * ds_flatwidth) + x)]];
- }
- else
- *dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
+ *dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
dest++;
iz += ds_sz.x;
uz += ds_su.x;
@@ -778,24 +734,7 @@ void R_DrawTiltedSpan_8(void)
for (i = SPANSIZE-1; i >= 0; i--)
{
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest = colormap[source[((y * ds_flatwidth) + x)]];
- }
- else
- *dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
+ *dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
dest++;
u += stepu;
v += stepv;
@@ -811,24 +750,7 @@ void R_DrawTiltedSpan_8(void)
u = (INT64)(startu);
v = (INT64)(startv);
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest = colormap[source[((y * ds_flatwidth) + x)]];
- }
- else
- *dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
+ *dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
}
else
{
@@ -849,24 +771,7 @@ void R_DrawTiltedSpan_8(void)
for (; width != 0; width--)
{
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest = colormap[source[((y * ds_flatwidth) + x)]];
- }
- else
- *dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
+ *dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
dest++;
u += stepu;
v += stepv;
@@ -927,24 +832,7 @@ void R_DrawTiltedTranslucentSpan_8(void)
v = (INT64)(vz*z) + viewy;
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
- }
- else
- *dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
+ *dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
dest++;
iz += ds_sz.x;
uz += ds_su.x;
@@ -981,24 +869,7 @@ void R_DrawTiltedTranslucentSpan_8(void)
for (i = SPANSIZE-1; i >= 0; i--)
{
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
- }
- else
- *dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
+ *dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
dest++;
u += stepu;
v += stepv;
@@ -1014,24 +885,7 @@ void R_DrawTiltedTranslucentSpan_8(void)
u = (INT64)(startu);
v = (INT64)(startv);
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
- }
- else
- *dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
+ *dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
}
else
{
@@ -1052,24 +906,7 @@ void R_DrawTiltedTranslucentSpan_8(void)
for (; width != 0; width--)
{
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
- }
- else
- *dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
+ *dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
dest++;
u += stepu;
v += stepv;
@@ -1130,25 +967,7 @@ void R_DrawTiltedSplat_8(void)
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- val = source[((y * ds_flatwidth) + x)];
- }
- else
- val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
-
+ val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
if (val != TRANSPARENTPIXEL)
*dest = colormap[val];
@@ -1188,24 +1007,7 @@ void R_DrawTiltedSplat_8(void)
for (i = SPANSIZE-1; i >= 0; i--)
{
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- val = source[((y * ds_flatwidth) + x)];
- }
- else
- val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
+ val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
if (val != TRANSPARENTPIXEL)
*dest = colormap[val];
dest++;
@@ -1223,24 +1025,7 @@ void R_DrawTiltedSplat_8(void)
u = (INT64)(startu);
v = (INT64)(startv);
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- val = source[((y * ds_flatwidth) + x)];
- }
- else
- val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
+ val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
if (val != TRANSPARENTPIXEL)
*dest = colormap[val];
}
@@ -1264,24 +1049,6 @@ void R_DrawTiltedSplat_8(void)
{
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
- if (!ds_powersoftwo)
- {
- fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
- fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- val = source[((y * ds_flatwidth) + x)];
- }
- else
- val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
if (val != TRANSPARENTPIXEL)
*dest = colormap[val];
dest++;
@@ -1321,125 +1088,95 @@ void R_DrawSplat_8 (void)
// bit per power of two (obviously)
// Ok, because I was able to eliminate the variable spot below, this function is now FASTER
// than the original span renderer. Whodathunkit?
- if (ds_powersoftwo)
- {
- xposition <<= nflatshiftup; yposition <<= nflatshiftup;
- xstep <<= nflatshiftup; ystep <<= nflatshiftup;
- }
+ xposition <<= nflatshiftup; yposition <<= nflatshiftup;
+ xstep <<= nflatshiftup; ystep <<= nflatshiftup;
source = ds_source;
colormap = ds_colormap;
dest = ylookup[ds_y] + columnofs[ds_x1];
- if (!ds_powersoftwo)
- {
- while (count-- && dest <= deststop)
- {
- fixed_t x = (xposition >> FRACBITS);
- fixed_t y = (yposition >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- val = source[((y * ds_flatwidth) + x)];
- if (val != TRANSPARENTPIXEL)
- *dest = colormap[val];
- dest++;
- xposition += xstep;
- yposition += ystep;
- }
- }
- else
+ while (count >= 8)
{
- while (count >= 8)
- {
- // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
- // have the uber complicated math to calculate it now, so that was a memory write we didn't
- // need!
- //
- // <Callum> 4194303 = (2048x2048)-1 (2048x2048 is maximum flat size)
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- val &= 4194303;
- val = source[val];
- if (val != TRANSPARENTPIXEL)
- dest[0] = colormap[val];
- xposition += xstep;
- yposition += ystep;
+ // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
+ // have the uber complicated math to calculate it now, so that was a memory write we didn't
+ // need!
+ //
+ // <Callum> 4194303 = (2048x2048)-1 (2048x2048 is maximum flat size)
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ val &= 4194303;
+ val = source[val];
+ if (val != TRANSPARENTPIXEL)
+ dest[0] = colormap[val];
+ xposition += xstep;
+ yposition += ystep;
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- val &= 4194303;
- val = source[val];
- if (val != TRANSPARENTPIXEL)
- dest[1] = colormap[val];
- xposition += xstep;
- yposition += ystep;
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ val &= 4194303;
+ val = source[val];
+ if (val != TRANSPARENTPIXEL)
+ dest[1] = colormap[val];
+ xposition += xstep;
+ yposition += ystep;
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- val &= 4194303;
- val = source[val];
- if (val != TRANSPARENTPIXEL)
- dest[2] = colormap[val];
- xposition += xstep;
- yposition += ystep;
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ val &= 4194303;
+ val = source[val];
+ if (val != TRANSPARENTPIXEL)
+ dest[2] = colormap[val];
+ xposition += xstep;
+ yposition += ystep;
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- val &= 4194303;
- val = source[val];
- if (val != TRANSPARENTPIXEL)
- dest[3] = colormap[val];
- xposition += xstep;
- yposition += ystep;
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ val &= 4194303;
+ val = source[val];
+ if (val != TRANSPARENTPIXEL)
+ dest[3] = colormap[val];
+ xposition += xstep;
+ yposition += ystep;
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- val &= 4194303;
- val = source[val];
- if (val != TRANSPARENTPIXEL)
- dest[4] = colormap[val];
- xposition += xstep;
- yposition += ystep;
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ val &= 4194303;
+ val = source[val];
+ if (val != TRANSPARENTPIXEL)
+ dest[4] = colormap[val];
+ xposition += xstep;
+ yposition += ystep;
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- val &= 4194303;
- val = source[val];
- if (val != TRANSPARENTPIXEL)
- dest[5] = colormap[val];
- xposition += xstep;
- yposition += ystep;
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ val &= 4194303;
+ val = source[val];
+ if (val != TRANSPARENTPIXEL)
+ dest[5] = colormap[val];
+ xposition += xstep;
+ yposition += ystep;
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- val &= 4194303;
- val = source[val];
- if (val != TRANSPARENTPIXEL)
- dest[6] = colormap[val];
- xposition += xstep;
- yposition += ystep;
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ val &= 4194303;
+ val = source[val];
+ if (val != TRANSPARENTPIXEL)
+ dest[6] = colormap[val];
+ xposition += xstep;
+ yposition += ystep;
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- val &= 4194303;
- val = source[val];
- if (val != TRANSPARENTPIXEL)
- dest[7] = colormap[val];
- xposition += xstep;
- yposition += ystep;
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ val &= 4194303;
+ val = source[val];
+ if (val != TRANSPARENTPIXEL)
+ dest[7] = colormap[val];
+ xposition += xstep;
+ yposition += ystep;
- dest += 8;
- count -= 8;
- }
- while (count-- && dest <= deststop)
- {
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- *dest = colormap[val];
- dest++;
- xposition += xstep;
- yposition += ystep;
- }
+ dest += 8;
+ count -= 8;
+ }
+ while (count-- && dest <= deststop)
+ {
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+ dest++;
+ xposition += xstep;
+ yposition += ystep;
}
}
@@ -1470,112 +1207,82 @@ void R_DrawTranslucentSplat_8 (void)
// bit per power of two (obviously)
// Ok, because I was able to eliminate the variable spot below, this function is now FASTER
// than the original span renderer. Whodathunkit?
- if (ds_powersoftwo)
- {
- xposition <<= nflatshiftup; yposition <<= nflatshiftup;
- xstep <<= nflatshiftup; ystep <<= nflatshiftup;
- }
+ xposition <<= nflatshiftup; yposition <<= nflatshiftup;
+ xstep <<= nflatshiftup; ystep <<= nflatshiftup;
source = ds_source;
colormap = ds_colormap;
dest = ylookup[ds_y] + columnofs[ds_x1];
- if (!ds_powersoftwo)
- {
- while (count-- && dest <= deststop)
- {
- fixed_t x = (xposition >> FRACBITS);
- fixed_t y = (yposition >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- val = source[((y * ds_flatwidth) + x)];
- if (val != TRANSPARENTPIXEL)
- *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
- dest++;
- xposition += xstep;
- yposition += ystep;
- }
- }
- else
+ while (count >= 8)
{
- while (count >= 8)
- {
- // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
- // have the uber complicated math to calculate it now, so that was a memory write we didn't
- // need!
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- dest[0] = *(ds_transmap + (colormap[val] << 8) + dest[0]);
- xposition += xstep;
- yposition += ystep;
+ // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
+ // have the uber complicated math to calculate it now, so that was a memory write we didn't
+ // need!
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ dest[0] = *(ds_transmap + (colormap[val] << 8) + dest[0]);
+ xposition += xstep;
+ yposition += ystep;
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- dest[1] = *(ds_transmap + (colormap[val] << 8) + dest[1]);
- xposition += xstep;
- yposition += ystep;
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ dest[1] = *(ds_transmap + (colormap[val] << 8) + dest[1]);
+ xposition += xstep;
+ yposition += ystep;
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- dest[2] = *(ds_transmap + (colormap[val] << 8) + dest[2]);
- xposition += xstep;
- yposition += ystep;
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ dest[2] = *(ds_transmap + (colormap[val] << 8) + dest[2]);
+ xposition += xstep;
+ yposition += ystep;
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- dest[3] = *(ds_transmap + (colormap[val] << 8) + dest[3]);
- xposition += xstep;
- yposition += ystep;
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ dest[3] = *(ds_transmap + (colormap[val] << 8) + dest[3]);
+ xposition += xstep;
+ yposition += ystep;
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- dest[4] = *(ds_transmap + (colormap[val] << 8) + dest[4]);
- xposition += xstep;
- yposition += ystep;
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ dest[4] = *(ds_transmap + (colormap[val] << 8) + dest[4]);
+ xposition += xstep;
+ yposition += ystep;
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- dest[5] = *(ds_transmap + (colormap[val] << 8) + dest[5]);
- xposition += xstep;
- yposition += ystep;
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ dest[5] = *(ds_transmap + (colormap[val] << 8) + dest[5]);
+ xposition += xstep;
+ yposition += ystep;
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- dest[6] = *(ds_transmap + (colormap[val] << 8) + dest[6]);
- xposition += xstep;
- yposition += ystep;
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ dest[6] = *(ds_transmap + (colormap[val] << 8) + dest[6]);
+ xposition += xstep;
+ yposition += ystep;
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- dest[7] = *(ds_transmap + (colormap[val] << 8) + dest[7]);
- xposition += xstep;
- yposition += ystep;
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ dest[7] = *(ds_transmap + (colormap[val] << 8) + dest[7]);
+ xposition += xstep;
+ yposition += ystep;
- dest += 8;
- count -= 8;
- }
- while (count-- && dest <= deststop)
- {
- val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
- if (val != TRANSPARENTPIXEL)
- *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
- dest++;
- xposition += xstep;
- yposition += ystep;
- }
+ dest += 8;
+ count -= 8;
+ }
+ while (count-- && dest <= deststop)
+ {
+ val = source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+ dest++;
+ xposition += xstep;
+ yposition += ystep;
}
}
/** \brief The R_DrawTranslucentSpan_8 function
- Draws the actual span with translucent.
+ Draws the actual span with translucency.
*/
void R_DrawTranslucentSpan_8 (void)
{
@@ -1601,109 +1308,76 @@ void R_DrawTranslucentSpan_8 (void)
// bit per power of two (obviously)
// Ok, because I was able to eliminate the variable spot below, this function is now FASTER
// than the original span renderer. Whodathunkit?
- if (ds_powersoftwo)
- {
- xposition <<= nflatshiftup; yposition <<= nflatshiftup;
- xstep <<= nflatshiftup; ystep <<= nflatshiftup;
- }
+ xposition <<= nflatshiftup; yposition <<= nflatshiftup;
+ xstep <<= nflatshiftup; ystep <<= nflatshiftup;
source = ds_source;
colormap = ds_colormap;
dest = ylookup[ds_y] + columnofs[ds_x1];
- if (!ds_powersoftwo)
+ while (count >= 8)
{
- while (count-- && dest <= deststop)
- {
- fixed_t x = (xposition >> FRACBITS);
- fixed_t y = (yposition >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- val = ((y * ds_flatwidth) + x);
- *dest = *(ds_transmap + (colormap[source[val]] << 8) + *dest);
- dest++;
- xposition += xstep;
- yposition += ystep;
- }
+ // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
+ // have the uber complicated math to calculate it now, so that was a memory write we didn't
+ // need!
+ dest[0] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[0]);
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[1] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[1]);
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[2] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[2]);
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[3] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[3]);
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[4] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[4]);
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[5] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[5]);
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[6] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[6]);
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[7] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[7]);
+ xposition += xstep;
+ yposition += ystep;
+
+ dest += 8;
+ count -= 8;
}
- else
+ while (count-- && dest <= deststop)
{
- while (count >= 8)
- {
- // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
- // have the uber complicated math to calculate it now, so that was a memory write we didn't
- // need!
- dest[0] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[0]);
- xposition += xstep;
- yposition += ystep;
-
- dest[1] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[1]);
- xposition += xstep;
- yposition += ystep;
-
- dest[2] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[2]);
- xposition += xstep;
- yposition += ystep;
-
- dest[3] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[3]);
- xposition += xstep;
- yposition += ystep;
-
- dest[4] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[4]);
- xposition += xstep;
- yposition += ystep;
-
- dest[5] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[5]);
- xposition += xstep;
- yposition += ystep;
-
- dest[6] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[6]);
- xposition += xstep;
- yposition += ystep;
-
- dest[7] = *(ds_transmap + (colormap[source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)]] << 8) + dest[7]);
- xposition += xstep;
- yposition += ystep;
-
- dest += 8;
- count -= 8;
- }
- while (count-- && dest <= deststop)
- {
- val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
- *dest = *(ds_transmap + (colormap[source[val]] << 8) + *dest);
- dest++;
- xposition += xstep;
- yposition += ystep;
- }
+ val = (((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift);
+ *dest = *(ds_transmap + (colormap[source[val]] << 8) + *dest);
+ dest++;
+ xposition += xstep;
+ yposition += ystep;
}
}
#ifndef NOWATER
void R_DrawTranslucentWaterSpan_8(void)
{
- fixed_t xposition;
- fixed_t yposition;
- fixed_t xstep, ystep;
+ UINT32 xposition;
+ UINT32 yposition;
+ UINT32 xstep, ystep;
UINT8 *source;
UINT8 *colormap;
UINT8 *dest;
UINT8 *dsrc;
- const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
- size_t count = (ds_x2 - ds_x1 + 1);
-
- xposition = ds_xfrac; yposition = (ds_yfrac + ds_waterofs);
- xstep = ds_xstep; ystep = ds_ystep;
+ size_t count;
// SoM: we only need 6 bits for the integer part (0 thru 63) so the rest
// can be used for the fraction part. This allows calculation of the memory address in the
@@ -1712,46 +1386,60 @@ void R_DrawTranslucentWaterSpan_8(void)
// bit per power of two (obviously)
// Ok, because I was able to eliminate the variable spot below, this function is now FASTER
// than the original span renderer. Whodathunkit?
- if (ds_powersoftwo)
- {
- xposition <<= nflatshiftup; yposition <<= nflatshiftup;
- xstep <<= nflatshiftup; ystep <<= nflatshiftup;
- }
+ xposition = ds_xfrac << nflatshiftup; yposition = (ds_yfrac + ds_waterofs) << nflatshiftup;
+ xstep = ds_xstep << nflatshiftup; ystep = ds_ystep << nflatshiftup;
source = ds_source;
colormap = ds_colormap;
dest = ylookup[ds_y] + columnofs[ds_x1];
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
+ count = ds_x2 - ds_x1 + 1;
- if (!ds_powersoftwo)
+ while (count >= 8)
{
- while (count-- && dest <= deststop)
- {
- fixed_t x = (xposition >> FRACBITS);
- fixed_t y = (yposition >> FRACBITS);
-
- // Carefully align all of my Friends.
- if (x < 0)
- x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
- if (y < 0)
- y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
-
- x %= ds_flatwidth;
- y %= ds_flatheight;
-
- *dest++ = colormap[*(ds_transmap + (source[((y * ds_flatwidth) + x)] << 8) + *dsrc++)];
- xposition += xstep;
- yposition += ystep;
- }
+ // SoM: Why didn't I see this earlier? the spot variable is a waste now because we don't
+ // have the uber complicated math to calculate it now, so that was a memory write we didn't
+ // need!
+ dest[0] = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[1] = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[2] = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[3] = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[4] = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[5] = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[6] = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest[7] = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+
+ dest += 8;
+ count -= 8;
}
- else
+ while (count--)
{
- while (count-- && dest <= deststop)
- {
- *dest++ = colormap[*(ds_transmap + (source[(((UINT32)yposition >> nflatyshift) & nflatmask) | ((UINT32)xposition >> nflatxshift)] << 8) + *dsrc++)];
- xposition += xstep;
- yposition += ystep;
- }
+ *dest++ = colormap[*(ds_transmap + (source[((yposition >> nflatyshift) & nflatmask) | (xposition >> nflatxshift)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
}
}
#endif
diff --git a/src/r_draw8_npo2.c b/src/r_draw8_npo2.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ed6acd001b760283b50fdf71e457bab70effc4f
--- /dev/null
+++ b/src/r_draw8_npo2.c
@@ -0,0 +1,845 @@
+// SONIC ROBO BLAST 2
+//-----------------------------------------------------------------------------
+// Copyright (C) 1998-2000 by DooM Legacy Team.
+// Copyright (C) 1999-2019 by Sonic Team Junior.
+//
+// This program is free software distributed under the
+// terms of the GNU General Public License, version 2.
+// See the 'LICENSE' file for more details.
+//-----------------------------------------------------------------------------
+/// \file r_draw8_npo2.c
+/// \brief 8bpp span drawer functions (for non-powers-of-two flat dimensions)
+/// \note no includes because this is included as part of r_draw.c
+
+// ==========================================================================
+// SPANS
+// ==========================================================================
+
+/** \brief The R_DrawSpan_NPO2_8 function
+ Draws the actual span.
+*/
+void R_DrawSpan_NPO2_8 (void)
+{
+ fixed_t xposition;
+ fixed_t yposition;
+ fixed_t xstep, ystep;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+ const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
+
+ size_t count = (ds_x2 - ds_x1 + 1);
+
+ xposition = ds_xfrac; yposition = ds_yfrac;
+ xstep = ds_xstep; ystep = ds_ystep;
+
+ source = ds_source;
+ colormap = ds_colormap;
+ dest = ylookup[ds_y] + columnofs[ds_x1];
+
+ if (dest+8 > deststop)
+ return;
+
+ while (count-- && dest <= deststop)
+ {
+ fixed_t x = (xposition >> FRACBITS);
+ fixed_t y = (yposition >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest++ = colormap[source[((y * ds_flatwidth) + x)]];
+ xposition += xstep;
+ yposition += ystep;
+ }
+}
+
+#ifdef ESLOPE
+/** \brief The R_DrawTiltedSpan_NPO2_8 function
+ Draw slopes! Holy sheit!
+*/
+void R_DrawTiltedSpan_NPO2_8(void)
+{
+ // x1, x2 = ds_x1, ds_x2
+ int width = ds_x2 - ds_x1;
+ double iz, uz, vz;
+ UINT32 u, v;
+ int i;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+
+ double startz, startu, startv;
+ double izstep, uzstep, vzstep;
+ double endz, endu, endv;
+ UINT32 stepu, stepv;
+
+ iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
+
+ // Lighting is simple. It's just linear interpolation from start to end
+ {
+ float planelightfloat = BASEVIDWIDTH*BASEVIDWIDTH/vid.width / (zeroheight - FIXED_TO_FLOAT(viewz)) / 21.0f;
+ float lightstart, lightend;
+
+ lightend = (iz + ds_sz.x*width) * planelightfloat;
+ lightstart = iz * planelightfloat;
+
+ R_CalcTiltedLighting(FLOAT_TO_FIXED(lightstart), FLOAT_TO_FIXED(lightend));
+ //CONS_Printf("tilted lighting %f to %f (foc %f)\n", lightstart, lightend, focallengthf);
+ }
+
+ uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
+ vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
+
+ dest = ylookup[ds_y] + columnofs[ds_x1];
+ source = ds_source;
+ //colormap = ds_colormap;
+
+#if 0 // The "perfect" reference version of this routine. Pretty slow.
+ // Use it only to see how things are supposed to look.
+ i = 0;
+ do
+ {
+ double z = 1.f/iz;
+ u = (INT64)(uz*z) + viewx;
+ v = (INT64)(vz*z) + viewy;
+
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest = colormap[source[((y * ds_flatwidth) + x)]];
+ }
+ dest++;
+ iz += ds_sz.x;
+ uz += ds_su.x;
+ vz += ds_sv.x;
+ } while (--width >= 0);
+#else
+#define SPANSIZE 16
+#define INVSPAN 0.0625f
+
+ startz = 1.f/iz;
+ startu = uz*startz;
+ startv = vz*startz;
+
+ izstep = ds_sz.x * SPANSIZE;
+ uzstep = ds_su.x * SPANSIZE;
+ vzstep = ds_sv.x * SPANSIZE;
+ //x1 = 0;
+ width++;
+
+ while (width >= SPANSIZE)
+ {
+ iz += izstep;
+ uz += uzstep;
+ vz += vzstep;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ stepu = (INT64)((endu - startu) * INVSPAN);
+ stepv = (INT64)((endv - startv) * INVSPAN);
+ u = (INT64)(startu) + viewx;
+ v = (INT64)(startv) + viewy;
+
+ for (i = SPANSIZE-1; i >= 0; i--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest = colormap[source[((y * ds_flatwidth) + x)]];
+ }
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ startu = endu;
+ startv = endv;
+ width -= SPANSIZE;
+ }
+ if (width > 0)
+ {
+ if (width == 1)
+ {
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest = colormap[source[((y * ds_flatwidth) + x)]];
+ }
+ }
+ else
+ {
+ double left = width;
+ iz += ds_sz.x * left;
+ uz += ds_su.x * left;
+ vz += ds_sv.x * left;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ left = 1.f/left;
+ stepu = (INT64)((endu - startu) * left);
+ stepv = (INT64)((endv - startv) * left);
+ u = (INT64)(startu) + viewx;
+ v = (INT64)(startv) + viewy;
+
+ for (; width != 0; width--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest = colormap[source[((y * ds_flatwidth) + x)]];
+ }
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ }
+ }
+#endif
+}
+
+/** \brief The R_DrawTiltedTranslucentSpan_NPO2_8 function
+ Like DrawTiltedSpan_NPO2, but translucent
+*/
+void R_DrawTiltedTranslucentSpan_NPO2_8(void)
+{
+ // x1, x2 = ds_x1, ds_x2
+ int width = ds_x2 - ds_x1;
+ double iz, uz, vz;
+ UINT32 u, v;
+ int i;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+
+ double startz, startu, startv;
+ double izstep, uzstep, vzstep;
+ double endz, endu, endv;
+ UINT32 stepu, stepv;
+
+ iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
+
+ // Lighting is simple. It's just linear interpolation from start to end
+ {
+ float planelightfloat = BASEVIDWIDTH*BASEVIDWIDTH/vid.width / (zeroheight - FIXED_TO_FLOAT(viewz)) / 21.0f;
+ float lightstart, lightend;
+
+ lightend = (iz + ds_sz.x*width) * planelightfloat;
+ lightstart = iz * planelightfloat;
+
+ R_CalcTiltedLighting(FLOAT_TO_FIXED(lightstart), FLOAT_TO_FIXED(lightend));
+ //CONS_Printf("tilted lighting %f to %f (foc %f)\n", lightstart, lightend, focallengthf);
+ }
+
+ uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
+ vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
+
+ dest = ylookup[ds_y] + columnofs[ds_x1];
+ source = ds_source;
+ //colormap = ds_colormap;
+
+#if 0 // The "perfect" reference version of this routine. Pretty slow.
+ // Use it only to see how things are supposed to look.
+ i = 0;
+ do
+ {
+ double z = 1.f/iz;
+ u = (INT64)(uz*z) + viewx;
+ v = (INT64)(vz*z) + viewy;
+
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
+ }
+ dest++;
+ iz += ds_sz.x;
+ uz += ds_su.x;
+ vz += ds_sv.x;
+ } while (--width >= 0);
+#else
+#define SPANSIZE 16
+#define INVSPAN 0.0625f
+
+ startz = 1.f/iz;
+ startu = uz*startz;
+ startv = vz*startz;
+
+ izstep = ds_sz.x * SPANSIZE;
+ uzstep = ds_su.x * SPANSIZE;
+ vzstep = ds_sv.x * SPANSIZE;
+ //x1 = 0;
+ width++;
+
+ while (width >= SPANSIZE)
+ {
+ iz += izstep;
+ uz += uzstep;
+ vz += vzstep;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ stepu = (INT64)((endu - startu) * INVSPAN);
+ stepv = (INT64)((endv - startv) * INVSPAN);
+ u = (INT64)(startu) + viewx;
+ v = (INT64)(startv) + viewy;
+
+ for (i = SPANSIZE-1; i >= 0; i--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
+ }
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ startu = endu;
+ startv = endv;
+ width -= SPANSIZE;
+ }
+ if (width > 0)
+ {
+ if (width == 1)
+ {
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
+ }
+ }
+ else
+ {
+ double left = width;
+ iz += ds_sz.x * left;
+ uz += ds_su.x * left;
+ vz += ds_sv.x * left;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ left = 1.f/left;
+ stepu = (INT64)((endu - startu) * left);
+ stepv = (INT64)((endv - startv) * left);
+ u = (INT64)(startu) + viewx;
+ v = (INT64)(startv) + viewy;
+
+ for (; width != 0; width--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
+ }
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ }
+ }
+#endif
+}
+
+void R_DrawTiltedSplat_NPO2_8(void)
+{
+ // x1, x2 = ds_x1, ds_x2
+ int width = ds_x2 - ds_x1;
+ double iz, uz, vz;
+ UINT32 u, v;
+ int i;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+
+ UINT8 val;
+
+ double startz, startu, startv;
+ double izstep, uzstep, vzstep;
+ double endz, endu, endv;
+ UINT32 stepu, stepv;
+
+ iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
+
+ // Lighting is simple. It's just linear interpolation from start to end
+ {
+ float planelightfloat = BASEVIDWIDTH*BASEVIDWIDTH/vid.width / (zeroheight - FIXED_TO_FLOAT(viewz)) / 21.0f;
+ float lightstart, lightend;
+
+ lightend = (iz + ds_sz.x*width) * planelightfloat;
+ lightstart = iz * planelightfloat;
+
+ R_CalcTiltedLighting(FLOAT_TO_FIXED(lightstart), FLOAT_TO_FIXED(lightend));
+ //CONS_Printf("tilted lighting %f to %f (foc %f)\n", lightstart, lightend, focallengthf);
+ }
+
+ uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
+ vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
+
+ dest = ylookup[ds_y] + columnofs[ds_x1];
+ source = ds_source;
+ //colormap = ds_colormap;
+
+#if 0 // The "perfect" reference version of this routine. Pretty slow.
+ // Use it only to see how things are supposed to look.
+ i = 0;
+ do
+ {
+ double z = 1.f/iz;
+ u = (INT64)(uz*z) + viewx;
+ v = (INT64)(vz*z) + viewy;
+
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ }
+
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+
+ dest++;
+ iz += ds_sz.x;
+ uz += ds_su.x;
+ vz += ds_sv.x;
+ } while (--width >= 0);
+#else
+#define SPANSIZE 16
+#define INVSPAN 0.0625f
+
+ startz = 1.f/iz;
+ startu = uz*startz;
+ startv = vz*startz;
+
+ izstep = ds_sz.x * SPANSIZE;
+ uzstep = ds_su.x * SPANSIZE;
+ vzstep = ds_sv.x * SPANSIZE;
+ //x1 = 0;
+ width++;
+
+ while (width >= SPANSIZE)
+ {
+ iz += izstep;
+ uz += uzstep;
+ vz += vzstep;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ stepu = (INT64)((endu - startu) * INVSPAN);
+ stepv = (INT64)((endv - startv) * INVSPAN);
+ u = (INT64)(startu) + viewx;
+ v = (INT64)(startv) + viewy;
+
+ for (i = SPANSIZE-1; i >= 0; i--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ }
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ startu = endu;
+ startv = endv;
+ width -= SPANSIZE;
+ }
+ if (width > 0)
+ {
+ if (width == 1)
+ {
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ }
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+ }
+ else
+ {
+ double left = width;
+ iz += ds_sz.x * left;
+ uz += ds_su.x * left;
+ vz += ds_sv.x * left;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ left = 1.f/left;
+ stepu = (INT64)((endu - startu) * left);
+ stepv = (INT64)((endv - startv) * left);
+ u = (INT64)(startu) + viewx;
+ v = (INT64)(startv) + viewy;
+
+ for (; width != 0; width--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u-viewx) >> FRACBITS);
+ fixed_t y = (((fixed_t)v-viewy) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ }
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ }
+ }
+#endif
+}
+#endif // ESLOPE
+
+/** \brief The R_DrawSplat_NPO2_8 function
+ Just like R_DrawSpan_NPO2_8, but skips transparent pixels.
+*/
+void R_DrawSplat_NPO2_8 (void)
+{
+ fixed_t xposition;
+ fixed_t yposition;
+ fixed_t xstep, ystep;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+ const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
+
+ size_t count = (ds_x2 - ds_x1 + 1);
+ UINT32 val;
+
+ xposition = ds_xfrac; yposition = ds_yfrac;
+ xstep = ds_xstep; ystep = ds_ystep;
+
+ source = ds_source;
+ colormap = ds_colormap;
+ dest = ylookup[ds_y] + columnofs[ds_x1];
+
+ while (count-- && dest <= deststop)
+ {
+ fixed_t x = (xposition >> FRACBITS);
+ fixed_t y = (yposition >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+ dest++;
+ xposition += xstep;
+ yposition += ystep;
+ }
+}
+
+/** \brief The R_DrawTranslucentSplat_NPO2_8 function
+ Just like R_DrawSplat_NPO2_8, but is translucent!
+*/
+void R_DrawTranslucentSplat_NPO2_8 (void)
+{
+ fixed_t xposition;
+ fixed_t yposition;
+ fixed_t xstep, ystep;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+ const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
+
+ size_t count = (ds_x2 - ds_x1 + 1);
+ UINT32 val;
+
+ xposition = ds_xfrac; yposition = ds_yfrac;
+ xstep = ds_xstep; ystep = ds_ystep;
+
+ source = ds_source;
+ colormap = ds_colormap;
+ dest = ylookup[ds_y] + columnofs[ds_x1];
+
+ while (count-- && dest <= deststop)
+ {
+ fixed_t x = (xposition >> FRACBITS);
+ fixed_t y = (yposition >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+ dest++;
+ xposition += xstep;
+ yposition += ystep;
+ }
+}
+
+/** \brief The R_DrawTranslucentSpan_NPO2_8 function
+ Draws the actual span with translucency.
+*/
+void R_DrawTranslucentSpan_NPO2_8 (void)
+{
+ fixed_t xposition;
+ fixed_t yposition;
+ fixed_t xstep, ystep;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+ const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
+
+ size_t count = (ds_x2 - ds_x1 + 1);
+ UINT32 val;
+
+ xposition = ds_xfrac; yposition = ds_yfrac;
+ xstep = ds_xstep; ystep = ds_ystep;
+
+ source = ds_source;
+ colormap = ds_colormap;
+ dest = ylookup[ds_y] + columnofs[ds_x1];
+
+ while (count-- && dest <= deststop)
+ {
+ fixed_t x = (xposition >> FRACBITS);
+ fixed_t y = (yposition >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ val = ((y * ds_flatwidth) + x);
+ *dest = *(ds_transmap + (colormap[source[val]] << 8) + *dest);
+ dest++;
+ xposition += xstep;
+ yposition += ystep;
+ }
+}
+
+#ifndef NOWATER
+void R_DrawTranslucentWaterSpan_NPO2_8(void)
+{
+ fixed_t xposition;
+ fixed_t yposition;
+ fixed_t xstep, ystep;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+ UINT8 *dsrc;
+ const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
+
+ size_t count = (ds_x2 - ds_x1 + 1);
+
+ xposition = ds_xfrac; yposition = (ds_yfrac + ds_waterofs);
+ xstep = ds_xstep; ystep = ds_ystep;
+
+ source = ds_source;
+ colormap = ds_colormap;
+ dest = ylookup[ds_y] + columnofs[ds_x1];
+ dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
+
+ while (count-- && dest <= deststop)
+ {
+ fixed_t x = (xposition >> FRACBITS);
+ fixed_t y = (yposition >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x = ds_flatwidth - ((UINT32)(ds_flatwidth - x) % ds_flatwidth);
+ if (y < 0)
+ y = ds_flatheight - ((UINT32)(ds_flatheight - y) % ds_flatheight);
+
+ x %= ds_flatwidth;
+ y %= ds_flatheight;
+
+ *dest++ = colormap[*(ds_transmap + (source[((y * ds_flatwidth) + x)] << 8) + *dsrc++)];
+ xposition += xstep;
+ yposition += ystep;
+ }
+}
+#endif
diff --git a/src/r_plane.c b/src/r_plane.c
index 8c644700ea43d49c94821d4f1ad9b5cb58ababfd..3745c28bec7e89b2d7042b2a1dca403d12f1a261 100644
--- a/src/r_plane.c
+++ b/src/r_plane.c
@@ -841,6 +841,7 @@ void R_DrawSinglePlane(visplane_t *pl)
ffloor_t *rover;
levelflat_t *levelflat;
int type;
+ int spanfunctype = BASEDRAWFUNC;
if (!(pl->minx <= pl->maxx))
return;
@@ -858,8 +859,9 @@ void R_DrawSinglePlane(visplane_t *pl)
spanfunc = spanfuncs[BASEDRAWFUNC];
#ifdef POLYOBJECTS_PLANES
- if (pl->polyobj && pl->polyobj->translucency != 0) {
- spanfunc = spanfuncs[SPANDRAWFUNC_TRANS];
+ if (pl->polyobj && pl->polyobj->translucency != 0)
+ {
+ spanfunctype = SPANDRAWFUNC_TRANS;
// Hacked up support for alpha value in software mode Tails 09-24-2002 (sidenote: ported to polys 10-15-2014, there was no time travel involved -Red)
if (pl->polyobj->translucency >= 10)
@@ -867,10 +869,10 @@ void R_DrawSinglePlane(visplane_t *pl)
else if (pl->polyobj->translucency > 0)
ds_transmap = transtables + ((pl->polyobj->translucency-1)<<FF_TRANSSHIFT);
else // Opaque, but allow transparent flat pixels
- spanfunc = spanfuncs[SPANDRAWFUNC_SPLAT];
+ spanfunctype = SPANDRAWFUNC_SPLAT;
#ifdef SHITPLANESPARENCY
- if ((spanfunc == spanfuncs[SPANDRAWFUNC_SPLAT]) != (pl->extra_colormap && (pl->extra_colormap->fog & 4)))
+ if ((spanfunctype == SPANDRAWFUNC_SPLAT) != (pl->extra_colormap && (pl->extra_colormap->fog & 4)))
#else
if (!pl->extra_colormap || !(pl->extra_colormap->fog & 2))
#endif
@@ -901,7 +903,7 @@ void R_DrawSinglePlane(visplane_t *pl)
if (pl->ffloor->flags & FF_TRANSLUCENT)
{
- spanfunc = spanfuncs[SPANDRAWFUNC_TRANS];
+ spanfunctype = SPANDRAWFUNC_TRANS;
// Hacked up support for alpha value in software mode Tails 09-24-2002
if (pl->ffloor->alpha < 12)
@@ -925,10 +927,10 @@ void R_DrawSinglePlane(visplane_t *pl)
else if (pl->ffloor->alpha < 243)
ds_transmap = transtables + ((tr_trans10-1)<<FF_TRANSSHIFT);
else // Opaque, but allow transparent flat pixels
- spanfunc = spanfuncs[SPANDRAWFUNC_SPLAT];
+ spanfunctype = SPANDRAWFUNC_SPLAT;
#ifdef SHITPLANESPARENCY
- if ((spanfunc == spanfuncs[SPANDRAWFUNC_SPLAT]) != (pl->extra_colormap && (pl->extra_colormap->fog & 4)))
+ if ((spanfunctype == SPANDRAWFUNC_SPLAT) != (pl->extra_colormap && (pl->extra_colormap->fog & 4)))
#else
if (!pl->extra_colormap || !(pl->extra_colormap->fog & 2))
#endif
@@ -938,7 +940,7 @@ void R_DrawSinglePlane(visplane_t *pl)
}
else if (pl->ffloor->flags & FF_FOG)
{
- spanfunc = spanfuncs[SPANDRAWFUNC_FOG];
+ spanfunctype = SPANDRAWFUNC_FOG;
light = (pl->lightlevel >> LIGHTSEGSHIFT);
}
else light = (pl->lightlevel >> LIGHTSEGSHIFT);
@@ -953,9 +955,9 @@ void R_DrawSinglePlane(visplane_t *pl)
INT32 top, bottom;
itswater = true;
- if (spanfunc == spanfuncs[SPANDRAWFUNC_TRANS])
+ if (spanfunctype == SPANDRAWFUNC_TRANS)
{
- spanfunc = spanfuncs[SPANDRAWFUNC_WATER];
+ spanfunctype = SPANDRAWFUNC_WATER;
// Copy the current scene, ugh
top = pl->high-8;
@@ -1032,8 +1034,8 @@ void R_DrawSinglePlane(visplane_t *pl)
if (R_CheckPowersOfTwo())
{
R_CheckFlatLength(ds_flatwidth * ds_flatheight);
- if (spanfunc == spanfuncs[BASEDRAWFUNC])
- spanfunc = spanfuncs[SPANDRAWFUNC_MMX];
+ if (spanfunctype == BASEDRAWFUNC)
+ spanfunctype = SPANDRAWFUNC_MMX;
}
}
@@ -1187,12 +1189,12 @@ void R_DrawSinglePlane(visplane_t *pl)
}
#undef SFMULT
- if (spanfunc == spanfuncs[SPANDRAWFUNC_TRANS])
- spanfunc = spanfuncs[SPANDRAWFUNC_TILTEDTRANS];
- else if (spanfunc == spanfuncs[SPANDRAWFUNC_SPLAT])
- spanfunc = spanfuncs[SPANDRAWFUNC_TILTEDSPLAT];
+ if (spanfunctype == SPANDRAWFUNC_TRANS)
+ spanfunctype = SPANDRAWFUNC_TILTEDTRANS;
+ else if (spanfunctype == SPANDRAWFUNC_SPLAT)
+ spanfunctype = SPANDRAWFUNC_TILTEDSPLAT;
else
- spanfunc = spanfuncs[SPANDRAWFUNC_TILTED];
+ spanfunctype = SPANDRAWFUNC_TILTED;
planezlight = scalelight[light];
} else
@@ -1200,6 +1202,17 @@ void R_DrawSinglePlane(visplane_t *pl)
planezlight = zlight[light];
+ // Use the correct span drawer depending on the powers-of-twoness
+ if (!ds_powersoftwo)
+ {
+ if (spanfuncs_npo2[spanfunctype])
+ spanfunc = spanfuncs_npo2[spanfunctype];
+ else
+ spanfunc = spanfuncs[spanfunctype];
+ }
+ else
+ spanfunc = spanfuncs[spanfunctype];
+
// set the maximum value for unsigned
pl->top[pl->maxx+1] = 0xffff;
pl->top[pl->minx-1] = 0xffff;
diff --git a/src/screen.c b/src/screen.c
index 5c88d8471850df52c75b5a2cdcfe3dff54a81d5d..83421a1cc6a291e0f461394766b98f732b99d9dd 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -46,6 +46,7 @@ void (*colfuncs[COLDRAWFUNC_MAX])(void);
void (*spanfunc)(void);
void (*spanfuncs[SPANDRAWFUNC_MAX])(void);
+void (*spanfuncs_npo2[SPANDRAWFUNC_MAX])(void);
// ------------------
// global video state
@@ -133,6 +134,21 @@ void SCR_SetMode(void)
spanfuncs[SPANDRAWFUNC_TILTEDSPLAT] = R_DrawTiltedSplat_8;
#endif
+ // Lactozilla: Non-powers-of-two
+ spanfuncs_npo2[BASEDRAWFUNC] = R_DrawSpan_NPO2_8;
+ spanfuncs_npo2[SPANDRAWFUNC_TRANS] = R_DrawTranslucentSpan_NPO2_8;
+ spanfuncs_npo2[SPANDRAWFUNC_SPLAT] = R_DrawSplat_NPO2_8;
+ spanfuncs_npo2[SPANDRAWFUNC_TRANSSPLAT] = R_DrawTranslucentSplat_NPO2_8;
+ spanfuncs_npo2[SPANDRAWFUNC_FOG] = NULL; // Not needed
+ spanfuncs_npo2[SPANDRAWFUNC_MMX] = NULL; // Same
+#ifndef NOWATER
+ spanfuncs_npo2[SPANDRAWFUNC_WATER] = R_DrawTranslucentWaterSpan_NPO2_8;
+#endif
+#ifdef ESLOPE
+ spanfuncs_npo2[SPANDRAWFUNC_TILTED] = R_DrawTiltedSpan_NPO2_8;
+ spanfuncs_npo2[SPANDRAWFUNC_TILTEDTRANS] = R_DrawTiltedTranslucentSpan_NPO2_8;
+ spanfuncs_npo2[SPANDRAWFUNC_TILTEDSPLAT] = R_DrawTiltedSplat_NPO2_8;
+#endif
#ifdef RUSEASM
if (R_ASM)
diff --git a/src/screen.h b/src/screen.h
index ffed931faea7e4a78779aa7d0ffc1d3f64b1a051..9a4d48dcfb4e07ec6f8301dfedfd996da86312e6 100644
--- a/src/screen.h
+++ b/src/screen.h
@@ -152,6 +152,7 @@ enum
extern void (*spanfunc)(void);
extern void (*spanfuncs[SPANDRAWFUNC_MAX])(void);
+extern void (*spanfuncs_npo2[SPANDRAWFUNC_MAX])(void);
// -----
// CPUID
diff --git a/src/sdl/Srb2SDL-vc10.vcxproj b/src/sdl/Srb2SDL-vc10.vcxproj
index 0d1fa1a4b5df7947be1559b1663175c592a087d3..b334f6313614b5890c9b971b07068e7c404b6cec 100644
--- a/src/sdl/Srb2SDL-vc10.vcxproj
+++ b/src/sdl/Srb2SDL-vc10.vcxproj
@@ -438,6 +438,9 @@
<ClCompile Include="..\r_draw8.c">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClCompile>
+ <ClCompile Include="..\r_draw8_npo2.c">
+ <ExcludedFromBuild>true</ExcludedFromBuild>
+ </ClCompile>
<ClCompile Include="..\r_main.c" />
<ClCompile Include="..\r_plane.c" />
<ClCompile Include="..\r_patch.c" />
diff --git a/src/sdl/Srb2SDL-vc10.vcxproj.filters b/src/sdl/Srb2SDL-vc10.vcxproj.filters
index cface637773be2167340011d7eec451d1f251042..3f61e87098fd08e732f7c521435d93fb63ca77f9 100644
--- a/src/sdl/Srb2SDL-vc10.vcxproj.filters
+++ b/src/sdl/Srb2SDL-vc10.vcxproj.filters
@@ -837,6 +837,9 @@
<ClCompile Include="..\r_draw8.c">
<Filter>R_Rend</Filter>
</ClCompile>
+ <ClCompile Include="..\r_draw8_npo2.c">
+ <Filter>R_Rend</Filter>
+ </ClCompile>
<ClCompile Include="..\r_main.c">
<Filter>R_Rend</Filter>
</ClCompile>
diff --git a/src/win32/Srb2win-vc10.vcxproj b/src/win32/Srb2win-vc10.vcxproj
index 7a79861b3899f9fffcdd4da9248556c54e9e7bba..387d65da9074249929ac24044d38942d2cd26f04 100644
--- a/src/win32/Srb2win-vc10.vcxproj
+++ b/src/win32/Srb2win-vc10.vcxproj
@@ -295,6 +295,9 @@
<ClCompile Include="..\r_draw8.c">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClCompile>
+ <ClCompile Include="..\r_draw8_npo2.c">
+ <ExcludedFromBuild>true</ExcludedFromBuild>
+ </ClCompile>
<ClCompile Include="..\r_main.c" />
<ClCompile Include="..\r_plane.c" />
<ClCompile Include="..\r_patch.c" />
diff --git a/src/win32/Srb2win-vc10.vcxproj.filters b/src/win32/Srb2win-vc10.vcxproj.filters
index 3d5c021d4b915f1950b831d2f67ec2a6a3ac78ba..2f380c47343f8a15be0f02393970086af4b74b40 100644
--- a/src/win32/Srb2win-vc10.vcxproj.filters
+++ b/src/win32/Srb2win-vc10.vcxproj.filters
@@ -369,6 +369,9 @@
<ClCompile Include="..\r_draw16.c">
<Filter>R_Rend</Filter>
</ClCompile>
+ <ClCompile Include="..\r_draw8_npo2.c">
+ <Filter>R_Rend</Filter>
+ </ClCompile>
<ClCompile Include="..\r_main.c">
<Filter>R_Rend</Filter>
</ClCompile>