quake: merge the remaining Pocket Quake PQ_OPT changes

I didn't do _OPT3 because it's disabled in the PQ source.

This gives as +0.2FPS boost over the last commit.

Change-Id: I9c3c8fb7bd23262beb810da6e9469d6b6c4b2a81

7 files changed, 767 insertions, 4 deletions

diff --git a/apps/plugins/sdl/progs/quake/d_scan.c b/apps/plugins/sdl/progs/quake/d_scan.c
index 008c783be6..a2e58649e3 100644
--- a/apps/plugins/sdl/progs/quake/d_scan.c
+++ b/apps/plugins/sdl/progs/quake/d_scan.c
@@ -254,6 +254,7 @@ void Turbulent8 (espan_t *pspan)
 D_DrawSpans8
 =============
 */
+#ifndef USE_PQ_OPT5
 void D_DrawSpans8 (espan_t *pspan)
 {
         int                             count, spancount;
@@ -381,8 +382,197 @@ void D_DrawSpans8 (espan_t *pspan)
 
         } while ((pspan = pspan->pnext) != NULL);
 }
+#else
 
+static int sdivzorig, sdivzstepv, sdivzstepu, sdivz8stepu;
+static int tdivzorig, tdivzstepv, tdivzstepu, tdivz8stepu;
+static int zi8stepu;
+static float last = 0;
+
+/*==============================================
+// UpdateFixedPointVars
+//============================================*/
+void UpdateFixedPointVars( int all )
+{
+        // JB: Store texture transformation matrix in fixed point vars
+        if (all)
+        {
+/*
+                sdivzorig = (int)(524288.0f * d_sdivzorigin); // 13.19 fixed point
+                tdivzorig = (int)(524288.0f * d_tdivzorigin);
+                sdivzstepv = (int)(524288.0f * d_sdivzstepv);
+                tdivzstepv = (int)(524288.0f * d_tdivzstepv);
+                sdivzstepu = (int)(524288.0f * d_sdivzstepu);
+                sdivz8stepu = sdivzstepu*8;
+                tdivzstepu = (int)(524288.0f * d_tdivzstepu);
+                tdivz8stepu = tdivzstepu*8;
+*/
+
+                sdivzorig = (int)(4194304.0f * d_sdivzorigin); // 10.22 fixed point
+                tdivzorig = (int)(4194304.0f * d_tdivzorigin);
+                sdivzstepv = (int)(4194304.0f * d_sdivzstepv);
+                tdivzstepv = (int)(4194304.0f * d_tdivzstepv);
+                sdivzstepu = (int)(4194304.0f * d_sdivzstepu);
+                sdivz8stepu = sdivzstepu*8;
+                tdivzstepu = (int)(4194304.0f * d_tdivzstepu);
+                tdivz8stepu = tdivzstepu*8;
+
+        }
+/*
+        ziorig = (int)(524288.0f * d_ziorigin);  // 13.19 fixed point
+        zistepv = (int)(524288.0f * d_zistepv ); 
+        zistepu = (int)(524288.0f * d_zistepu ); 
+*/
+#ifndef USE_PQ_OPT3
+        d_ziorigin_fxp = (int)(4194304.0f * d_ziorigin);  // 10.22 fixed point
+        d_zistepv_fxp = (int)(4194304.0f * d_zistepv ); 
+        d_zistepu_fxp = (int)(4194304.0f * d_zistepu ); 
+#endif
+
+        zi8stepu = d_zistepu_fxp * 8;
+        last = d_zistepv;
+}
+
+void D_DrawSpans8 (espan_t *pspan)
+{
+        int count, spancount, spancountminus1;
+        unsigned char *pbase, *pdest;
+        fixed16_t s1, t1;
+        int zi, sdivz, tdivz, sstep, tstep;
+        int snext, tnext;
+        pbase = (unsigned char *)cacheblock;
+        //Jacco Biker's fixed point conversion
+
+        // Recalc fixed point values
+        UpdateFixedPointVars( 1 );
+        do
+        {
+                pdest = (unsigned char *)((byte *)d_viewbuffer + (screenwidth * pspan->v) + pspan->u);
+                count = pspan->count;
+                // calculate the initial s/z, t/z, 1/z, s, and t and clamp
+                sdivz = sdivzorig + pspan->v * sdivzstepv + pspan->u * sdivzstepu;
+                tdivz = tdivzorig + pspan->v * tdivzstepv + pspan->u * tdivzstepu;
+                zi = d_ziorigin_fxp + pspan->v * d_zistepv_fxp + pspan->u * d_zistepu_fxp;
+                if (zi == 0) zi = 1;
+                s1 = (((sdivz << 8) / zi) << 8) + sadjust;      // 5.27 / 13.19 = 24.8 >> 8 = 16.16
+                if (s1 > bbextents) s1 = bbextents; else if (s1 < 0) s1 = 0;
+                t1 = (((tdivz << 8) / zi) << 8) + tadjust;
+                if (t1 > bbextentt) t1 = bbextentt; else if (t1 < 0) t1 = 0;
+                // calculate final s/z, t/z, 1/z, s, and t and clamp
+                //sdivz += sdivzstepu * (count - 1);
+                //tdivz += tdivzstepu * (count - 1);
+                //zi += d_zistepu_fxp * (count - 1);
+                //if (zi == 0) zi = 1;
+#if 0
+                s2 = (((sdivz << 8) / zi) << 8) + sadjust;
+                if (s2 > bbextents) s2 = bbextents; else if (s2 < 8) s2 = 8;
+                t2 = (((tdivz << 8) / zi) << 8) + tadjust;
+                if (t2 > bbextentt) t2 = bbextentt; else if (t2 < 8) t2 = 8;
+                if (count > 1)
+                {
+                        sstep = (s2 - s1) / (count - 1);
+                        tstep = (t2 - t1) / (count - 1);
+                }
+#else
+                //End Jacco Biker mod
+                //Dan East: Fixed point conversion for perspective correction
+                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;
+                                if (!zi) zi = 1;
+                                //z = zi;
+                                //z = (float)0x10000 / zi;      // prescale to 16.16 fixed-point
+                                snext = (((sdivz<<8)/zi)<<8)+sadjust;
+                                //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 = (((tdivz<<8)/zi)<<8) + tadjust;
+                                if (tnext > bbextentt)
+                                        tnext = bbextentt;
+                                else if (tnext < 8)
+                                        tnext = 8;      // guard against round-off error on <0 steps
+
+                                sstep = (snext - s1) >> 3;
+                                tstep = (tnext - t1) >> 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 = spancount - 1;
+                                sdivz += sdivzstepu * spancountminus1;
+                                tdivz += tdivzstepu * spancountminus1;
+                                zi += d_zistepu_fxp * spancountminus1;
+                                if (!zi) zi = 1;
+                                //z = zi;//(float)0x10000 / zi; // prescale to 16.16 fixed-point
+                                snext = (((sdivz<<8) / zi)<<8) + 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 = (((tdivz<<8) / zi)<<8) + 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 - s1)) / ((spancount - 1));
+                                        tstep = ((tnext - t1)) / ((spancount - 1));
+                                }
+                        }
+                        do
+                        {
+                                *pdest++ = *(pbase + (s1 >> 16) + (t1 >> 16) * cachewidth);
+                                s1 += sstep;
+                                t1 += tstep;
+                        } while (--spancount > 0);
+
+                        s1 = snext;
+                        t1 = tnext;
+
+                } while (count > 0);
 #endif
