Merge 19e8774ad0 into 4528441c74

fix crash under freak circumstances
make it more clear what's actually being done
2024-11-14 05:17:40 -07:00 · 2024-11-10 01:35:06 +01:00 · 2024-05-10 05:54:46 -04:00 · 2024-04-06 17:55:03 -04:00 · 2024-03-30 13:23:41 -04:00 · 2024-03-30 08:28:04 -04:00
2 changed files with 43 additions and 55 deletions
--- a/src/GPU3D_Soft.cpp
+++ b/src/GPU3D_Soft.cpp
@ -622,7 +622,7 @@ void SoftRenderer::SetupPolygonLeftEdge(SoftRenderer::RendererPolygon* rp, s32 y

    rp->XL = rp->SlopeL.Setup(polygon->Vertices[rp->CurVL]->FinalPosition[0], polygon->Vertices[rp->NextVL]->FinalPosition[0],
                              polygon->Vertices[rp->CurVL]->FinalPosition[1], polygon->Vertices[rp->NextVL]->FinalPosition[1],
-                              polygon->FinalW[rp->CurVL], polygon->FinalW[rp->NextVL], y);
+                              polygon->FinalW[rp->CurVL], polygon->FinalW[rp->NextVL], y, polygon->WBuffer);
 }

 void SoftRenderer::SetupPolygonRightEdge(SoftRenderer::RendererPolygon* rp, s32 y) const
@ -649,7 +649,7 @@ void SoftRenderer::SetupPolygonRightEdge(SoftRenderer::RendererPolygon* rp, s32

    rp->XR = rp->SlopeR.Setup(polygon->Vertices[rp->CurVR]->FinalPosition[0], polygon->Vertices[rp->NextVR]->FinalPosition[0],
                              polygon->Vertices[rp->CurVR]->FinalPosition[1], polygon->Vertices[rp->NextVR]->FinalPosition[1],
-                              polygon->FinalW[rp->CurVR], polygon->FinalW[rp->NextVR], y);
+                              polygon->FinalW[rp->CurVR], polygon->FinalW[rp->NextVR], y, polygon->WBuffer);
 }

 void SoftRenderer::SetupPolygon(SoftRenderer::RendererPolygon* rp, Polygon* polygon) const
