Beispiel #1
0
        /*
        ===============
        R_SetVrect
        ===============
        */
        public static void R_SetVrect(vid.vrect_t pvrectin, vid.vrect_t pvrect, int lineadj)
        {
            int		h;
            double	size;

            size = screen.scr_viewsize.value > 100 ? 100 : screen.scr_viewsize.value;
            if (client.cl.intermission != 0)
            {
                size = 100;
                lineadj = 0;
            }
            size /= 100;

            h = pvrectin.height - lineadj;
            pvrect.width = (int)(pvrectin.width * size);
            if (pvrect.width < 96)
            {
                size = 96.0 / pvrectin.width;
                pvrect.width = 96;	// min for icons
            }
            pvrect.width &= ~7;
            pvrect.height = (int)(pvrectin.height * size);
            if (pvrect.height > pvrectin.height - lineadj)
                pvrect.height = pvrectin.height - lineadj;

            pvrect.height &= ~1;

            pvrect.x = (pvrectin.width - pvrect.width)/2;
            pvrect.y = (h - pvrect.height)/2;

            {
                if (view.lcd_x.value != 0)
                {
                    pvrect.y >>= 1;
                    pvrect.height >>= 1;
                }
            }
        }
Beispiel #2
0
        /*
        ===============
        R_ViewChanged

        Called every time the vid structure or r_refdef changes.
        Guaranteed to be called before the first refresh
        ===============
        */
        public static void R_ViewChanged(vid.vrect_t pvrect, int lineadj, double aspect)
        {
            int     i;
            double  res_scale;

            r_viewchanged = true;

            R_SetVrect(pvrect, r_refdef.vrect, lineadj);

            r_refdef.horizontalFieldOfView = 2.0 * Math.Tan(r_refdef.fov_x / 360 * mathlib.M_PI);
            r_refdef.fvrectx = (double)r_refdef.vrect.x;
            r_refdef.fvrectx_adj = (double)r_refdef.vrect.x - 0.5;
            r_refdef.vrect_x_adj_shift20 = (r_refdef.vrect.x << 20) + (1 << 19) - 1;
            r_refdef.fvrecty = (double)r_refdef.vrect.y;
            r_refdef.fvrecty_adj = (double)r_refdef.vrect.y - 0.5;
            r_refdef.vrectright = r_refdef.vrect.x + r_refdef.vrect.width;
            r_refdef.vrectright_adj_shift20 = (r_refdef.vrectright << 20) + (1 << 19) - 1;
            r_refdef.fvrectright = (double)r_refdef.vrectright;
            r_refdef.fvrectright_adj = (double)r_refdef.vrectright - 0.5;
            r_refdef.vrectrightedge = (double)r_refdef.vrectright - 0.99;
            r_refdef.vrectbottom = r_refdef.vrect.y + r_refdef.vrect.height;
            r_refdef.fvrectbottom = (double)r_refdef.vrectbottom;
            r_refdef.fvrectbottom_adj = (double)r_refdef.vrectbottom - 0.5;

            r_refdef.aliasvrect.x = (int)(r_refdef.vrect.x * r_aliasuvscale);
            r_refdef.aliasvrect.y = (int)(r_refdef.vrect.y * r_aliasuvscale);
            r_refdef.aliasvrect.width = (int)(r_refdef.vrect.width * r_aliasuvscale);
            r_refdef.aliasvrect.height = (int)(r_refdef.vrect.height * r_aliasuvscale);
            r_refdef.aliasvrectright = r_refdef.aliasvrect.x +
                    r_refdef.aliasvrect.width;
            r_refdef.aliasvrectbottom = r_refdef.aliasvrect.y +
                    r_refdef.aliasvrect.height;

            pixelAspect = aspect;
            xOrigin = r_refdef.xOrigin;
            yOrigin = r_refdef.yOrigin;

            screenAspect = r_refdef.vrect.width * pixelAspect /
                    r_refdef.vrect.height;
            // 320*200 1.0 pixelAspect = 1.6 screenAspect
            // 320*240 1.0 pixelAspect = 1.3333 screenAspect
            // proper 320*200 pixelAspect = 0.8333333

            verticalFieldOfView = r_refdef.horizontalFieldOfView / screenAspect;

            // values for perspective projection
            // if math were exact, the values would range from 0.5 to to range+0.5
            // hopefully they wll be in the 0.000001 to range+.999999 and truncate
            // the polygon rasterization will never render in the first row or column
            // but will definately render in the [range] row and column, so adjust the
            // buffer origin to get an exact edge to edge fill
            xcenter = ((double)r_refdef.vrect.width * XCENTERING) +
                    r_refdef.vrect.x - 0.5;
            aliasxcenter = xcenter * r_aliasuvscale;
            ycenter = ((double)r_refdef.vrect.height * YCENTERING) +
                    r_refdef.vrect.y - 0.5;
            aliasycenter = ycenter * r_aliasuvscale;

            xscale = r_refdef.vrect.width / r_refdef.horizontalFieldOfView;
            aliasxscale = xscale * r_aliasuvscale;
            xscaleinv = 1.0 / xscale;
            yscale = xscale * pixelAspect;
            aliasyscale = yscale * r_aliasuvscale;
            yscaleinv = 1.0 / yscale;
            xscaleshrink = (r_refdef.vrect.width - 6) / r_refdef.horizontalFieldOfView;
            yscaleshrink = xscaleshrink * pixelAspect;

            // left side clip
            screenedge[0].normal[0] = -1.0 / (xOrigin * r_refdef.horizontalFieldOfView);
            screenedge[0].normal[1] = 0;
            screenedge[0].normal[2] = 1;
            screenedge[0].type = bspfile.PLANE_ANYZ;

            // right side clip
            screenedge[1].normal[0] =
                    1.0 / ((1.0 - xOrigin) * r_refdef.horizontalFieldOfView);
            screenedge[1].normal[1] = 0;
            screenedge[1].normal[2] = 1;
            screenedge[1].type = bspfile.PLANE_ANYZ;

            // top side clip
            screenedge[2].normal[0] = 0;
            screenedge[2].normal[1] = -1.0 / (yOrigin * verticalFieldOfView);
            screenedge[2].normal[2] = 1;
            screenedge[2].type = bspfile.PLANE_ANYZ;

            // bottom side clip
            screenedge[3].normal[0] = 0;
            screenedge[3].normal[1] = 1.0 / ((1.0 - yOrigin) * verticalFieldOfView);
            screenedge[3].normal[2] = 1;
            screenedge[3].type = bspfile.PLANE_ANYZ;

            for (i = 0; i < 4; i++)
                mathlib.VectorNormalize(screenedge[i].normal);

            res_scale = Math.Sqrt((double)(r_refdef.vrect.width * r_refdef.vrect.height) /
                              (320.0 * 152.0)) *
                    (2.0 / r_refdef.horizontalFieldOfView);
            r_aliastransition = r_aliastransbase.value * res_scale;
            r_resfudge = r_aliastransadj.value * res_scale;

            if (screen.scr_fov.value <= 90.0)
                r_fov_greater_than_90 = false;
            else
                r_fov_greater_than_90 = true;

            draw.D_ViewChanged();
        }