+#if 0
+                // Draw span
+                for ( i = 0; i < count; i++ )
+                {
+                        *pdest++ = *(pbase + (s1 >> 16) + (t1 >> 16) * cachewidth);
+                        s1 += sstep;
+                        t1 += tstep;
+                }
+#endif
+        } while ((pspan = pspan->pnext) != NULL);
+}
+
+#endif //USE_PQ_OPT5
+
+#endif // !id386
 
 
 #if     !id386
diff --git a/apps/plugins/sdl/progs/quake/model.c b/apps/plugins/sdl/progs/quake/model.c
index 64c53dfc3e..63a63a4b62 100644
--- a/apps/plugins/sdl/progs/quake/model.c
+++ b/apps/plugins/sdl/progs/quake/model.c
@@ -588,6 +588,9 @@ void Mod_LoadVertexes (lump_t *l)
         dvertex_t       *in;
         mvertex_t       *out;
         int                     i, count;
+#ifdef USE_PQ_OPT2
+        mvertex_fxp_t   *out2;
+#endif
 
         in = (void *)(mod_base + l->fileofs);
         if (l->filelen % sizeof(*in))
@@ -595,6 +598,11 @@ void Mod_LoadVertexes (lump_t *l)
         count = l->filelen / sizeof(*in);
         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
 
+#ifdef USE_PQ_OPT2
+        out2 = Hunk_AllocName ( count*sizeof(*out2), loadname); 
+        loadmodel->vertexes_fxp = out2;
+#endif
+
         loadmodel->vertexes = out;
         loadmodel->numvertexes = count;
 
@@ -603,6 +611,14 @@ void Mod_LoadVertexes (lump_t *l)
                 out->position[0] = LittleFloatUnaligned (in->point[0]);
                 out->position[1] = LittleFloatUnaligned (in->point[1]);
                 out->position[2] = LittleFloatUnaligned (in->point[2]);
+
+#ifdef USE_PQ_OPT2
+                out2->position[0] = (int)(out->position[0]*524288.0f);  //13.19
+                out2->position[1] = (int)(out->position[1]*524288.0f);  //13.19
+                out2->position[2] = (int)(out->position[2]*524288.0f);  //13.19
+                out2++;
+#endif
+
         }
 }
 
diff --git a/apps/plugins/sdl/progs/quake/quakedef.h b/apps/plugins/sdl/progs/quake/quakedef.h
index 8328154c0b..fe9245e851 100644
--- a/apps/plugins/sdl/progs/quake/quakedef.h
+++ b/apps/plugins/sdl/progs/quake/quakedef.h
@@ -31,7 +31,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #ifdef FIXEDPOINT_OPT
 #define USE_PQ_OPT
 #define USE_PQ_OPT1
-//#define USE_PQ_OPT2
+#define USE_PQ_OPT2
 //#define USE_PQ_OPT3 // don't use
 #define USE_PQ_OPT4
 //#define USE_PQ_OPT5