@ -755,8 +755,8 @@ void SoftRenderer::RenderShadowMaskScanline(const GPU3D& gpu3d, RendererPolygon*
    s32 wl = rp->SlopeL.Interp.Interpolate(polygon->FinalW[rp->CurVL], polygon->FinalW[rp->NextVL]);
    s32 wr = rp->SlopeR.Interp.Interpolate(polygon->FinalW[rp->CurVR], polygon->FinalW[rp->NextVR]);

-    s32 zl = rp->SlopeL.Interp.InterpolateZ(polygon->FinalZ[rp->CurVL], polygon->FinalZ[rp->NextVL], polygon->WBuffer);
-    s32 zr = rp->SlopeR.Interp.InterpolateZ(polygon->FinalZ[rp->CurVR], polygon->FinalZ[rp->NextVR], polygon->WBuffer);
+    s32 zl = rp->SlopeL.Interp.InterpolateZ(polygon->FinalZ[rp->CurVL], polygon->FinalZ[rp->NextVL]);
+    s32 zr = rp->SlopeR.Interp.InterpolateZ(polygon->FinalZ[rp->CurVR], polygon->FinalZ[rp->NextVR]);

    // right vertical edges are pushed 1px to the left as long as either:
    // the left edge slope is not 0, or the span is not 0 pixels wide, and it is not at the leftmost pixel of the screen
@ -841,7 +841,7 @@ void SoftRenderer::RenderShadowMaskScanline(const GPU3D& gpu3d, RendererPolygon*
    int edge;

    s32 x = xstart;
-    Interpolator<0> interpX(xstart, xend+1, wl, wr);
+    Interpolator<0> interpX(xstart, xend+1, wl, wr, polygon->WBuffer, zl, zr);

    if (x < 0) x = 0;
    s32 xlimit;
@ -863,7 +863,7 @@ void SoftRenderer::RenderShadowMaskScanline(const GPU3D& gpu3d, RendererPolygon*

        interpX.SetX(x);

-        s32 z = interpX.InterpolateZ(zl, zr, polygon->WBuffer);
+        s32 z = interpX.InterpolateZ(zl, zr);
        u32 dstattr = AttrBuffer[pixeladdr];

        if (!fnDepthTest(DepthBuffer[pixeladdr], z, dstattr))
@ -889,7 +889,7 @@ void SoftRenderer::RenderShadowMaskScanline(const GPU3D& gpu3d, RendererPolygon*

        interpX.SetX(x);

-        s32 z = interpX.InterpolateZ(zl, zr, polygon->WBuffer);
+        s32 z = interpX.InterpolateZ(zl, zr);
        u32 dstattr = AttrBuffer[pixeladdr];

        if (!fnDepthTest(DepthBuffer[pixeladdr], z, dstattr))
@ -915,7 +915,7 @@ void SoftRenderer::RenderShadowMaskScanline(const GPU3D& gpu3d, RendererPolygon*

        interpX.SetX(x);

-        s32 z = interpX.InterpolateZ(zl, zr, polygon->WBuffer);
+        s32 z = interpX.InterpolateZ(zl, zr);
        u32 dstattr = AttrBuffer[pixeladdr];

        if (!fnDepthTest(DepthBuffer[pixeladdr], z, dstattr))
@ -980,8 +980,8 @@ void SoftRenderer::RenderPolygonScanline(const GPU& gpu, RendererPolygon* rp, s3
    s32 wl = rp->SlopeL.Interp.Interpolate(polygon->FinalW[rp->CurVL], polygon->FinalW[rp->NextVL]);
    s32 wr = rp->SlopeR.Interp.Interpolate(polygon->FinalW[rp->CurVR], polygon->FinalW[rp->NextVR]);

-    s32 zl = rp->SlopeL.Interp.InterpolateZ(polygon->FinalZ[rp->CurVL], polygon->FinalZ[rp->NextVL], polygon->WBuffer);
-    s32 zr = rp->SlopeR.Interp.InterpolateZ(polygon->FinalZ[rp->CurVR], polygon->FinalZ[rp->NextVR], polygon->WBuffer);
+    s32 zl = rp->SlopeL.Interp.InterpolateZ(polygon->FinalZ[rp->CurVL], polygon->FinalZ[rp->NextVL]);
+    s32 zr = rp->SlopeR.Interp.InterpolateZ(polygon->FinalZ[rp->CurVR], polygon->FinalZ[rp->NextVR]);

    // right vertical edges are pushed 1px to the left as long as either:
    // the left edge slope is not 0, or the span is not 0 pixels wide, and it is not at the leftmost pixel of the screen
@ -1091,7 +1091,7 @@ void SoftRenderer::RenderPolygonScanline(const GPU& gpu, RendererPolygon* rp, s3
    int edge;

    s32 x = xstart;
-    Interpolator<0> interpX(xstart, xend+1, wl, wr);
+    Interpolator<0> interpX(xstart, xend+1, wl, wr, polygon->WBuffer, zl, zr);

    if (x < 0) x = 0;
    s32 xlimit;
@ -1130,7 +1130,7 @@ void SoftRenderer::RenderPolygonScanline(const GPU& gpu, RendererPolygon* rp, s3

        interpX.SetX(x);

-        s32 z = interpX.InterpolateZ(zl, zr, polygon->WBuffer);
+        s32 z = interpX.InterpolateZ(zl, zr);

        // if depth test against the topmost pixel fails, test
        // against the pixel underneath
@ -1226,7 +1226,7 @@ void SoftRenderer::RenderPolygonScanline(const GPU& gpu, RendererPolygon* rp, s3

        interpX.SetX(x);

-        s32 z = interpX.InterpolateZ(zl, zr, polygon->WBuffer);
+        s32 z = interpX.InterpolateZ(zl, zr);

        // if depth test against the topmost pixel fails, test
        // against the pixel underneath
@ -1318,7 +1318,7 @@ void SoftRenderer::RenderPolygonScanline(const GPU& gpu, RendererPolygon* rp, s3

        interpX.SetX(x);

-        s32 z = interpX.InterpolateZ(zl, zr, polygon->WBuffer);
+        s32 z = interpX.InterpolateZ(zl, zr);

        // if depth test against the topmost pixel fails, test
        // against the pixel underneath
--- a/src/GPU3D_Soft.h
+++ b/src/GPU3D_Soft.h
@ -69,23 +69,24 @@ private:
    {
    public:
        constexpr Interpolator() {}
-        constexpr Interpolator(s32 x0, s32 x1, s32 w0, s32 w1)
+        constexpr Interpolator(s32 x0, s32 x1, s32 w0, s32 w1, bool wbuffer, s32 z0, s32 z1)
        {
-            Setup(x0, x1, w0, w1);
+            Setup(x0, x1, w0, w1, wbuffer, z0, z1);
        }

-        constexpr void Setup(s32 x0, s32 x1, s32 w0, s32 w1)
+        constexpr void Setup(s32 x0, s32 x1, s32 w0, s32 w1, bool wbuffer, s32 z0 = 0, s32 z1 = 0)
        {
            this->x0 = x0;
            this->x1 = x1;
            this->xdiff = x1 - x0;
+            this->wbuffer = wbuffer;

-            // calculate reciprocal for Z interpolation
-            // TODO eventually: use a faster reciprocal function?
-            if (this->xdiff != 0)
-                this->xrecip_z = (1<<22) / this->xdiff;
-            else
-                this->xrecip_z = 0;
+            // calculate increment and init counter for Z interpolation
+            if (!dir && !wbuffer && xdiff != 0)
+            {
+                this->zincr = ((z1 - z0) >> 1) / xdiff << 1;
+                this->zcounter = z0;
+            }

            // linear mode is used if both W values are equal and have
            // low-order bits cleared (0-6 along X, 1-6 along Y)
@ -144,7 +145,7 @@ private:

        constexpr s32 Interpolate(s32 y0, s32 y1) const
        {
-            if (xdiff == 0 || y0 == y1) return y0;
+            if (x == 0 || xdiff == 0 ||  y0 == y1) return y0;

            if (!linear)
            {
@ -164,9 +165,9 @@ private:
            }
        }

-        constexpr s32 InterpolateZ(s32 z0, s32 z1, bool wbuffer) const
+        constexpr s32 InterpolateZ(s32 z0, s32 z1)
        {
-            if (xdiff == 0 || z0 == z1) return z0;
+            if (x == 0 || xdiff == 0 || z0 == z1) return z0;

            if (wbuffer)
            {
@ -179,37 +180,22 @@ private:
            else
            {
                // Z-buffering: linear interpolation
-                // still doesn't quite match hardware...
-                s32 base = 0, disp = 0, factor = 0;
-
-                if (z0 < z1)
-                {
-                    base = z0;
-                    disp = z1 - z0;
-                    factor = x;
-                }
-                else
-                {
-                    base = z1;
-                    disp = z0 - z1,
-                    factor = xdiff - x;
-                }
+                // not perfect, but close

                if (dir)
                {
-                    int shift = 0;
-                    while (disp > 0x3FF)
-                    {
-                        disp >>= 1;
-                        shift++;
-                    }
-
-                    return base + ((((s64)disp * factor * xrecip_z) >> 22) << shift);
+                    // interpolating along y uses a different algorithm than x
+                    // this algo probably isn't quite right though...
+                    if (z0 < z1)
+                        return z0 + (s64)(z1-z0) * x / xdiff;
+                    else
+                        return z1 + (s64)(z0-z1) * (xdiff-x) / xdiff;
                }
                else
                {
-                    disp >>= 9;
-                    return base + (((s64)disp * factor * xrecip_z) >> 13);
+                    // unoptimized algorithm is: z0 + ((z1-z0 >> 1) / xdiff * x << 1);
+                    // or alternatively there's: z0 + (z1-z0) / (xdiff<<1) * (x<<1);
+                    return zcounter += zincr;
                }
            }
        }
@ -219,8 +205,10 @@ private:

        int shift;
        bool linear;
+        bool wbuffer;

-        s32 xrecip_z;
+        s32 zincr;
+        s32 zcounter;
        s32 w0n, w0d, w1d;

        u32 yfactor;
@ -244,7 +232,7 @@ private:
            Increment = 0;
            XMajor = false;

-            Interp.Setup(0, 0, 0, 0);
+            Interp.Setup(0, 0, 0, 0, false);
            Interp.SetX(0);

            xcov_incr = 0;
@ -252,7 +240,7 @@ private:
            return x0;
        }

-        constexpr s32 Setup(s32 x0, s32 x1, s32 y0, s32 y1, s32 w0, s32 w1, s32 y)
+        constexpr s32 Setup(s32 x0, s32 x1, s32 y0, s32 y1, s32 w0, s32 w1, s32 y, bool wbuffer)
        {
            this->x0 = x0;
            this->y = y;
@ -318,7 +306,7 @@ private:
            s32 x = XVal();

            int interpoffset = (Increment >= 0x40000) && (side ^ Negative);
-            Interp.Setup(y0-interpoffset, y1-interpoffset, w0, w1);
+            Interp.Setup(y0-interpoffset, y1-interpoffset, w0, w1, wbuffer);
            Interp.SetX(y);

            // used for calculating AA coverage
Author	SHA1	Message	Date
Jakly	204dc039ba	Merge `19e8774ad0` into `4528441c74`	2024-11-10 01:35:06 +01:00
Jaklyy	19e8774ad0	fix crash under freak circumstances	2024-05-10 05:54:46 -04:00
Jaklyy	60b28d846f	make it more clear what's actually being done	2024-04-06 17:55:03 -04:00
Jaklyy	fd650cf133	minor clean up i forgot to do	2024-03-30 13:23:41 -04:00
Jaklyy	3f42215602	ok this makes a lot more sense	2024-03-30 08:28:04 -04:00
Jaklyy	8f450faa56	idk	2024-03-29 14:06:52 -04:00
Jaklyy	c5b9c3d36d	optimization attempt	2024-03-29 13:38:12 -04:00
Jaklyy	9ee9389ee1	attempt to optimize quotient/remainder calc	2024-03-17 15:03:47 -04:00
Jaklyy	ee91d7f8f3	notes + optimization should only compile to one div instruction per path now	2024-03-17 10:42:52 -04:00
Jaklyy	b6fa43b0cf	implement approximation of z0 > z1 case	2024-03-16 22:10:21 -04:00
Jaklyy	672e6d03fa	betterer approximation	2024-03-16 22:10:21 -04:00
Jaklyy	668e5580e0	better approximation	2024-03-16 22:10:21 -04:00
Jaklyy	2c457de681	rework to actually work	2024-03-16 22:10:21 -04:00
Jaklyy	f4bae5a5d5	best approximation so far	2024-03-16 22:10:21 -04:00