Beispiel #3
0
        /*
        ==============
        R_DrawRect8
        ==============
        */
        static void R_DrawRect8(vid.vrect_t prect, int rowbytes, int psrc, int transparent)
        {
            byte	t;
            int		i, j, srcdelta, destdelta;
            int	    pdest;

            pdest = (int)(/*vid.buffer + */(prect.y * screen.vid.rowbytes) + prect.x);

            srcdelta = rowbytes - prect.width;
            destdelta = (int)(screen.vid.rowbytes - prect.width);

            if (transparent != 0)
            {
                for (i=0 ; i<prect.height ; i++)
                {
                    for (j=0 ; j<prect.width ; j++)
                    {
                        t = r_rectdesc.ptexbytes[psrc];
                        if (t != TRANSPARENT_COLOR)
                        {
                            screen.vid.buffer[pdest] = t;
                        }

                        psrc++;
                        pdest++;
                    }

                    psrc += srcdelta;
                    pdest += destdelta;
                }
            }
            else
            {
                for (i=0 ; i<prect.height ; i++)
                {
                    Buffer.BlockCopy(r_rectdesc.ptexbytes, psrc, screen.vid.buffer, pdest, prect.width);
                    psrc += rowbytes;
                    pdest += (int)screen.vid.rowbytes;
                }
            }
        }