diff --git a/apps/plugins/sdl/progs/quake/r_draw.c b/apps/plugins/sdl/progs/quake/r_draw.c
index c4bf95f112..c7da5a8a7e 100644
--- a/apps/plugins/sdl/progs/quake/r_draw.c
+++ b/apps/plugins/sdl/progs/quake/r_draw.c
@@ -60,6 +60,11 @@ int		intsintable[SIN_BUFFER_SIZE];
 mvertex_t       r_leftenter, r_leftexit;
 mvertex_t       r_rightenter, r_rightexit;
 
+#ifdef USE_PQ_OPT2
+mvertex_fxp_t   r_leftenter_fxp, r_leftexit_fxp;
+mvertex_fxp_t   r_rightenter_fxp, r_rightexit_fxp;
+#endif
+
 typedef struct
 {
         float   u,v;
@@ -259,6 +264,311 @@ void R_EmitEdge (mvertex_t *pv0, mvertex_t *pv1)
         removeedges[v2] = edge;
 }
 
+#ifdef USE_PQ_OPT2
+void R_EmitEdgeFXP_fxp (mvertex_fxp_t *pv0, mvertex_fxp_t *pv1)
+{
+        //This is just like R_EmitEdge_fxp, except that the vertex parameters are
+        //already fixed point, and don't need to be converted.
+
+        edge_t  *edge, *pcheck;
+        int             u_check;
+        //float u, u_step;
+        int             u_fxp, u_step_fxp;
+        //vec3_t        local, transformed;
+        int             local_fxp[3], transformed_fxp[3];
+        int             *world;
+        int             v, v2, ceilv0;
+        //float scale, lzi0, u0, v0;
+        int             scale_fxp, scale2_fxp, lzi0_fxp, u0_fxp, v0_fxp;
+        int             side;
+
+        if (r_lastvertvalid)
+        {
+                u0_fxp = r_u1_fxp;
+                v0_fxp = r_v1_fxp;
+                lzi0_fxp = r_lzi1_fxp;
+                //lzi0 = r_lzi1;
+                ceilv0 = r_ceilv1;
+        }
+        else
+        {
+                //world_fxp=(int)(pv0->position[0]*(float)(2^16));
+                world = &pv0->position[0];
+                
+        // transform and project
+                //VectorSubtract (world, modelorg, local);
+                //Vector Subtract (and convert)
+                local_fxp[0]=world[0]-modelorg_fxp[0];
+                local_fxp[1]=world[1]-modelorg_fxp[1];
+                local_fxp[2]=world[2]-modelorg_fxp[2];
+
+                //TransformVector (local, transformed);
+                //transformed_fxp[0] = (int)(local_fxp[0]*vright[0])+(int)(local_fxp[1]*vright[1])+(int)(local_fxp[2]*vright[2]);
+                //transformed_fxp[1] = (int)(local_fxp[0]*vup[0])+(int)(local_fxp[1]*vup[1])+(int)(local_fxp[2]*vup[2]);
+                //transformed_fxp[2] = (int)(local_fxp[0]*vpn[0])+(int)(local_fxp[1]*vpn[1])+(int)(local_fxp[2]*vpn[2]);
+
+                //13.19 / 24.8 = 21.11
+                transformed_fxp[0] = local_fxp[0]/vright_fxp[0]+local_fxp[1]/vright_fxp[1]+local_fxp[2]/vright_fxp[2];
+                transformed_fxp[1] = local_fxp[0]/vup_fxp[0]+local_fxp[1]/vup_fxp[1]+local_fxp[2]/vup_fxp[2];
+                transformed_fxp[2] = local_fxp[0]/vpn_fxp[0]+local_fxp[1]/vpn_fxp[1]+local_fxp[2]/vpn_fxp[2];
+                
+                if (transformed_fxp[2] < (int)(NEAR_CLIP*2048.0))
+                        transformed_fxp[2] = (int)(NEAR_CLIP*2048.0);
+
+                transformed_fxp[0]/=16;         //21.11->25.7
+                transformed_fxp[1]/=16;         //21.11->25.7
+                transformed_fxp[2]/=8;          //21.11->24.8
+
+                lzi0_fxp=transformed_fxp[2];
+                //lzi0 = (float)(1.0 / transformed[2]);
+
+        // FIXME: build x/yscale into transform?
+                //scale = xscale * lzi0;
+                //u0 = (xcenter + scale*transformed[0]);
+
+                //Dan: Is this needed?
+                if (!transformed_fxp[2]) scale_fxp=0;
+                else scale_fxp=xscale_fxp/transformed_fxp[2];   //9.23 / 24.8 = 17.15
+                scale2_fxp=transformed_fxp[0]*(scale_fxp);      // 25.7 * 17.15 = 10.22
+
+                if (transformed_fxp[0]<0) {
+                        if (scale2_fxp>0) scale2_fxp=-511*4194304;
+                } else {
+                        if (scale2_fxp<0) scale2_fxp=511*4194304;
+                }
+
+                u0_fxp=scale2_fxp+xcenter_fxp;
+
+                if (u0_fxp < r_refdef_fvrectx_adj_fxp)
+                        u0_fxp = r_refdef_fvrectx_adj_fxp;
+                if (u0_fxp > r_refdef_fvrectright_adj_fxp)
+                        u0_fxp = r_refdef_fvrectright_adj_fxp;
+
+                //scale = yscale * lzi0;
+                //v0 = (ycenter - scale*transformed[1]);
+
+                //Dan: Is this needed?
+                if (!transformed_fxp[2]) scale_fxp=0;
+                else scale_fxp=yscale_fxp/transformed_fxp[2];   //9.23 / 24.8 = 17.15
+                scale2_fxp=transformed_fxp[1]*(scale_fxp);      // 25.7 * 17.15 = 10.22
+
+                if (transformed_fxp[1]<0) {
+                        if (scale2_fxp>0) scale2_fxp=-511*4194304;
+                } else {
+                        if (scale2_fxp<0) scale2_fxp=511*4194304;       //255*8388608;
+                }
+
+                v0_fxp = ycenter_fxp-scale2_fxp;
+
+                if (v0_fxp < r_refdef_fvrecty_adj_fxp)
+                        v0_fxp = r_refdef_fvrecty_adj_fxp;
+                if (v0_fxp > r_refdef_fvrectbottom_adj_fxp)
+                        v0_fxp = r_refdef_fvrectbottom_adj_fxp;
+        
+                ceilv0 = v0_fxp/4194304;
+                if (v0_fxp&0x3FFFFF) ceilv0++;
+        }
+
+        //world(pv1->position[0]*(float)(2^16));
+        world = &pv1->position[0];
+
+// transform and project
+        //VectorSubtract (world, modelorg, local);
+        //Vector Subtract (and convert)
+        local_fxp[0]=world[0]-modelorg_fxp[0];
+        local_fxp[1]=world[1]-modelorg_fxp[1];
+        local_fxp[2]=world[2]-modelorg_fxp[2];
+
+        //TransformVector (local, transformed);
+        //transformed_fxp[0] = ((int)(local_fxp[0]*vright[0]))+((int)(local_fxp[1]*vright[1]))+((int)(local_fxp[2]*vright[2]));
+        //transformed_fxp[1] = ((int)(local_fxp[0]*vup[0]))+((int)(local_fxp[1]*vup[1]))+((int)(local_fxp[2]*vup[2]));
+        //transformed_fxp[2] = ((int)(local_fxp[0]*vpn[0]))+((int)(local_fxp[1]*vpn[1]))+((int)(local_fxp[2]*vpn[2]));
+
+        transformed_fxp[0] = local_fxp[0]/vright_fxp[0]+local_fxp[1]/vright_fxp[1]+local_fxp[2]/vright_fxp[2];
+        transformed_fxp[1] = local_fxp[0]/vup_fxp[0]+local_fxp[1]/vup_fxp[1]+local_fxp[2]/vup_fxp[2];
+        transformed_fxp[2] = local_fxp[0]/vpn_fxp[0]+local_fxp[1]/vpn_fxp[1]+local_fxp[2]/vpn_fxp[2];
+
+        if (transformed_fxp[2] < (int)(NEAR_CLIP*2048.0))
+                transformed_fxp[2] = (int)(NEAR_CLIP*2048.0);
+
+        transformed_fxp[0]/=16;
+        transformed_fxp[1]/=16;
+        transformed_fxp[2]/=8;
+
+        r_lzi1_fxp=transformed_fxp[2];
+        //r_lzi1 = (float)(1.0 / transformed[2]);
+        //scale = xscale * r_lzi1;
+
+        //Dan: Is this needed?
+        if (!transformed_fxp[2]) scale_fxp=0;
+        else scale_fxp=xscale_fxp/transformed_fxp[2];   //9.23 / 24.8 = 17.15
+        scale2_fxp=transformed_fxp[0]*(scale_fxp);      // 24.8 * 17.15 = 9.23 //21.11
+
+        if (transformed_fxp[0]<0) {
+                if (scale2_fxp>0) scale2_fxp=-511*4194304;
+        } else {
+                if (scale2_fxp<0) scale2_fxp=511*4194304;
+        }
+
+        //r_u1 = (xcenter + scale*transformed[0]);
+        r_u1_fxp = xcenter_fxp + scale2_fxp;
+        if (r_u1_fxp < r_refdef_fvrectx_adj_fxp)
+                r_u1_fxp = r_refdef_fvrectx_adj_fxp;
+        if (r_u1_fxp > r_refdef_fvrectright_adj_fxp)
+                r_u1_fxp = r_refdef_fvrectright_adj_fxp;
+
+        //scale = yscale * r_lzi1;
+        //r_v1 = (ycenter - scale*transformed[1]);
+
+        //Dan: Is this needed?
+        if (!transformed_fxp[2]) scale_fxp=0;
+        else scale_fxp=yscale_fxp/transformed_fxp[2];   //9.23 / 24.8 = 17.15
+        scale2_fxp=transformed_fxp[1]*(scale_fxp);      // 23.9 * 17.15 = 9.23 //21.11
+
+        if (transformed_fxp[1]<0) {
+                if (scale2_fxp>0) scale2_fxp=-511*4194304;
+        } else {
+                if (scale2_fxp<0) scale2_fxp=511*4194304;
+        }
+
+        r_v1_fxp = ycenter_fxp - scale2_fxp;
+        if (r_v1_fxp < r_refdef_fvrecty_adj_fxp)
+                r_v1_fxp = r_refdef_fvrecty_adj_fxp;
+        if (r_v1_fxp > r_refdef_fvrectbottom_adj_fxp)
+                r_v1_fxp = r_refdef_fvrectbottom_adj_fxp;
+
+        //if (r_lzi1 > lzi0)
+        //      lzi0 = r_lzi1;
+        if (r_lzi1_fxp < lzi0_fxp)
+                lzi0_fxp = r_lzi1_fxp;
+
+        //if (lzi0 > r_nearzi)  // for mipmap finding
+        //      r_nearzi = lzi0;
+        if (/*128*/128.0/lzi0_fxp > r_nearzi) { // for mipmap finding
+                //if (!lzi0_fxp) r_nearzi=0;
+                //else
+                        r_nearzi = (float)(128.0/lzi0_fxp);
+        }
+
+// for right edges, all we want is the effect on 1/z
+        if (r_nearzionly)
+                return;
+
+        r_emitted = 1;
+
+        //r_ceilv1 = (int) ceil(r_v1);
+        r_ceilv1 = r_v1_fxp/4194304;
+        if (r_v1_fxp&0x3FFFFF) r_ceilv1++;
+
+
+// create the edge
+        if (ceilv0 == r_ceilv1)
+        {
+        // we cache unclipped horizontal edges as fully clipped
+                if (cacheoffset != 0x7FFFFFFF)
+                {
+                        cacheoffset = FULLY_CLIPPED_CACHED |
+                                        (r_framecount & FRAMECOUNT_MASK);
+                }
+
+                return;         // horizontal edge
+        }
+
+        side = ceilv0 > r_ceilv1;
+        
+        edge = edge_p++;
+
+        edge->owner = NULL;
+        
+        edge->owner = r_pedge;
+
+        //Dan: Is this needed?
+        if (!lzi0_fxp) edge->nearzi=0.0;
+        else edge->nearzi = (float)(128.0f/*256.0*//lzi0_fxp);
+
+        if (side == 0)
+        {
+                int tmp;
+        // trailing edge (go from p1 to p2)
+                v = ceilv0;
+                v2 = r_ceilv1 - 1;
+
+                edge->surfs[0] = surface_p - surfaces;
+                edge->surfs[1] = 0;
+
+                //u_step = ((r_u1 - u0) / (r_v1 - v0));
+                //u = u0 + ((float)v - v0) * u_step;
+
+                tmp=((r_v1_fxp - v0_fxp)>>10);
+                if (tmp)
+                        u_step_fxp=(r_u1_fxp - u0_fxp) / tmp;   //10.22 / 15.12 = 22.10
+                else
+                        u_step_fxp=0;
+                u_fxp = u0_fxp + ((v*4194304 - v0_fxp)>>12 * u_step_fxp>>12);
+        }
+        else
+        {
+                int tmp;
+        // leading edge (go from p2 to p1)
+                v2 = ceilv0 - 1;
+                v = r_ceilv1;
+
+                edge->surfs[0] = 0;
+                edge->surfs[1] = surface_p - surfaces;
+
+                //u_step = ((u0 - r_u1) / (v0 - r_v1));
+                //u = r_u1 + ((float)v - r_v1) * u_step;
+
+                tmp=((v0_fxp - r_v1_fxp)>>10);
+                if (tmp)
+                        u_step_fxp = (u0_fxp - r_u1_fxp) / tmp;
+                else 
+                        u_step_fxp=0;
+                u_fxp = r_u1_fxp + ((v*4194304 - r_v1_fxp)>>12 * u_step_fxp>>12);
+
+        }
+        //edge->u_step = tmp*0x100000;
+        //edge->u = (int)(/*(u_fxp/65536)*0x100000*/u_fxp/4 + 0xFFFFF);
+
+        edge->u_step = u_step_fxp*1024;///16; //tmp*0x100000;
+        edge->u = (int)(/*(u_fxp/65536)*0x100000*/u_fxp/4 + 0xFFFFF);
+
+// we need to do this to avoid stepping off the edges if a very nearly
+// horizontal edge is less than epsilon above a scan, and numeric error causes
+// it to incorrectly extend to the scan, and the extension of the line goes off
+// the edge of the screen
+// FIXME: is this actually needed?
+        if (edge->u < r_refdef.vrect_x_adj_shift20)
+                edge->u = r_refdef.vrect_x_adj_shift20;
+        if (edge->u > r_refdef.vrectright_adj_shift20)
+                edge->u = r_refdef.vrectright_adj_shift20;
+
+//
+// sort the edge in normally
+//
+        u_check = edge->u;
+        if (edge->surfs[0])
+                u_check++;      // sort trailers after leaders
+
+        if (!newedges[v] || newedges[v]->u >= u_check)
+        {
+                edge->next = newedges[v];
+                newedges[v] = edge;
+        }
+        else
+        {
+                pcheck = newedges[v];
+                while (pcheck->next && pcheck->next->u < u_check)
+                        pcheck = pcheck->next;
+                edge->next = pcheck->next;
+                pcheck->next = edge;
+        }
+
+        edge->nextremove = removeedges[v2];
+        removeedges[v2] = edge;
+}
+#endif
+
 #ifdef USE_PQ_OPT1
 void R_EmitEdge_fxp (mvertex_t *pv0, mvertex_t *pv1)
 {
@@ -560,6 +870,138 @@ void R_EmitEdge_fxp (mvertex_t *pv0, mvertex_t *pv1)
 }
 #endif
 
+#ifdef USE_PQ_OPT2
+void R_ClipEdge_fxp (mvertex_fxp_t pv0[3], mvertex_fxp_t pv1[3], clipplane_fxp_t *clip)
+{
+        int                             d0_fxp, d1_fxp, f_fxp;
+        mvertex_fxp_t   clipvert_fxp;
+        //12.20
+
+        if (clip)
+        {
+                do
+                {
+                        //13.19 / 20.12 = 25.7
+                        d0_fxp=(pv0->position[0])/clip->normal[0]+(pv0->position[1])/clip->normal[1]+(pv0->position[2])/clip->normal[2];
+                        d1_fxp=(pv1->position[0])/clip->normal[0]+(pv1->position[1])/clip->normal[1]+(pv1->position[2])/clip->normal[2];
+                        d0_fxp-=(clip->dist);
+                        d1_fxp-=(clip->dist);
+                        //d0 = DotProduct (pv0->position, clip->normal) - clip->dist;
+                        //d1 = DotProduct (pv1->position, clip->normal) - clip->dist;
+
+                        if (d0_fxp >= 0)
+                        {
+                        // point 0 is unclipped
+                                if (d1_fxp >= 0)
+                                {
+                                // both points are unclipped
+                                        continue;
+                                }
+
+                        // only point 1 is clipped
+
+                        // we don't cache clipped edges
+                                cacheoffset = 0x7FFFFFFF;
+
+                                if (!(d0_fxp)) 
+                                        f_fxp=2<<29;    
+                                else {
+                                        f_fxp = (((d0_fxp - d1_fxp)<<7)/(d0_fxp));      //(25.7->18.14) / 25.7 = 25.7
+                                        if (!f_fxp) f_fxp=2<<29;
+                                }
+
+
+                                clipvert_fxp.position[0] = pv0->position[0] +
+                                                (((pv1->position[0] - pv0->position[0])/f_fxp)<<7); //13.19 / 25.7 = 20.12
+
+                                clipvert_fxp.position[1] = pv0->position[1] +
+                                                (((pv1->position[1] - pv0->position[1])/f_fxp)<<7);
+
+                                clipvert_fxp.position[2] = pv0->position[2] +
+                                                (((pv1->position[2] - pv0->position[2])/f_fxp)<<7);
+
+                                if (clip->leftedge)
+                                {
+                                        r_leftclipped = true;
+                                        r_leftexit_fxp = clipvert_fxp;
+                                }
+                                else if (clip->rightedge)
+                                {
+                                        r_rightclipped = true;
+                                        r_rightexit_fxp = clipvert_fxp;
+                                }
+
+                                R_ClipEdge_fxp (pv0, &clipvert_fxp, clip->next);
+                                return;
+                        }
+                        else
+                        {
+                        // point 0 is clipped
+                                if (d1_fxp < 0)
+                                {
+                                // both points are clipped
+                                // we do cache fully clipped edges
+                                        if (!r_leftclipped)
+                                                cacheoffset = FULLY_CLIPPED_CACHED |
+                                                                (r_framecount & FRAMECOUNT_MASK);
+                                        return;
+                                }
+
+                        // only point 0 is clipped
+                                r_lastvertvalid = false;
+
+                        // we don't cache partially clipped edges
+                                cacheoffset = 0x7FFFFFFF;
+
+                                if (!d0_fxp) 
+                                        f_fxp=2<<29;    
+                                else {
+                                        f_fxp = (((d0_fxp - d1_fxp)<<7)/d0_fxp);        //12.20 / 20.12 = 24.8
+                                        if (!f_fxp) f_fxp=2<<29;
+                                }
+
+                                clipvert_fxp.position[0] = pv0->position[0] +
+                                                (((pv1->position[0] - pv0->position[0])/f_fxp)<<7); //12.20 / 24.8 = 20.12
+
+                                clipvert_fxp.position[1] = pv0->position[1] +
+                                                (((pv1->position[1] - pv0->position[1])/f_fxp)<<7);
+
+                                clipvert_fxp.position[2] = pv0->position[2] +
+                                                (((pv1->position[2] - pv0->position[2])/f_fxp)<<7);
+
+                                if (clip->leftedge)
+                                {
+                                        r_leftclipped = true;
+                                        r_leftenter_fxp = clipvert_fxp;
+                                }
+                                else if (clip->rightedge)
+                                {
+                                        r_rightclipped = true;
+                                        r_rightenter_fxp = clipvert_fxp;
+                                }
+
+                                R_ClipEdge_fxp (&clipvert_fxp, pv1, clip->next);
+                                return;
+                        }
+                } while ((clip = clip->next) != NULL);
+        }
+/*
+{
+        mvertex_t p0, p1;
+        p0.position[0]=pv0->position[0]/524288.0f;
+        p0.position[1]=pv0->position[1]/524288.0f;
+        p0.position[2]=pv0->position[2]/524288.0f;
+        p1.position[0]=pv1->position[0]/524288.0f;
+        p1.position[1]=pv1->position[1]/524288.0f;
+        p1.position[2]=pv1->position[2]/524288.0f;
+        R_EmitEdge (&p0, &p1);
+}
+*/
+// add the edge
+        R_EmitEdgeFXP_fxp (pv0, pv1);
+}
+#endif
+
 /*
 ================
 R_ClipEdge
@@ -705,6 +1147,9 @@ void R_RenderFace (msurface_t *fa, int clipflags)
         vec3_t          p_normal;
         medge_t         *pedges, tedge;
         clipplane_t     *pclip;
+#ifdef USE_PQ_OPT2
+        clipplane_fxp_t *pclip_fxp;
+#endif
 
 // skip out if no more surfs
         if ((surface_p) >= surf_max)
@@ -734,6 +1179,19 @@ void R_RenderFace (msurface_t *fa, int clipflags)
                 }
         }
 
+#ifdef USE_PQ_OPT2
+        pclip_fxp = NULL;
+
+        for (i=3, mask = 0x08 ; i>=0 ; i--, mask >>= 1)
+        {
+                if (clipflags & mask)
+                {
+                        view_clipplanes_fxp[i].next = pclip_fxp;
+                        pclip_fxp = &view_clipplanes_fxp[i];
+                }
+        }
+#endif
+
 // push the edges through
         r_emitted = 0;
         r_nearzi = 0;
@@ -779,9 +1237,16 @@ void R_RenderFace (msurface_t *fa, int clipflags)
                 // assume it's cacheable
                         cacheoffset = (byte *)edge_p - (byte *)r_edges;
                         r_leftclipped = r_rightclipped = false;
+#ifndef USE_PQ_OPT2
                         R_ClipEdge (&r_pcurrentvertbase[r_pedge->v[0]],
                                                 &r_pcurrentvertbase[r_pedge->v[1]],
                                                 pclip);
+#else
+                        R_ClipEdge_fxp (&r_pcurrentvertbase_fxp[r_pedge->v[0]],
+                                                &r_pcurrentvertbase_fxp[r_pedge->v[1]],
+                                                pclip_fxp);
+#endif
+
                         r_pedge->cachededgeoffset = cacheoffset;
 
                         if (r_leftclipped)
@@ -825,9 +1290,15 @@ void R_RenderFace (msurface_t *fa, int clipflags)
                 // assume it's cacheable
                         cacheoffset = (byte *)edge_p - (byte *)r_edges;
                         r_leftclipped = r_rightclipped = false;
+#ifndef USE_PQ_OPT2
                         R_ClipEdge (&r_pcurrentvertbase[r_pedge->v[1]],
                                                 &r_pcurrentvertbase[r_pedge->v[0]],
                                                 pclip);
+#else
+                        R_ClipEdge_fxp (&r_pcurrentvertbase_fxp[r_pedge->v[1]],
+                                                &r_pcurrentvertbase_fxp[r_pedge->v[0]],
+                                                pclip_fxp);
+#endif
                         r_pedge->cachededgeoffset = cacheoffset;
 
                         if (r_leftclipped)
@@ -845,7 +1316,11 @@ void R_RenderFace (msurface_t *fa, int clipflags)
         {
                 r_pedge = &tedge;
                 r_lastvertvalid = false;
+#ifndef USE_PQ_OPT2
                 R_ClipEdge (&r_leftexit, &r_leftenter, pclip->next);
+#else
+                R_ClipEdge_fxp (&r_leftexit_fxp, &r_leftenter_fxp, pclip_fxp->next);
+#endif
         }
 
 // if there was a clip off the right edge, get the right r_nearzi
@@ -854,7 +1329,11 @@ void R_RenderFace (msurface_t *fa, int clipflags)
                 r_pedge = &tedge;
                 r_lastvertvalid = false;
                 r_nearzionly = true;
+#ifndef USE_PQ_OPT2
                 R_ClipEdge (&r_rightexit, &r_rightenter, view_clipplanes[1].next);
+#else
+                R_ClipEdge_fxp (&r_rightexit_fxp, &r_rightenter_fxp, view_clipplanes_fxp[1].next);
+#endif
         }
 
 // if no edges made it out, return without posting the surface
@@ -876,14 +1355,22 @@ void R_RenderFace (msurface_t *fa, int clipflags)
 // FIXME: cache this?
         TransformVector (pplane->normal, p_normal);
 // FIXME: cache this?
-        distinv = 1.0 / (pplane->dist - DotProduct (modelorg, pplane->normal));
+        distinv = (float) 1.0 / (pplane->dist - DotProduct (modelorg, pplane->normal));
 
+#ifndef USE_PQ_OPT3
         surface_p->d_zistepu = p_normal[0] * xscaleinv * distinv;
         surface_p->d_zistepv = -p_normal[1] * yscaleinv * distinv;
         surface_p->d_ziorigin = p_normal[2] * distinv -
                         xcenter * surface_p->d_zistepu -
                         ycenter * surface_p->d_zistepv;
-
+#else
+        surface_p->d_zistepu_fxp=(int)(p_normal[0] * xscaleinv * distinv*4194304.0f);
+        surface_p->d_zistepv_fxp=(int)(-p_normal[1] * yscaleinv * distinv*4194304.0f);
+        surface_p->d_ziorigin_fxp=((int)(p_normal[2] * distinv * 4194304.0f)) -
+                        ((int)(xcenter * surface_p->d_zistepu_fxp)) -
+                        ((int)(ycenter * surface_p->d_zistepv_fxp));
+#endif
+        
 //JDC   VectorCopy (r_worldmodelorg, surface_p->modelorg);
         surface_p++;
 }
diff --git a/apps/plugins/sdl/progs/quake/r_local.h b/apps/plugins/sdl/progs/quake/r_local.h
index ae3416ba2f..adb9565b8b 100644
--- a/apps/plugins/sdl/progs/quake/r_local.h
+++ b/apps/plugins/sdl/progs/quake/r_local.h
@@ -94,7 +94,28 @@ typedef struct clipplane_s
         byte            reserved[2];
 } clipplane_t;
 
+typedef struct clipplane_fxp_s
+{
+        int                     normal[3];
+        int                     dist;
+        struct          clipplane_fxp_s *next;
+        byte            leftedge;
+        byte            rightedge;
+        byte            reserved[2];
+} clipplane_fxp_t;
+
+typedef struct clipplane_FPM_s
+{
+        vec3_FPM_t      normal;
+        fixedpoint_t    dist;
+        struct          clipplane_FPM_s *next;
+        byte            leftedge;
+        byte            rightedge;
+        byte            reserved[2];
+} clipplane_FPM_t;
+
 extern  clipplane_t     view_clipplanes[4];
+extern  clipplane_FPM_t view_clipplanesFPM[4];
 
 #ifdef USE_PQ_OPT2
 extern  clipplane_fxp_t view_clipplanes_fxp[4];
diff --git a/apps/plugins/sdl/progs/quake/r_main.c b/apps/plugins/sdl/progs/quake/r_main.c
index 7776b46bde..4aa14d69da 100644
--- a/apps/plugins/sdl/progs/quake/r_main.c
+++ b/apps/plugins/sdl/progs/quake/r_main.c
@@ -43,6 +43,9 @@ qboolean	r_dowarp, r_dowarpold, r_viewchanged;
 int                     numbtofpolys;
 btofpoly_t      *pbtofpolys;
 mvertex_t       *r_pcurrentvertbase;
+#ifdef USE_PQ_OPT2
+mvertex_fxp_t   *r_pcurrentvertbase_fxp;
+#endif
 
 int                     c_surf;
 int                     r_maxsurfsseen, r_maxedgesseen, r_cnumsurfs;
@@ -808,6 +811,10 @@ void R_DrawBEntitiesOnList (void)
                                 VectorCopy (modelorg, r_worldmodelorg);
                 
                                 r_pcurrentvertbase = clmodel->vertexes;
+                                
+#ifdef USE_PQ_OPT2
+                                r_pcurrentvertbase_fxp = clmodel->vertexes_fxp;
+#endif
                 
                         // FIXME: stop transforming twice
                                 R_RotateBmodel ();
diff --git a/apps/plugins/sdl/progs/quake/r_misc.c b/apps/plugins/sdl/progs/quake/r_misc.c
index c0aa7e991d..349f760140 100644
--- a/apps/plugins/sdl/progs/quake/r_misc.c
+++ b/apps/plugins/sdl/progs/quake/r_misc.c
@@ -286,8 +286,18 @@ void R_TransformFrustum (void)
                 v2[2] = v[1]*vright[2] + v[2]*vup[2] + v[0]*vpn[2];
 
                 VectorCopy (v2, view_clipplanes[i].normal);
-
                 view_clipplanes[i].dist = DotProduct (modelorg, v2);
+
+#ifdef USE_PQ_OPT2
+                if (!v2[0]) view_clipplanes_fxp[i].normal[0]=2<29;
+                else view_clipplanes_fxp[i].normal[0]=(int)(4096.0f/v2[0]);
+                if (!v2[1]) view_clipplanes_fxp[i].normal[1]=2<29;
+                else view_clipplanes_fxp[i].normal[1]=(int)(4096.0f/v2[1]);
+                if (!v2[2]) view_clipplanes_fxp[i].normal[2]=2<29;
+                else view_clipplanes_fxp[i].normal[2]=(int)(4096.0f/v2[2]);
+
+                view_clipplanes_fxp[i].dist=(int)(view_clipplanes[i].dist*128.0);
+#endif
         }
 }
 
@@ -306,6 +316,38 @@ void TransformVector (vec3_t in, vec3_t out)
         out[2] = DotProduct(in,vpn);            
 }
 
+#ifdef USE_PQ_OPT
+//JB: Optimization
+static float last;
+static fpvec3 fpvright, fpvup, fpvpn;
+void FPTransformVector( fpvec3 in, fpvec3 out )
+{
+        if (last != vright[0])
+        {
+                last = vright[0];
+                fpvright[0] = (int)(16384.0f * vright[0]); 
+                fpvright[1] = (int)(16384.0f * vright[1]); 
+                fpvright[2] = (int)(16384.0f * vright[2]); 
+                fpvup[0] = (int)(16384.0f * vup[0]); 
+                fpvup[1] = (int)(16384.0f * vup[1]); 
+                fpvup[2] = (int)(16384.0f * vup[2]); 
+                fpvpn[0] = (int)(16384.0f * vpn[0]); 
+                fpvpn[1] = (int)(16384.0f * vpn[1]); 
+                fpvpn[2] = (int)(16384.0f * vpn[2]); 
+        }
+        out[0] = (in[0] * fpvright[0] +
+                         in[1] * fpvright[1] +
+                         in[2] * fpvright[2]) >> 4;
+        out[1] = (in[0] * fpvup[0] +
+                         in[1] * fpvup[1] +
+                         in[2] * fpvup[2]) >> 4;
+        out[2] = (in[0] * fpvpn[0] +
+                         in[1] * fpvpn[1] +
+                         in[2] * fpvpn[2]) >> 4;
+}
+
+#endif
+
 #endif