diff options
Diffstat (limited to 'nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb')
41 files changed, 7892 insertions, 0 deletions
diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/Makefile b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/Makefile new file mode 100644 index 000000000..cb73238c0 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/Makefile @@ -0,0 +1,36 @@ +# src/mesa/drivers/dri/ffb/Makefile + +TOP = ../../../../.. +include $(TOP)/configs/current + +LIBNAME = ffb_dri.so + +# not yet +# MINIGLX_SOURCES = server/ffb_dri.c + +DRIVER_SOURCES = \ + ffb_bitmap.c \ + ffb_clear.c \ + ffb_dd.c \ + ffb_depth.c \ + ffb_fog.c \ + ffb_lines.c \ + ffb_points.c \ + ffb_span.c \ + ffb_state.c \ + ffb_stencil.c \ + ffb_tex.c \ + ffb_tris.c \ + ffb_vb.c \ + ffb_xmesa.c + +C_SOURCES = \ + $(COMMON_SOURCES) \ + $(DRIVER_SOURCES) + + +ASM_SOURCES = + +include ../Makefile.template + +symlinks: diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_bitmap.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_bitmap.c new file mode 100644 index 000000000..7263e8381 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_bitmap.c @@ -0,0 +1,159 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_bitmap.c,v 1.1 2002/02/22 21:32:58 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "ffb_context.h" +#include "ffb_state.h" +#include "ffb_lock.h" +#include "ffb_bitmap.h" +#include "swrast/swrast.h" +#include "image.h" +#include "macros.h" + +/* Compute ceiling of integer quotient of A divided by B: */ +#define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 ) + +#undef FFB_BITMAP_TRACE + +static void +ffb_bitmap(GLcontext *ctx, GLint px, GLint py, + GLsizei width, GLsizei height, + const struct gl_pixelstore_attrib *unpack, + const GLubyte *bitmap) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_fbcPtr ffb = fmesa->regs; + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + unsigned int ppc, pixel; + GLint row, col, row_stride; + const GLubyte *src; + char *buf; + + if (fmesa->bad_fragment_attrs != 0) + _swrast_Bitmap(ctx, px, py, width, + height, unpack, bitmap); + + pixel = (((((GLuint)(ctx->Current.RasterColor[0] * 255.0f)) & 0xff) << 0) | + ((((GLuint)(ctx->Current.RasterColor[1] * 255.0f)) & 0xff) << 8) | + ((((GLuint)(ctx->Current.RasterColor[2] * 255.0f)) & 0xff) << 16) | + ((((GLuint)(ctx->Current.RasterColor[3] * 255.0f)) & 0xff) << 24)); + +#ifdef FFB_BITMAP_TRACE + fprintf(stderr, "ffb_bitmap: ppc(%08x) fbc(%08x) cmp(%08x) pixel(%08x)\n", + fmesa->ppc, fmesa->fbc, fmesa->cmp, pixel); +#endif + + LOCK_HARDWARE(fmesa); + fmesa->hw_locked = 1; + + if (fmesa->state_dirty) + ffbSyncHardware(fmesa); + + ppc = fmesa->ppc; + + FFBFifo(fmesa, 4); + ffb->ppc = ((ppc & + ~(FFB_PPC_TBE_MASK | FFB_PPC_ZS_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK)) + | (FFB_PPC_TBE_TRANSPARENT | FFB_PPC_ZS_CONST | FFB_PPC_CS_CONST | + (ctx->Color.BlendEnabled ? FFB_PPC_XS_CONST : FFB_PPC_XS_WID))); + ffb->constz = ((GLuint) (ctx->Current.RasterPos[2] * 0x0fffffff)); + ffb->fg = pixel; + ffb->fontinc = (0 << 16) | 32; + + buf = (char *)(fmesa->sfb32 + (dPriv->x << 2) + (dPriv->y << 13)); + + row_stride = (unpack->Alignment * CEILING(width, 8 * unpack->Alignment)); + src = (const GLubyte *) (bitmap + + (unpack->SkipRows * row_stride) + + (unpack->SkipPixels / 8)); + if (unpack->LsbFirst == GL_TRUE) { + for (row = 0; row < height; row++, src += row_stride) { + const GLubyte *row_src = src; + GLuint base_x, base_y; + + base_x = dPriv->x + px; + base_y = dPriv->y + (dPriv->h - (py + row)); + + FFBFifo(fmesa, 1); + ffb->fontxy = (base_y << 16) | base_x; + + for (col = 0; col < width; col += 32, row_src += 4) { + GLint bitnum, font_w = (width - col); + GLuint font_data; + + if (font_w > 32) + font_w = 32; + font_data = 0; + for (bitnum = 0; bitnum < 32; bitnum++) { + const GLubyte val = row_src[bitnum >> 3]; + + if (val & (1 << (bitnum & (8 - 1)))) + font_data |= (1 << (31 - bitnum)); + } + + FFBFifo(fmesa, 2); + ffb->fontw = font_w; + ffb->font = font_data; + } + } + } else { + for (row = 0; row < height; row++, src += row_stride) { + const GLubyte *row_src = src; + GLuint base_x, base_y; + + base_x = dPriv->x + px; + base_y = dPriv->y + (dPriv->h - (py + row)); + + FFBFifo(fmesa, 1); + ffb->fontxy = (base_y << 16) | base_x; + + for (col = 0; col < width; col += 32, row_src += 4) { + GLint font_w = (width - col); + + if (font_w > 32) + font_w = 32; + FFBFifo(fmesa, 2); + ffb->fontw = font_w; + ffb->font = (((unsigned int)row_src[0]) << 24 | + ((unsigned int)row_src[1]) << 16 | + ((unsigned int)row_src[2]) << 8 | + ((unsigned int)row_src[3]) << 0); + } + } + } + + FFBFifo(fmesa, 1); + ffb->ppc = ppc; + fmesa->ffbScreen->rp_active = 1; + + UNLOCK_HARDWARE(fmesa); + fmesa->hw_locked = 0; +} + +void ffbDDInitBitmapFuncs(GLcontext *ctx) +{ + ctx->Driver.Bitmap = ffb_bitmap; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_bitmap.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_bitmap.h new file mode 100644 index 000000000..4f8d2ea2a --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_bitmap.h @@ -0,0 +1,8 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_bitmap.h,v 1.1 2002/02/22 21:32:58 dawes Exp $ */ + +#ifndef _FFB_BITMAP_H +#define _FFB_BITMAP_H + +extern void ffbDDInitBitmapFuncs(GLcontext *); + +#endif /* !(_FFB_BITMAP_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_clear.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_clear.c new file mode 100644 index 000000000..c63179149 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_clear.c @@ -0,0 +1,354 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_clear.c,v 1.2 2002/02/22 21:32:58 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "mtypes.h" +#include "extensions.h" + +#include "mm.h" +#include "ffb_dd.h" +#include "ffb_span.h" +#include "ffb_depth.h" +#include "ffb_context.h" +#include "ffb_vb.h" +#include "ffb_tris.h" +#include "ffb_clear.h" +#include "ffb_lock.h" + +#undef CLEAR_TRACE + +#define BOX_AREA(__w, __h) ((int)(__w) * (int)(__h)) + +/* Compute the page aligned box for a page mode fast fill. + * In 'ework' this returns greater than zero if there are some odd + * edges to take care of which are outside of the page aligned area. + * It will place less than zero there if the box is too small, + * indicating that a different method must be used to fill it. + */ +#define CreatorPageFillParms(ffp, x, y, w, h, px, py, pw, ph, ework) \ +do { int xdiff, ydiff; \ + int pf_bh = ffp->pagefill_height; \ + int pf_bw = ffp->pagefill_width; \ + py = ((y + (pf_bh - 1)) & ~(pf_bh - 1)); \ + ydiff = py - y; \ + px = ffp->Pf_AlignTab[x + (pf_bw - 1)]; \ + xdiff = px - x; \ + ph = ((h - ydiff) & ~(pf_bh - 1)); \ + if(ph <= 0) \ + ework = -1; \ + else { \ + pw = ffp->Pf_AlignTab[w - xdiff]; \ + if(pw <= 0) { \ + ework = -1; \ + } else { \ + ework = (((xdiff > 0) || \ + (ydiff > 0) || \ + ((w - pw) > 0) || \ + ((h - ph) > 0))) ? 1 : 0; \ + } \ + } \ +} while(0); + +struct ff_fixups { + int x, y, width, height; +}; + +/* Compute fixups of non-page aligned areas after a page fill. + * Return the number of fixups needed. + */ +static __inline__ int +CreatorComputePageFillFixups(struct ff_fixups *fixups, + int x, int y, int w, int h, + int paligned_x, int paligned_y, + int paligned_w, int paligned_h) +{ + int nfixups = 0; + + /* FastFill Left */ + if(paligned_x != x) { + fixups[nfixups].x = x; + fixups[nfixups].y = paligned_y; + fixups[nfixups].width = paligned_x - x; + fixups[nfixups].height = paligned_h; + nfixups++; + } + /* FastFill Top */ + if(paligned_y != y) { + fixups[nfixups].x = x; + fixups[nfixups].y = y; + fixups[nfixups].width = w; + fixups[nfixups].height = paligned_y - y; + nfixups++; + } + /* FastFill Right */ + if((x+w) != (paligned_x+paligned_w)) { + fixups[nfixups].x = (paligned_x+paligned_w); + fixups[nfixups].y = paligned_y; + fixups[nfixups].width = (x+w) - fixups[nfixups].x; + fixups[nfixups].height = paligned_h; + nfixups++; + } + /* FastFill Bottom */ + if((y+h) != (paligned_y+paligned_h)) { + fixups[nfixups].x = x; + fixups[nfixups].y = (paligned_y+paligned_h); + fixups[nfixups].width = w; + fixups[nfixups].height = (y+h) - fixups[nfixups].y; + nfixups++; + } + return nfixups; +} + +static void +ffb_do_clear(ffbContextPtr fmesa, __DRIdrawablePrivate *dPriv, + GLboolean all, GLint cx, GLint cy, GLint cwidth, + GLint cheight) +{ + FFBDRIPtr gDRIPriv = (FFBDRIPtr) fmesa->driScreen->pDevPriv; + ffb_fbcPtr ffb = fmesa->regs; + drm_clip_rect_t *box = dPriv->pClipRects; + int nc = dPriv->numClipRects; + + cy = dPriv->h - cy - cheight; + cx += dPriv->x; + cy += dPriv->y; + + while (nc--) { + GLint x = box[nc].x1; + GLint y = box[nc].y1; + GLint width = box[nc].x2 - x; + GLint height = box[nc].y2 - y; + int paligned_y, paligned_x; + int paligned_h, paligned_w = 0; + int extra_work; + + if (!all) { + if (x < cx) { + width -= cx - x; + x = cx; + } + if (y < cy) { + height -= cy - y; + y = cy; + } + if (x + width > cx + cwidth) + width = cx + cwidth - x; + if (y + height > cy + cheight) + height = cy + cheight - y; + if (width <= 0) + continue; + if (height <= 0) + continue; + } + + if (BOX_AREA(width, height) < gDRIPriv->fastfill_small_area) { + FFBFifo(fmesa, 5); + ffb->drawop = FFB_DRAWOP_RECTANGLE; + ffb->by = y; + ffb->bx = x; + ffb->bh = height; + ffb->bw = width; + continue; + } + + FFBFifo(fmesa, 1); + ffb->drawop = FFB_DRAWOP_FASTFILL; + + if (gDRIPriv->disable_pagefill || + (width < (gDRIPriv->pagefill_width<<1)) || + (height < (gDRIPriv->pagefill_height<<1))) + goto do_fastfill; + + CreatorPageFillParms(gDRIPriv, + x, y, width, height, + paligned_x, paligned_y, + paligned_w, paligned_h, extra_work); + + if (extra_work < 0 || + BOX_AREA(paligned_w, paligned_h) < gDRIPriv->pagefill_small_area) { + do_fastfill: + FFBFifo(fmesa, 10); + ffb->by = FFB_FASTFILL_COLOR_BLK; + ffb->dy = 0; + ffb->dx = 0; + ffb->bh = gDRIPriv->fastfill_height; + ffb->bw = (gDRIPriv->fastfill_width * 4); + ffb->by = FFB_FASTFILL_BLOCK; + ffb->dy = y; + ffb->dx = x; + ffb->bh = (height + (y & (gDRIPriv->fastfill_height - 1))); + ffb->bx = (width + (x & (gDRIPriv->fastfill_width - 1))); + continue; + } + + /* Ok, page fill is possible and worth it. */ + FFBFifo(fmesa, 15); + ffb->by = FFB_FASTFILL_COLOR_BLK; + ffb->dy = 0; + ffb->dx = 0; + ffb->bh = gDRIPriv->fastfill_height; + ffb->bw = gDRIPriv->fastfill_width * 4; + ffb->by = FFB_FASTFILL_BLOCK_X; + ffb->dy = 0; + ffb->dx = 0; + ffb->bh = gDRIPriv->pagefill_height; + ffb->bw = gDRIPriv->pagefill_width * 4; + ffb->by = FFB_FASTFILL_PAGE; + ffb->dy = paligned_y; + ffb->dx = paligned_x; + ffb->bh = paligned_h; + ffb->bx = paligned_w; + + if (extra_work) { + struct ff_fixups local_fixups[4]; + int nfixups; + + nfixups = CreatorComputePageFillFixups(local_fixups, + x, y, width, height, + paligned_x, paligned_y, + paligned_w, paligned_h); + FFBFifo(fmesa, 5 + (nfixups * 5)); + ffb->by = FFB_FASTFILL_COLOR_BLK; + ffb->dy = 0; + ffb->dx = 0; + ffb->bh = gDRIPriv->fastfill_height; + ffb->bw = gDRIPriv->fastfill_width * 4; + + while (--nfixups >= 0) { + int xx, yy, ww, hh; + + xx = local_fixups[nfixups].x; + yy = local_fixups[nfixups].y; + ffb->dy = yy; + ffb->dx = xx; + ww = (local_fixups[nfixups].width + + (xx & (gDRIPriv->fastfill_width - 1))); + hh = (local_fixups[nfixups].height + + (yy & (gDRIPriv->fastfill_height - 1))); + if (nfixups != 0) { + ffb->by = FFB_FASTFILL_BLOCK; + ffb->bh = hh; + ffb->bw = ww; + } else { + ffb->bh = hh; + ffb->by = FFB_FASTFILL_BLOCK; + ffb->bx = ww; + } + } + } + } +} + +void ffbDDClear(GLcontext *ctx, GLbitfield mask, GLboolean all, + GLint cx, GLint cy, GLint cwidth, GLint cheight) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + unsigned int stcmask = BUFFER_BIT_STENCIL; + +#ifdef CLEAR_TRACE + fprintf(stderr, "ffbDDClear: mask(%08x) all(%d) " + "[x(%x)y(%x)w(%x)h(%x)]\n", + mask, (int) all, cx, cy, cwidth, cheight); +#endif + if (!(fmesa->ffb_sarea->flags & FFB_DRI_FFB2PLUS)) + stcmask = 0; + + if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT | BUFFER_BIT_DEPTH | stcmask)) { + ffb_fbcPtr ffb = fmesa->regs; + unsigned int fbc, ppc; + + fbc = (FFB_FBC_XE_ON); + ppc = (FFB_PPC_ACE_DISABLE | FFB_PPC_DCE_DISABLE | + FFB_PPC_ABE_DISABLE | FFB_PPC_VCE_DISABLE | + FFB_PPC_APE_DISABLE | FFB_PPC_XS_WID | + FFB_PPC_ZS_CONST | FFB_PPC_CS_CONST); + + /* Y/X enables must be both on or both off. */ + if (mask & (BUFFER_BIT_DEPTH | stcmask)) { + fbc |= (FFB_FBC_ZE_ON | FFB_FBC_YE_ON | FFB_FBC_WB_C); + } else + fbc |= FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF; + + /* All RGB enables must be both on or both off. */ + if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)) { + if (mask & BUFFER_BIT_FRONT_LEFT) { + if (fmesa->back_buffer == 0) + fbc |= FFB_FBC_WB_B; + else + fbc |= FFB_FBC_WB_A; + } + if (mask & BUFFER_BIT_BACK_LEFT) { + if (fmesa->back_buffer == 0) + fbc |= FFB_FBC_WB_A; + else + fbc |= FFB_FBC_WB_B; + } + fbc |= FFB_FBC_RGBE_ON; + } else + fbc |= FFB_FBC_RGBE_OFF; + + LOCK_HARDWARE(fmesa); + + if (dPriv->numClipRects) { + FFBFifo(fmesa, 8); + ffb->fbc = fbc; + ffb->ppc = ppc; + ffb->xclip = FFB_XCLIP_TEST_ALWAYS; + ffb->cmp = 0x80808080; + ffb->rop = FFB_ROP_NEW; + + if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)) + ffb->fg = fmesa->clear_pixel; + if (mask & BUFFER_BIT_DEPTH) + ffb->constz = fmesa->clear_depth; + if (mask & stcmask) + ffb->consty = fmesa->clear_stencil; + + ffb_do_clear(fmesa, dPriv, all, cx, cy, cwidth, cheight); + + FFBFifo(fmesa, 6); + ffb->ppc = fmesa->ppc; + ffb->fbc = fmesa->fbc; + ffb->xclip = fmesa->xclip; + ffb->cmp = fmesa->cmp; + ffb->rop = fmesa->rop; + ffb->drawop = fmesa->drawop; + if (mask & stcmask) + ffb->consty = fmesa->consty; + fmesa->ffbScreen->rp_active = 1; + } + + UNLOCK_HARDWARE(fmesa); + + mask &= ~(BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT | + BUFFER_BIT_DEPTH | stcmask); + } + + if (mask) + _swrast_Clear(ctx, mask, all, cx, cy, cwidth, cheight); +} + diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_clear.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_clear.h new file mode 100644 index 000000000..4b707f19b --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_clear.h @@ -0,0 +1,9 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_clear.h,v 1.2 2002/02/22 21:32:58 dawes Exp $ */ + +#ifndef _FFB_CLEAR_H +#define _FFB_CLEAR_H + +extern void ffbDDClear(GLcontext *ctx, GLbitfield mask, GLboolean all, + GLint cx, GLint cy, GLint cwidth, GLint cheight); + +#endif /* !(_FFB_CLEAR_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_context.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_context.h new file mode 100644 index 000000000..33f6f7cff --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_context.h @@ -0,0 +1,306 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_context.h,v 1.2 2002/02/22 21:32:58 dawes Exp $ */ + +#ifndef _FFB_CONTEXT_H +#define _FFB_CONTEXT_H + +#include "dri_util.h" +#include "drm.h" + +#include "mtypes.h" + +#include "ffb_xmesa.h" + +typedef struct { + GLfloat alpha; + GLfloat red; + GLfloat green; + GLfloat blue; +} ffb_color; + +#define FFB_GET_ALPHA(VTX) \ + FFB_COLOR_FROM_FLOAT((VTX)->color[0].alpha) +#define FFB_GET_RED(VTX) \ + FFB_COLOR_FROM_FLOAT((VTX)->color[0].red) +#define FFB_GET_GREEN(VTX) \ + FFB_COLOR_FROM_FLOAT((VTX)->color[0].green) +#define FFB_GET_BLUE(VTX) \ + FFB_COLOR_FROM_FLOAT((VTX)->color[0].blue) + +typedef struct { + GLfloat x, y, z; + ffb_color color[2]; +} ffb_vertex; + +#define FFB_DELAYED_VIEWPORT_VARS \ + GLfloat VP_SX = fmesa->hw_viewport[MAT_SX]; \ + GLfloat VP_TX = fmesa->hw_viewport[MAT_TX]; \ + GLfloat VP_SY = fmesa->hw_viewport[MAT_SY]; \ + GLfloat VP_TY = fmesa->hw_viewport[MAT_TY]; \ + GLfloat VP_SZ = fmesa->hw_viewport[MAT_SZ]; \ + GLfloat VP_TZ = fmesa->hw_viewport[MAT_TZ]; \ + (void) VP_SX; (void) VP_SY; (void) VP_SZ; \ + (void) VP_TX; (void) VP_TY; (void) VP_TZ + +#define FFB_GET_Z(VTX) \ + FFB_Z_FROM_FLOAT(VP_SZ * (VTX)->z + VP_TZ) +#define FFB_GET_Y(VTX) \ + FFB_XY_FROM_FLOAT(VP_SY * (VTX)->y + VP_TY) +#define FFB_GET_X(VTX) \ + FFB_XY_FROM_FLOAT(VP_SX * (VTX)->x + VP_TX) + +typedef void (*ffb_point_func)(GLcontext *, ffb_vertex *); +typedef void (*ffb_line_func)(GLcontext *, ffb_vertex *, ffb_vertex *); +typedef void (*ffb_tri_func)(GLcontext *, ffb_vertex *, ffb_vertex *, + ffb_vertex *); +typedef void (*ffb_quad_func)(GLcontext *, ffb_vertex *, ffb_vertex *, + ffb_vertex *, ffb_vertex *); + +/* Immediate mode fast-path support. */ +typedef struct { + GLfloat obj[4]; + GLfloat normal[4]; + GLfloat clip[4]; + GLuint mask; + GLfloat color[4]; + GLfloat win[4]; + GLfloat eye[4]; +} ffbTnlVertex, *ffbTnlVertexPtr; + +typedef void (*ffb_interp_func)(GLfloat t, + ffbTnlVertex *O, + const ffbTnlVertex *I, + const ffbTnlVertex *J); + +struct ffb_current_state { + GLfloat color[4]; + GLfloat normal[4]; + GLfloat specular[4]; +}; + +struct ffb_light_state { + GLfloat base_color[3]; + GLfloat base_alpha; +}; + +struct ffb_vertex_state { + struct ffb_current_state current; + struct ffb_light_state light; +}; + +struct ffb_imm_vertex { + ffbTnlVertex vertices[8]; + ffbTnlVertex *v0; + ffbTnlVertex *v1; + ffbTnlVertex *v2; + ffbTnlVertex *v3; + + void (*save_vertex)(GLcontext *ctx, ffbTnlVertex *v); + void (*flush_vertex)(GLcontext *ctx, ffbTnlVertex *v); + + ffb_interp_func interp; + + GLuint prim, format; + + GLvertexformat vtxfmt; +}; + +typedef struct ffb_context_t { + GLcontext *glCtx; + GLframebuffer *glBuffer; + + ffb_fbcPtr regs; + volatile char *sfb32; + + int hw_locked; + + int back_buffer; /* 0 = bufferA, 1 = bufferB */ + + /* Viewport matrix. */ + GLfloat hw_viewport[16]; +#define SUBPIXEL_X (-0.5F) +#define SUBPIXEL_Y (-0.5F + 0.125) + + /* Vertices in driver format. */ + ffb_vertex *verts; + + /* Rasterization functions. */ + ffb_point_func draw_point; + ffb_line_func draw_line; + ffb_tri_func draw_tri; + ffb_quad_func draw_quad; + + GLenum raster_primitive; + GLenum render_primitive; + + GLfloat backface_sign; + GLfloat depth_scale; + + GLfloat ffb_2_30_fixed_scale; + GLfloat ffb_one_over_2_30_fixed_scale; + GLfloat ffb_16_16_fixed_scale; + GLfloat ffb_one_over_16_16_fixed_scale; + GLfloat ffb_ubyte_color_scale; + GLfloat ffb_zero; + + /* Immediate mode state. */ + struct ffb_vertex_state vtx_state; + struct ffb_imm_vertex imm; + + /* Debugging knobs. */ + GLboolean debugFallbacks; + + /* This records state bits when a per-fragment attribute has + * been set which prevents us from rendering in hardware. + * + * As attributes change, some of these bits may clear as + * we move back within the chips capabilities. If they + * all clear, we return to full hw rendering. + */ + unsigned int bad_fragment_attrs; +#define FFB_BADATTR_FOG 0x00000001 /* Bad fog possible only when < FFB2 */ +#define FFB_BADATTR_BLENDFUNC 0x00000002 /* Any non-const func based upon dst alpha */ +#define FFB_BADATTR_BLENDROP 0x00000004 /* Blend enabled and LogicOP != GL_COPY */ +#define FFB_BADATTR_BLENDEQN 0x00000008 /* Blend equation other than ADD */ +#define FFB_BADATTR_STENCIL 0x00000010 /* Stencil enabled when < FFB2+ */ +#define FFB_BADATTR_TEXTURE 0x00000020 /* Texture enabled */ +#define FFB_BADATTR_SWONLY 0x00000040 /* Environment var set */ + + unsigned int state_dirty; + unsigned int state_fifo_ents; +#define FFB_STATE_FBC 0x00000001 +#define FFB_STATE_PPC 0x00000002 +#define FFB_STATE_DRAWOP 0x00000004 +#define FFB_STATE_ROP 0x00000008 +#define FFB_STATE_LPAT 0x00000010 +#define FFB_STATE_PMASK 0x00000020 +#define FFB_STATE_XPMASK 0x00000040 +#define FFB_STATE_YPMASK 0x00000080 +#define FFB_STATE_ZPMASK 0x00000100 +#define FFB_STATE_XCLIP 0x00000200 +#define FFB_STATE_CMP 0x00000400 +#define FFB_STATE_MATCHAB 0x00000800 +#define FFB_STATE_MAGNAB 0x00001000 +#define FFB_STATE_MATCHC 0x00002000 +#define FFB_STATE_MAGNC 0x00004000 +#define FFB_STATE_DCUE 0x00008000 +#define FFB_STATE_BLEND 0x00010000 +#define FFB_STATE_CLIP 0x00020000 +#define FFB_STATE_STENCIL 0x00040000 +#define FFB_STATE_APAT 0x00080000 +#define FFB_STATE_WID 0x00100000 +#define FFB_STATE_ALL 0x001fffff + + unsigned int state_all_fifo_ents; + +#define FFB_MAKE_DIRTY(FMESA, STATE_MASK, FIFO_ENTS) \ +do { if ((STATE_MASK) & ~((FMESA)->state_dirty)) { \ + (FMESA)->state_dirty |= (STATE_MASK); \ + (FMESA)->state_fifo_ents += FIFO_ENTS; \ + } \ +} while (0) + + /* General hw reg state. */ + unsigned int fbc; + unsigned int ppc; + unsigned int drawop; + unsigned int rop; + + unsigned int lpat; +#define FFB_LPAT_BAD 0xffffffff + + unsigned int wid; + unsigned int pmask; + unsigned int xpmask; + unsigned int ypmask; + unsigned int zpmask; + unsigned int xclip; + unsigned int cmp; + unsigned int matchab; + unsigned int magnab; + unsigned int matchc; + unsigned int magnc; + + /* Depth cue unit hw reg state. */ + unsigned int dcss; /* All FFB */ + unsigned int dcsf; /* All FFB */ + unsigned int dcsb; /* All FFB */ + unsigned int dczf; /* All FFB */ + unsigned int dczb; /* All FFB */ + unsigned int dcss1; /* >=FFB2 only */ + unsigned int dcss2; /* >=FFB2 only */ + unsigned int dcss3; /* >=FFB2 only */ + unsigned int dcs2; /* >=FFB2 only */ + unsigned int dcs3; /* >=FFB2 only */ + unsigned int dcs4; /* >=FFB2 only */ + unsigned int dcd2; /* >=FFB2 only */ + unsigned int dcd3; /* >=FFB2 only */ + unsigned int dcd4; /* >=FFB2 only */ + + /* Blend unit hw reg state. */ + unsigned int blendc; + unsigned int blendc1; + unsigned int blendc2; + + /* ViewPort clipping hw reg state. */ + unsigned int vclipmin; + unsigned int vclipmax; + unsigned int vclipzmin; + unsigned int vclipzmax; + struct { + unsigned int min; + unsigned int max; + } aux_clips[4]; + + /* Stencil control hw reg state. >=FFB2+ only. */ + unsigned int stencil; + unsigned int stencilctl; + unsigned int consty; /* Stencil Ref */ + + /* Area pattern (used for polygon stipples). */ + unsigned int pattern[32]; + + /* Fog state. */ + float Znear, Zfar; + + drm_context_t hHWContext; + drm_hw_lock_t *driHwLock; + int driFd; + + unsigned int clear_pixel; + unsigned int clear_depth; + unsigned int clear_stencil; + + unsigned int setupindex; + unsigned int setupnewinputs; + unsigned int new_gl_state; + + __DRIdrawablePrivate *driDrawable; + __DRIscreenPrivate *driScreen; + ffbScreenPrivate *ffbScreen; + ffb_dri_state_t *ffb_sarea; +} ffbContextRec, *ffbContextPtr; + +#define FFB_CONTEXT(ctx) ((ffbContextPtr)((ctx)->DriverCtx)) + +/* We want the depth values written during software rendering + * to match what the hardware is going to put there when we + * hw render. + * + * The Z buffer is 28 bits deep. Smooth shaded primitives + * specify a 2:30 signed fixed point Z value in the range 0.0 + * to 1.0 inclusive. + * + * So for example, when hw rendering, the largest Z value of + * 1.0 would produce a value of 0x0fffffff in the actual Z + * buffer, which is the maximum value. + * + * Mesa's depth type is a 32-bit int, so we use the following macro + * to convert to/from FFB hw Z values. Note we also have to clear + * out the top bits as that is where the Y (stencil) buffer is stored + * and during hw Z buffer reads it is always there. (During writes + * we tell the hw to discard those top 4 bits). + */ +#define Z_TO_MESA(VAL) ((GLdepth)(((VAL) & 0x0fffffff) << (32 - 28))) +#define Z_FROM_MESA(VAL) (((GLuint)((GLdouble)(VAL))) >> (32 - 28)) + +#endif /* !(_FFB_CONTEXT_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_dd.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_dd.c new file mode 100644 index 000000000..53423bbae --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_dd.c @@ -0,0 +1,119 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_dd.c,v 1.4 2002/09/11 19:49:07 tsi Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000, 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "mtypes.h" +#include "mm.h" +#include "ffb_dd.h" +#include "ffb_span.h" +#include "ffb_depth.h" +#include "ffb_context.h" +#include "ffb_vb.h" +#include "ffb_tris.h" +#include "ffb_clear.h" +#include "ffb_lock.h" +#include "extensions.h" + +#define FFB_DATE "20021125" + +PUBLIC const char __driConfigOptions[] = { 0 }; +const GLuint __driNConfigOptions = 0; + +/* Mesa's Driver Functions */ + +static const GLubyte *ffbDDGetString(GLcontext *ctx, GLenum name) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + static char buffer[128]; + + switch (name) { + case GL_VENDOR: + return (GLubyte *) "David S. Miller"; + + case GL_RENDERER: + sprintf(buffer, "Mesa DRI FFB " FFB_DATE); + + if (fmesa->ffb_sarea->flags & FFB_DRI_FFB2) + strncat(buffer, " FFB2", 5); + if (fmesa->ffb_sarea->flags & FFB_DRI_FFB2PLUS) + strncat(buffer, " FFB2PLUS", 9); + if (fmesa->ffb_sarea->flags & FFB_DRI_PAC1) + strncat(buffer, " PAC1", 5); + if (fmesa->ffb_sarea->flags & FFB_DRI_PAC2) + strncat(buffer, " PAC2", 5); + +#ifdef USE_SPARC_ASM + strncat(buffer, " Sparc", 6); +#endif + + return (GLubyte *) buffer; + + default: + return NULL; + }; +} + + +static void ffbBufferSize(GLframebuffer *buffer, GLuint *width, GLuint *height) +{ + GET_CURRENT_CONTEXT(ctx); + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + LOCK_HARDWARE(fmesa); + *width = fmesa->driDrawable->w; + *height = fmesa->driDrawable->h; + UNLOCK_HARDWARE(fmesa); +} + +void ffbDDExtensionsInit(GLcontext *ctx) +{ + /* Nothing for now until we start to add + * real acceleration. -DaveM + */ + + /* XXX Need to turn off GL_EXT_blend_func_separate for one. + * XXX Also BlendEquation should be turned off too, what + * XXX EXT is that assosciated with? + */ +} + +static void ffbDDFinish(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + LOCK_HARDWARE(fmesa); + FFBWait(fmesa, fmesa->regs); + UNLOCK_HARDWARE(fmesa); +} + +void ffbDDInitDriverFuncs(GLcontext *ctx) +{ + ctx->Driver.GetBufferSize = ffbBufferSize; + ctx->Driver.GetString = ffbDDGetString; + ctx->Driver.Clear = ffbDDClear; + + ctx->Driver.Finish = ffbDDFinish; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_dd.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_dd.h new file mode 100644 index 000000000..4ffcbe666 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_dd.h @@ -0,0 +1,36 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_dd.h,v 1.1 2000/06/20 05:08:38 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D. + * Copyright (C) 2000 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#ifndef _FFB_DD_H +#define _FFB_DD_H + +#include "context.h" + +void ffbDDInitDriverFuncs(GLcontext *ctx); +void ffbDDExtensionsInit(GLcontext *ctx); + +#endif /* !(_FFB_DD_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_depth.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_depth.c new file mode 100644 index 000000000..68a2450eb --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_depth.c @@ -0,0 +1,245 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_depth.c,v 1.2 2002/02/22 21:32:58 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "mtypes.h" +#include "swrast/swrast.h" +#include "ffb_dd.h" +#include "ffb_span.h" +#include "ffb_context.h" +#include "ffb_depth.h" +#include "ffb_lock.h" + +#include "swrast/swrast.h" + +#undef DEPTH_TRACE + +static void FFBWriteDepthSpan( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, GLint x, GLint y, + const void *values, + const GLubyte mask[] ) +{ + const GLuint *depth = (const GLuint *) values; +#ifdef DEPTH_TRACE + fprintf(stderr, "FFBWriteDepthSpan: n(%d) x(%d) y(%d)\n", + (int) n, x, y); +#endif + if (ctx->Depth.Mask) { + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + GLuint *zptr; + GLuint i; + + if (!fmesa->hw_locked) + LOCK_HARDWARE(fmesa); + FFBFifo(fmesa, 2); + fmesa->regs->fbc = (FFB_FBC_WB_C | FFB_FBC_ZE_ON | + FFB_FBC_YE_OFF | FFB_FBC_RGBE_OFF); + fmesa->regs->ppc = FFB_PPC_ZS_VAR; + FFBWait(fmesa, fmesa->regs); + + y = (dPriv->h - y); + zptr = (GLuint *) + ((char *)fmesa->sfb32 + + ((dPriv->x + x) << 2) + + ((dPriv->y + y) << 13)); + + for (i = 0; i < n; i++) { + if (mask[i]) { + *zptr = Z_FROM_MESA(depth[i]); + } + zptr++; + } + + FFBFifo(fmesa, 2); + fmesa->regs->fbc = fmesa->fbc; + fmesa->regs->ppc = fmesa->ppc; + fmesa->ffbScreen->rp_active = 1; + if (!fmesa->hw_locked) + UNLOCK_HARDWARE(fmesa); + } +} + +static void FFBWriteMonoDepthSpan( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, GLint x, GLint y, + const void *value, const GLubyte mask[] ) +{ + const GLuint depthVal = *((GLuint *) value); + GLuint depths[MAX_WIDTH]; + GLuint i; + for (i = 0; i < n; i++) + depths[i] = depthVal; + FFBWriteDepthSpan(ctx, rb, n, x, y, depths, mask); +} + +static void FFBWriteDepthPixels( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, + const GLint x[], + const GLint y[], + const void *values, + const GLubyte mask[] ) +{ + const GLuint *depth = (const GLuint *) values; +#ifdef DEPTH_TRACE + fprintf(stderr, "FFBWriteDepthPixels: n(%d)\n", (int) n); +#endif + if (ctx->Depth.Mask) { + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + char *zbase; + GLuint i; + + if (!fmesa->hw_locked) + LOCK_HARDWARE(fmesa); + FFBFifo(fmesa, 2); + fmesa->regs->fbc = (FFB_FBC_WB_C | FFB_FBC_ZE_ON | + FFB_FBC_YE_OFF | FFB_FBC_RGBE_OFF); + fmesa->regs->ppc = FFB_PPC_ZS_VAR; + fmesa->ffbScreen->rp_active = 1; + FFBWait(fmesa, fmesa->regs); + + zbase = ((char *)fmesa->sfb32 + + (dPriv->x << 2) + (dPriv->y << 13)); + + for (i = 0; i < n; i++) { + GLint y1 = (dPriv->h - y[i]); + GLint x1 = x[i]; + GLuint *zptr; + + zptr = (GLuint *) + (zbase + (x1 << 2) + (y1 << 13)); + if (mask[i]) + *zptr = Z_FROM_MESA(depth[i]); + } + + FFBFifo(fmesa, 2); + fmesa->regs->fbc = fmesa->fbc; + fmesa->regs->ppc = fmesa->ppc; + fmesa->ffbScreen->rp_active = 1; + if (!fmesa->hw_locked) + UNLOCK_HARDWARE(fmesa); + } +} + +static void FFBReadDepthSpan( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, GLint x, GLint y, + void *values ) +{ + GLuint *depth = (GLuint *) values; + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + GLuint *zptr; + GLuint i; + +#ifdef DEPTH_TRACE + fprintf(stderr, "FFBReadDepthSpan: n(%d) x(%d) y(%d)\n", + (int) n, x, y); +#endif + if (!fmesa->hw_locked) + LOCK_HARDWARE(fmesa); + FFBFifo(fmesa, 1); + fmesa->regs->fbc = FFB_FBC_RB_C; + fmesa->ffbScreen->rp_active = 1; + FFBWait(fmesa, fmesa->regs); + + y = (dPriv->h - y); + zptr = (GLuint *) + ((char *)fmesa->sfb32 + + ((dPriv->x + x) << 2) + + ((dPriv->y + y) << 13)); + + for (i = 0; i < n; i++) { + depth[i] = Z_TO_MESA(*zptr); + zptr++; + } + + FFBFifo(fmesa, 1); + fmesa->regs->fbc = fmesa->fbc; + fmesa->ffbScreen->rp_active = 1; + if (!fmesa->hw_locked) + UNLOCK_HARDWARE(fmesa); +} + +static void FFBReadDepthPixels( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, + const GLint x[], const GLint y[], + void *values ) +{ + GLuint *depth = (GLuint *) values; + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + char *zbase; + GLuint i; + +#ifdef DEPTH_TRACE + fprintf(stderr, "FFBReadDepthPixels: n(%d)\n", (int) n); +#endif + if (!fmesa->hw_locked) + LOCK_HARDWARE(fmesa); + FFBFifo(fmesa, 1); + fmesa->regs->fbc = FFB_FBC_RB_C; + fmesa->ffbScreen->rp_active = 1; + FFBWait(fmesa, fmesa->regs); + + zbase = ((char *)fmesa->sfb32 + + (dPriv->x << 2) + (dPriv->y << 13)); + + for (i = 0; i < n; i++) { + GLint y1 = (dPriv->h - y[i]); + GLint x1 = x[i]; + GLuint *zptr; + + zptr = (GLuint *) + (zbase + (x1 << 2) + (y1 << 13)); + depth[i] = Z_TO_MESA(*zptr); + } + + FFBFifo(fmesa, 1); + fmesa->regs->fbc = fmesa->fbc; + fmesa->ffbScreen->rp_active = 1; + if (!fmesa->hw_locked) + UNLOCK_HARDWARE(fmesa); +} + +/** + * Plug in the Get/Put routines for the given driRenderbuffer. + */ +void +ffbSetDepthFunctions(driRenderbuffer *drb, const GLvisual *vis) +{ + assert(drb->Base.InternalFormat == GL_DEPTH_COMPONENT16); + drb->Base.GetRow = FFBReadDepthSpan; + drb->Base.GetValues = FFBReadDepthPixels; + drb->Base.PutRow = FFBWriteDepthSpan; + drb->Base.PutMonoRow = FFBWriteMonoDepthSpan; + drb->Base.PutValues = FFBWriteDepthPixels; + drb->Base.PutMonoValues = NULL; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_depth.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_depth.h new file mode 100644 index 000000000..db908e7a6 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_depth.h @@ -0,0 +1,8 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_depth.h,v 1.1 2000/06/20 05:08:38 dawes Exp $ */ + +#ifndef _FFB_DEPTH_H +#define _FFB_DEPTH_H + +void ffbSetDepthFunctions(driRenderbuffer *drb, const GLvisual *vis); + +#endif /* !(_FFB_DEPTH_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_fifo.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_fifo.h new file mode 100644 index 000000000..886d71b76 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_fifo.h @@ -0,0 +1,28 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_fifo.h,v 1.2 2002/02/22 21:32:58 dawes Exp $ */ + +#ifndef _FFB_FIFO_H +#define _FFB_FIFO_H + +#define FFBFifo(__fmesa, __n) \ +do { ffbScreenPrivate *__fScrn = (__fmesa)->ffbScreen; \ + int __cur_slots = __fScrn->fifo_cache; \ + if ((__cur_slots - (__n)) < 0) { \ + ffb_fbcPtr __ffb = __fmesa->regs; \ + do { __cur_slots = (((int)__ffb->ucsr & FFB_UCSR_FIFO_MASK) - 4); \ + } while ((__cur_slots - (__n)) < 0); \ + } (__fScrn)->fifo_cache = (__cur_slots - (__n)); \ +} while(0) + +#define FFBWait(__fmesa, __ffb) \ +do { ffbScreenPrivate *__fScrn = (__fmesa)->ffbScreen; \ + if (__fScrn->rp_active) { \ + unsigned int __regval = (__ffb)->ucsr; \ + while((__regval & FFB_UCSR_ALL_BUSY) != 0) { \ + __regval = (__ffb)->ucsr; \ + } \ + __fScrn->fifo_cache = ((int)(__regval & FFB_UCSR_FIFO_MASK)) - 4; \ + __fScrn->rp_active = 0; \ + } \ +} while(0) + +#endif /* !(_FFB_FIFO_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_fog.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_fog.c new file mode 100644 index 000000000..e6eca2390 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_fog.c @@ -0,0 +1,73 @@ + +/* FFB fog support: + * + * There are two levels of support for FOG in the Creator3D series. + * Both involve a depth cue unit and 1 or 4 slope factors and scales + * for varying the pixel intensity. + * + * Chips prior to FFB2 only have a single set of such settings, FFB2 + * and later have 4 settings. + * + * The basic depth cueing equation is: + * + * C_final = dcsf(z) * C_orig + (1 - dcsf(z)) * C_fog + * + * C_final -- The final color passed to blend unit or frame + * buffer (if blending is disabled). + * + * C_orig -- The color we start with, which comes either from + * the raster processor or cpu writes to the smart + * framebuffer aperture. + * + * C_fog -- This is the "fog" color, ie. the desired color + * at the deepest Z. + * + * dcsf(z) -- The depth cue scale as a function of Z. + * + * With pre-FFB2 chips there are four parameters to control the depth + * cue scaling. Here is a diagram: + * + * 1.0 ------------- + * | | | | + * | | | | + * Sfront XXXXX---+---+ + * | |X | | + * dcsf(z) | | X | | + * | | X| | + * Sback +---+---XXXXX + * | | | | + * 0.0 ------------- + * 0.0 Zf Zb 1.0 + * + * z + * Therefore: + * + * for Zf < z < Zb + * + * dcsf(z) = Sback + ((Sfront - Sback) / (Zf - Zb)) * (Zb - z) + * + * for z <= Zf + * + * dcsf(z) = Sfront + * + * for z >= Zb + * + * dcsf(z) = Sback + * + * With FFB2 and later, 3 more slope regions are provided, the first of + * them starts at the end of the region defined above and ends at a + * specified depth value, the next slop region starts there and ends + * at the next specified depth value, and so on. Each of the 3 slope + * regions also have scale and slope settings of their own. + * + * The C_fog color is programmed into the alpha blending unit color1 + * and color2 registers as follows: + * + * color1: -(C_fog) + * color2: C_fog - bg + * + * If alpha blending is disabled, the bg factor is zero. Note that + * the alpha blending color registers specify each of the RGB values + * as 9 bit 1:8 signed numbers in the range -1.00 to 0.ff inclusive. + * (ie. 0x100 == -1.00 and 0x0ff == +0.ff) + */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lines.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lines.c new file mode 100644 index 000000000..da1de18f3 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lines.c @@ -0,0 +1,111 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_lines.c,v 1.2 2002/02/22 21:32:58 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000, 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "mtypes.h" +#include "mm.h" +#include "ffb_dd.h" +#include "ffb_span.h" +#include "ffb_depth.h" +#include "ffb_context.h" +#include "ffb_vb.h" +#include "ffb_lines.h" +#include "ffb_tris.h" +#include "ffb_lock.h" +#include "extensions.h" + +#undef FFB_LINE_TRACE + +#define FFB_LINE_FLAT_BIT 0x01 +#define FFB_LINE_ALPHA_BIT 0x02 +#define MAX_FFB_LINE_FUNCS 0x04 + +static ffb_line_func ffb_line_tab[MAX_FFB_LINE_FUNCS]; + +/* If the line is not wide, we can support all of the line + * patterning and smooth shading features of OpenGL fully. + */ + +#define IND (0) +#define TAG(x) x +#include "ffb_linetmp.h" + +#define IND (FFB_LINE_FLAT_BIT) +#define TAG(x) x##_flat +#include "ffb_linetmp.h" + +#define IND (FFB_LINE_ALPHA_BIT) +#define TAG(x) x##_alpha +#include "ffb_linetmp.h" + +#define IND (FFB_LINE_ALPHA_BIT|FFB_LINE_FLAT_BIT) +#define TAG(x) x##_alpha_flat +#include "ffb_linetmp.h" + +void ffbDDLinefuncInit(void) +{ + init(); + init_flat(); + init_alpha(); + init_alpha_flat(); +} + +static void ffb_dd_line( GLcontext *ctx, GLuint e0, GLuint e1 ) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_vertex *v0 = &fmesa->verts[e0]; + ffb_vertex *v1 = &fmesa->verts[e1]; + fmesa->draw_line( ctx, v0, v1 ); +} + +void ffbChooseLineState(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint flags = ctx->_TriangleCaps; + GLuint ind = 0; + + tnl->Driver.Render.Line = ffb_dd_line; + + if (flags & DD_FLATSHADE) + ind |= FFB_LINE_FLAT_BIT; + + if ((flags & DD_LINE_STIPPLE) != 0 && + fmesa->lpat == FFB_LPAT_BAD) { + fmesa->draw_line = ffb_fallback_line; + return; + } + + /* If blending or the alpha test is enabled we need to + * provide alpha components to the chip, else we can + * do without it and thus feed vertex data to the chip + * more efficiently. + */ + if (ctx->Color.BlendEnabled || ctx->Color.AlphaEnabled) + ind |= FFB_LINE_ALPHA_BIT; + + fmesa->draw_line = ffb_line_tab[ind]; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lines.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lines.h new file mode 100644 index 000000000..d508c243e --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lines.h @@ -0,0 +1,18 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_lines.h,v 1.2 2002/02/22 21:32:58 dawes Exp $ */ + +#ifndef _FFB_LINES_H +#define _FFB_LINES_H + +#include "ffb_context.h" + +#define _FFB_NEW_LINE (_DD_NEW_FLATSHADE | \ + _DD_NEW_LINE_WIDTH | \ + _DD_NEW_LINE_STIPPLE | \ + _DD_NEW_LINE_SMOOTH | \ + _NEW_COLOR) + +extern void ffbDDLinefuncInit(void); +extern void ffbChooseLineState(GLcontext *); +extern void ffb_fallback_line( GLcontext *ctx, ffb_vertex *v0, ffb_vertex *v1 ); + +#endif /* !(_FFB_LINES_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_linetmp.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_linetmp.h new file mode 100644 index 000000000..0951513ca --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_linetmp.h @@ -0,0 +1,81 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_linetmp.h,v 1.2 2002/02/22 21:32:58 dawes Exp $ */ + +static __inline void TAG(ffb_line)(GLcontext *ctx, ffb_vertex *v0, + ffb_vertex *v1 ) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_fbcPtr ffb = fmesa->regs; +#if (IND & FFB_LINE_FLAT_BIT) + const GLuint const_fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR( v1->color[0] ); +#endif + FFB_DELAYED_VIEWPORT_VARS; + +#ifdef FFB_LINE_TRACE + fprintf(stderr, "FFB: ffb_line [" +#if (IND & FFB_LINE_FLAT_BIT) + " FLAT" +#endif +#if (IND & FFB_LINE_ALPHA_BIT) + " ALPHA" +#endif + " ]\n"); +#endif + +#if (IND & FFB_LINE_FLAT_BIT) + FFBFifo(fmesa, 1); + ffb->fg = const_fg; +#ifdef FFB_LINE_TRACE + fprintf(stderr, "FFB: ffb_line confg_fg[%08x]\n", const_fg); +#endif +#endif + +#if (IND & FFB_LINE_FLAT_BIT) + /* (2 * 3) + 1 */ + FFBFifo(fmesa, 7); +#else +#if (IND & FFB_LINE_ALPHA_BIT) + /* (2 * 7) + 1 */ + FFBFifo(fmesa, 15); +#else + /* (2 * 6) + 1 */ + FFBFifo(fmesa, 13); +#endif +#endif + + /* Using DDLINE or AALINE, init the line pattern state. */ + ffb->lpat = fmesa->lpat; + +#if !(IND & FFB_LINE_FLAT_BIT) +#if (IND & FFB_LINE_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v0); +#endif + ffb->red = FFB_GET_RED(v0); + ffb->green = FFB_GET_GREEN(v0); + ffb->blue = FFB_GET_BLUE(v0); +#endif + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + +#if !(IND & FFB_LINE_FLAT_BIT) +#if (IND & FFB_LINE_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v1); +#endif + ffb->red = FFB_GET_RED(v1); + ffb->green = FFB_GET_GREEN(v1); + ffb->blue = FFB_GET_BLUE(v1); +#endif + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(init)(void) +{ + ffb_line_tab[IND] = TAG(ffb_line); +} + +#undef IND +#undef TAG diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lock.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lock.h new file mode 100644 index 000000000..7c49f740f --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lock.h @@ -0,0 +1,37 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_lock.h,v 1.2 2002/02/22 21:32:59 dawes Exp $ */ + +#ifndef _FFB_LOCK_H +#define _FFB_LOCK_H + +#include "ffb_context.h" + +extern void ffbXMesaUpdateState(ffbContextPtr fmesa); +#define FFB_UPDATE_STATE(fmesa) ffbXMesaUpdateState(fmesa) + +/* Lock the hardware and validate our state. This hardware can only ever + * exist on SPARC platforms. Don't bother building the real LOCK_HARDWARE and + * UNLOCK_HARDWARE code on non-SPARC platforms. The only reason the driver + * gets built on non-SPARC is to catch build breakages earlier. + */ +#if !defined(__sparc__) +#define LOCK_HARDWARE(fmesa) +#define UNLOCK_HARDWARE(fmesa) +#else +#define LOCK_HARDWARE(fmesa) \ + do { \ + DRM_CAS_RESULT(__ret); \ + DRM_CAS(fmesa->driHwLock, fmesa->hHWContext, \ + (DRM_LOCK_HELD | fmesa->hHWContext), __ret);\ + if (__ret) { \ + drmGetLock(fmesa->driFd, fmesa->hHWContext, 0); \ + FFB_UPDATE_STATE(fmesa); \ + } \ + } while (0) + + +/* Unlock the hardware. */ +#define UNLOCK_HARDWARE(fmesa) \ + DRM_UNLOCK(fmesa->driFd, fmesa->driHwLock, fmesa->hHWContext); +#endif + +#endif /* !(_FFB_LOCK_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_points.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_points.c new file mode 100644 index 000000000..a7496dd1d --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_points.c @@ -0,0 +1,93 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_points.c,v 1.2 2002/02/22 21:32:59 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000, 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "mtypes.h" +#include "ffb_dd.h" +#include "ffb_context.h" +#include "ffb_vb.h" +#include "ffb_points.h" +#include "ffb_tris.h" +#include "ffb_lock.h" + + +#undef FFB_POINT_TRACE + +#define FFB_POINT_AA_BIT 0x01 + +static ffb_point_func ffb_point_tab[0x08]; + +#define IND (0) +#define TAG(x) x +#include "ffb_pointtmp.h" + +#define IND (FFB_POINT_AA_BIT) +#define TAG(x) x##_aa +#include "ffb_pointtmp.h" + +void ffbDDPointfuncInit(void) +{ + init(); + init_aa(); +} + +static void ffb_dd_points( GLcontext *ctx, GLuint first, GLuint last ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb; + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_vertex *fverts = fmesa->verts; + int i; + + if (VB->Elts == 0) { + for ( i = first ; i < last ; i++ ) { + if ( VB->ClipMask[i] == 0 ) { + fmesa->draw_point( ctx, &fverts[i] ); + } + } + } else { + for ( i = first ; i < last ; i++ ) { + GLuint e = VB->Elts[i]; + if ( VB->ClipMask[e] == 0 ) { + fmesa->draw_point( ctx, &fverts[e] ); + } + } + } +} + +void ffbChoosePointState(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint flags = ctx->_TriangleCaps; + GLuint ind = 0; + + tnl->Driver.Render.Points = ffb_dd_points; + + if (flags & DD_POINT_SMOOTH) + ind |= FFB_POINT_AA_BIT; + + fmesa->draw_point = ffb_point_tab[ind]; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_points.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_points.h new file mode 100644 index 000000000..7d5c1f8a0 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_points.h @@ -0,0 +1,15 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_points.h,v 1.2 2002/02/22 21:32:59 dawes Exp $ */ + +#ifndef _FFB_POINTS_H +#define _FFB_POINTS_H + +extern void ffbDDPointfuncInit(void); + +#define _FFB_NEW_POINT (_DD_NEW_POINT_SIZE | \ + _DD_NEW_POINT_SMOOTH | \ + _NEW_COLOR) + +extern void ffbChoosePointState(GLcontext *); +extern void ffb_fallback_point( GLcontext *ctx, ffb_vertex *v0 ); + +#endif /* !(_FFB_POINTS_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_pointtmp.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_pointtmp.h new file mode 100644 index 000000000..310c95d89 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_pointtmp.h @@ -0,0 +1,55 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_pointtmp.h,v 1.3 2002/02/22 21:32:59 dawes Exp $ */ + +static __inline void TAG(ffb_draw_point)(GLcontext *ctx, ffb_vertex *tmp ) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_fbcPtr ffb = fmesa->regs; + FFB_DELAYED_VIEWPORT_VARS; + +#ifdef FFB_POINT_TRACE + fprintf(stderr, "FFB: ffb_point [" +#if (IND & FFB_POINT_AA_BIT) + "AA" +#endif + "] X(%f) Y(%f) Z(%f)\n", + tmp->x, tmp->y, tmp->z); +#endif + +#if (IND & FFB_POINT_AA_BIT) + FFBFifo(fmesa, 4); + + ffb->fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR( tmp->color[0] ); + ffb->z = FFB_GET_Z(tmp); + ffb->y = FFB_GET_Y(tmp) + 0x8000 /* FIX ME */; + ffb->x = FFB_GET_X(tmp) + 0x8000 /* FIX ME */; +#else + { + unsigned int const_fg, const_z, h, w; + + const_fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR( tmp->color[0] ); + const_z = Z_FROM_MESA(FFB_Z_TO_FLOAT(FFB_GET_Z(tmp))); + h = FFB_GET_Y(tmp) >> 16; + w = FFB_GET_X(tmp) >> 16; +#ifdef FFB_POINT_TRACE + fprintf(stderr, "FFB: ffb_point fg(%08x) z(%08x) h(%08x) w(%08x)\n", + const_fg, const_z, h, w); +#endif + FFBFifo(fmesa, 4); + ffb->fg = const_fg; + ffb->constz = const_z; + ffb->bh = h; + ffb->bw = w; + } +#endif + + fmesa->ffbScreen->rp_active = 1; +} + + +static void TAG(init)(void) +{ + ffb_point_tab[IND] = TAG(ffb_draw_point); +} + +#undef IND +#undef TAG diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_rendertmp.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_rendertmp.h new file mode 100644 index 000000000..26d991b08 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_rendertmp.h @@ -0,0 +1,646 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_rendertmp.h,v 1.2 2003/01/29 23:00:40 dawes Exp $ */ + +#define IMPL_LOCAL_VARS \ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); \ + ffb_fbcPtr ffb = fmesa->regs; \ + const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \ + FFB_DELAYED_VIEWPORT_VARS; \ + (void) fmesa; (void) ffb; (void) elt + +#if (IND & FFB_FLAT_BIT) +#define FFB_DECLARE_CACHED_COLOR(NAME) \ + unsigned int NAME; +#define FFB_COMPUTE_CACHED_COLOR(NAME, VTX) \ + NAME = FFB_PACK_CONST_UBYTE_ARGB_COLOR((VTX)->color[0]) +#define FFB_CACHED_COLOR_SAME(NAME1, NAME2) \ + ((NAME1) == (NAME2)) +#define FFB_CACHED_COLOR_SET(NAME) \ + ffb->fg = (NAME) +#define FFB_CACHED_COLOR_UPDATE(NAME1, NAME2) \ + ffb->fg = (NAME1) = (NAME2) +#define FFB_SET_PRIM_COLOR(COLOR_VERTEX) \ + ffb->fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR((COLOR_VERTEX)->color[0]) +#define FFB_PRIM_COLOR_COST 1 +#define FFB_SET_VERTEX_COLOR(VTX) /**/ +#define FFB_VERTEX_COLOR_COST 0 +#else +#define FFB_DECLARE_CACHED_COLOR(NAME) /**/ +#define FFB_COMPUTE_CACHED_COLOR(NAME, VTX) /**/ +#define FFB_CACHED_COLOR_SAME(NAME1, NAME2) 0 +#define FFB_CACHED_COLOR_SET(NAME1) /**/ +#define FFB_CACHED_COLOR_UPDATE(NAME1, NAME2) /**/ +#define FFB_SET_PRIM_COLOR(COLOR_VERTEX) /**/ +#define FFB_PRIM_COLOR_COST 0 +#if (IND & FFB_ALPHA_BIT) +#define FFB_SET_VERTEX_COLOR(VTX) \ + ffb->alpha = FFB_GET_ALPHA(VTX); \ + ffb->red = FFB_GET_RED(VTX); \ + ffb->green = FFB_GET_GREEN(VTX); \ + ffb->blue = FFB_GET_BLUE(VTX) +#define FFB_VERTEX_COLOR_COST 4 +#else +#define FFB_SET_VERTEX_COLOR(VTX) \ + ffb->red = FFB_GET_RED(VTX); \ + ffb->green = FFB_GET_GREEN(VTX); \ + ffb->blue = FFB_GET_BLUE(VTX) +#define FFB_VERTEX_COLOR_COST 3 +#endif +#endif + +#define RESET_STIPPLE ffb->lpat = fmesa->lpat; + +#if !(IND & (FFB_TRI_CULL_BIT)) +static void TAG(ffb_vb_points)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_POINTS); + if (ctx->_TriangleCaps & DD_POINT_SMOOTH) { + for (i = start; i < count; i++) { + ffb_vertex *v0 = &fmesa->verts[ELT(i)]; + + FFBFifo(fmesa, 4); + ffb->fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR(v0->color[0]); + ffb->z = FFB_GET_Z(v0); + ffb->y = FFB_GET_Y(v0) + 0x8000 /* FIX ME */; + ffb->x = FFB_GET_X(v0) + 0x8000 /* FIX ME */; + } + } else { + for (i = start; i < count; i++) { + ffb_vertex *v0 = &fmesa->verts[ELT(i)]; + FFBFifo(fmesa, 4); + ffb->fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR(v0->color[0]); + ffb->constz = Z_FROM_MESA(FFB_Z_TO_FLOAT(FFB_GET_Z(v0))); + ffb->bh = FFB_GET_Y(v0) >> 16; + ffb->bw = FFB_GET_X(v0) >> 16; + } + } + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(ffb_vb_lines)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_LINES); + for (i = start + 1; i < count; i += 2) { + ffb_vertex *v0 = &fmesa->verts[i - 1]; + ffb_vertex *v1 = &fmesa->verts[i - 0]; + + FFBFifo(fmesa, (1 + FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 2) + 6)); + + RESET_STIPPLE; + + FFB_SET_PRIM_COLOR(v1); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + } +} + +static void TAG(ffb_vb_line_loop)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_LINE_LOOP); + if ((flags & PRIM_BEGIN) != 0) { + ffb_vertex *v0 = &fmesa->verts[ELT(start + 0)]; + ffb_vertex *v1 = &fmesa->verts[ELT(start + 1)]; + + FFBFifo(fmesa, (1 + FFB_PRIM_COLOR_COST + + ((FFB_VERTEX_COLOR_COST * 2) + (3 * 2)))); + + RESET_STIPPLE; + + FFB_SET_PRIM_COLOR(v1); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + } + for (i = start + 2; i < count; i++) { + ffb_vertex *v0 = &fmesa->verts[ELT(i)]; + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST + 3))); + + FFB_SET_PRIM_COLOR(v0); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->y = FFB_GET_Y(v0); + ffb->x = FFB_GET_X(v0); + } + if ((flags & PRIM_END) != 0) { + ffb_vertex *v0 = &fmesa->verts[ELT(start)]; + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST + 3))); + + FFB_SET_PRIM_COLOR(v0); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->y = FFB_GET_Y(v0); + ffb->x = FFB_GET_X(v0); + } + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(ffb_vb_line_strip)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + FFB_DECLARE_CACHED_COLOR(cached_fg) + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_LINE_STRIP); + FFBFifo(fmesa, (1 + FFB_PRIM_COLOR_COST + + ((FFB_VERTEX_COLOR_COST * 2) + (3 * 2)))); + + RESET_STIPPLE; + + { + ffb_vertex *v0 = &fmesa->verts[ELT(start + 0)]; + ffb_vertex *v1 = &fmesa->verts[ELT(start + 1)]; + + FFB_COMPUTE_CACHED_COLOR(cached_fg, v0); + FFB_CACHED_COLOR_SET(cached_fg); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + } + + for (i = start + 2; i < count; i++) { + ffb_vertex *v1 = &fmesa->verts[ELT(i - 0)]; + FFB_DECLARE_CACHED_COLOR(new_fg) + + FFB_COMPUTE_CACHED_COLOR(new_fg, v1); + if (FFB_CACHED_COLOR_SAME(cached_fg, new_fg)) { + FFBFifo(fmesa, ((FFB_VERTEX_COLOR_COST * 1) + (3 * 1))); + } else { + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 1) + (3 * 1))); + FFB_CACHED_COLOR_UPDATE(cached_fg, new_fg); + } + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + } + + fmesa->ffbScreen->rp_active = 1; +} +#endif /* !(IND & (FFB_TRI_CULL_BIT)) */ + +/* OK, now things start getting fun :-) */ +#if (IND & (FFB_TRI_CULL_BIT)) +#define FFB_AREA_DECLARE GLfloat cc, ex, ey, fx, fy; +#define FFB_COMPUTE_AREA_TRI(V0, V1, V2) \ +{ ex = (V1)->x - (V0)->x; \ + ey = (V1)->y - (V0)->y; \ + fx = (V2)->x - (V0)->x; \ + fy = (V2)->y - (V0)->y; \ + cc = ex*fy-ey*fx; \ +} +#define FFB_COMPUTE_AREA_QUAD(V0, V1, V2, V3) \ +{ ex = (V2)->x - (V0)->x; \ + ey = (V2)->y - (V0)->y; \ + fx = (V3)->x - (V1)->x; \ + fy = (V3)->y - (V1)->y; \ + cc = ex*fy-ey*fx; \ +} +#else +#define FFB_AREA_DECLARE /**/ +#define FFB_COMPUTE_AREA_TRI(V0, V1, V2) do { } while(0) +#define FFB_COMPUTE_AREA_QUAD(V0, V1, V2, V3) do { } while(0) +#endif + +#if (IND & FFB_TRI_CULL_BIT) +#define FFB_CULL_TRI(CULL_ACTION) \ + if (cc * fmesa->backface_sign > fmesa->ffb_zero) { \ + CULL_ACTION \ + } +#define FFB_CULL_QUAD(CULL_ACTION) \ + if (cc * fmesa->backface_sign > fmesa->ffb_zero) { \ + CULL_ACTION \ + } +#else +#define FFB_CULL_TRI(CULL_ACTION) do { } while (0) +#define FFB_CULL_QUAD(CULL_ACTION) do { } while (0) +#endif + +static void TAG(ffb_vb_triangles)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_TRIANGLES); + for (i = start + 2; i < count; i += 3) { + ffb_vertex *v0 = &fmesa->verts[ELT(i - 2)]; + ffb_vertex *v1 = &fmesa->verts[ELT(i - 1)]; + ffb_vertex *v2 = &fmesa->verts[ELT(i - 0)]; + FFB_AREA_DECLARE + + FFB_COMPUTE_AREA_TRI(v0, v1, v2); + FFB_CULL_TRI(continue;); + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 3) + 9)); + FFB_SET_PRIM_COLOR(v2); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + FFB_SET_VERTEX_COLOR(v2); + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + } + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(ffb_vb_tri_strip)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + GLint parity = 0; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_TRIANGLE_STRIP); + + i = start + 2; + goto something_clipped; + + something_clipped: + for (; i < count; i++, parity ^= 1) { + ffb_vertex *v0 = &fmesa->verts[ELT(i - 2 + parity)]; + ffb_vertex *v1 = &fmesa->verts[ELT(i - 1 - parity)]; + ffb_vertex *v2 = &fmesa->verts[ELT(i - 0)]; + FFB_AREA_DECLARE + + FFB_COMPUTE_AREA_TRI(v0, v1, v2); + FFB_CULL_TRI(continue;); + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 3) + 9)); + FFB_SET_PRIM_COLOR(v2); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + FFB_SET_VERTEX_COLOR(v2); + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + + i++; + parity ^= 1; + break; + } + + for (; i < count; i++, parity ^= 1) { + ffb_vertex *v0 = &fmesa->verts[ELT(i - 2 + parity)]; + ffb_vertex *v1 = &fmesa->verts[ELT(i - 1 - parity)]; + ffb_vertex *v2 = &fmesa->verts[ELT(i - 0)]; + FFB_AREA_DECLARE + (void) v0; (void) v1; + + FFB_COMPUTE_AREA_TRI(v0, v1, v2); + FFB_CULL_TRI(i++; parity^=1; goto something_clipped;); + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 1) + 3)); + FFB_SET_PRIM_COLOR(v2); + + FFB_SET_VERTEX_COLOR(v2); + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + } + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(ffb_vb_tri_fan)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_TRIANGLE_FAN); + + i = start + 2; + goto something_clipped; + + something_clipped: + for ( ; i < count; i++) { + ffb_vertex *v0 = &fmesa->verts[ELT(start)]; + ffb_vertex *v1 = &fmesa->verts[ELT(i - 1)]; + ffb_vertex *v2 = &fmesa->verts[ELT(i - 0)]; + FFB_AREA_DECLARE + + FFB_COMPUTE_AREA_TRI(v0, v1, v2); + FFB_CULL_TRI(continue;); + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 3) + 9)); + FFB_SET_PRIM_COLOR(v2); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + FFB_SET_VERTEX_COLOR(v2); + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + + i++; + break; + } + + for (; i < count; i++) { + ffb_vertex *v0 = &fmesa->verts[ELT(start)]; + ffb_vertex *v1 = &fmesa->verts[ELT(i - 1)]; + ffb_vertex *v2 = &fmesa->verts[ELT(i - 0)]; + FFB_AREA_DECLARE + (void) v0; (void) v1; + + FFB_COMPUTE_AREA_TRI(v0, v1, v2); + FFB_CULL_TRI(i++; goto something_clipped;); + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 1) + 3)); + FFB_SET_PRIM_COLOR(v2); + + FFB_SET_VERTEX_COLOR(v2); + ffb->z = FFB_GET_Z(v2); + ffb->dmyf = FFB_GET_Y(v2); + ffb->dmxf = FFB_GET_X(v2); + } + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(ffb_vb_poly)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_POLYGON); + + /* XXX Optimize XXX */ + for (i = start + 2; i < count; i++) { + ffb_vertex *v0 = &fmesa->verts[ELT(i - 1)]; + ffb_vertex *v1 = &fmesa->verts[ELT(i)]; + ffb_vertex *v2 = &fmesa->verts[ELT(start)]; + FFB_AREA_DECLARE + + FFB_COMPUTE_AREA_TRI(v0, v1, v2); + FFB_CULL_TRI(continue;); + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 3) + 9)); + FFB_SET_PRIM_COLOR(v2); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + FFB_SET_VERTEX_COLOR(v2); + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + } + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(ffb_vb_quads)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_QUADS); + + for (i = start + 3; i < count; i += 4) { + ffb_vertex *v0 = &fmesa->verts[ELT(i - 3)]; + ffb_vertex *v1 = &fmesa->verts[ELT(i - 2)]; + ffb_vertex *v2 = &fmesa->verts[ELT(i - 1)]; + ffb_vertex *v3 = &fmesa->verts[ELT(i - 0)]; + FFB_AREA_DECLARE + + FFB_COMPUTE_AREA_QUAD(v0, v1, v2, v3); + FFB_CULL_QUAD(continue;); + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 4) + 12)); + FFB_SET_PRIM_COLOR(v3); + + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + FFB_SET_VERTEX_COLOR(v2); + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + + FFB_SET_VERTEX_COLOR(v3); + ffb->z = FFB_GET_Z(v3); + ffb->dmyf = FFB_GET_Y(v3); + ffb->dmxf = FFB_GET_X(v3); + } + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(ffb_vb_quad_strip)(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + GLint i; + IMPL_LOCAL_VARS; + +#ifdef FFB_RENDER_TRACE + fprintf(stderr, "%s: start(%d) count(%d) flags(%x)\n", + __FUNCTION__, start, count, flags); +#endif + ffbRenderPrimitive(ctx, GL_QUAD_STRIP); + + /* XXX Optimize XXX */ + for (i = start + 3; i < count; i += 2) { + ffb_vertex *v0 = &fmesa->verts[ELT(i - 1)]; + ffb_vertex *v1 = &fmesa->verts[ELT(i - 3)]; + ffb_vertex *v2 = &fmesa->verts[ELT(i - 2)]; + ffb_vertex *v3 = &fmesa->verts[ELT(i - 0)]; + FFB_AREA_DECLARE + + FFB_COMPUTE_AREA_QUAD(v0, v1, v2, v3); + FFB_CULL_QUAD(continue;); + + FFBFifo(fmesa, (FFB_PRIM_COLOR_COST + + (FFB_VERTEX_COLOR_COST * 4) + 12)); + FFB_SET_PRIM_COLOR(v3); + + FFB_DUMP_VERTEX(v0); + FFB_SET_VERTEX_COLOR(v0); + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_DUMP_VERTEX(v1); + FFB_SET_VERTEX_COLOR(v1); + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + FFB_DUMP_VERTEX(v2); + FFB_SET_VERTEX_COLOR(v2); + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + + FFB_DUMP_VERTEX(v3); + FFB_SET_VERTEX_COLOR(v3); + ffb->z = FFB_GET_Z(v3); + ffb->dmyf = FFB_GET_Y(v3); + ffb->dmxf = FFB_GET_X(v3); + } + + fmesa->ffbScreen->rp_active = 1; +} + +static void (*TAG(render_tab)[GL_POLYGON + 2])(GLcontext *, GLuint, GLuint, GLuint) = +{ +#if !(IND & (FFB_TRI_CULL_BIT)) + TAG(ffb_vb_points), + TAG(ffb_vb_lines), + TAG(ffb_vb_line_loop), + TAG(ffb_vb_line_strip), +#else + NULL, + NULL, + NULL, + NULL, +#endif + TAG(ffb_vb_triangles), + TAG(ffb_vb_tri_strip), + TAG(ffb_vb_tri_fan), + TAG(ffb_vb_quads), + TAG(ffb_vb_quad_strip), + TAG(ffb_vb_poly), + ffb_vb_noop, +}; + +#undef IND +#undef TAG + +#undef IMPL_LOCAL_VARS +#undef FFB_DECLARE_CACHED_COLOR +#undef FFB_COMPUTE_CACHED_COLOR +#undef FFB_CACHED_COLOR_SAME +#undef FFB_CACHED_COLOR_SET +#undef FFB_CACHED_COLOR_UPDATE +#undef FFB_SET_PRIM_COLOR +#undef FFB_PRIM_COLOR_COST +#undef FFB_SET_VERTEX_COLOR +#undef FFB_VERTEX_COLOR_COST +#undef RESET_STIPPLE +#undef FFB_AREA_DECLARE +#undef FFB_COMPUTE_AREA_TRI +#undef FFB_COMPUTE_AREA_QUAD +#undef FFB_CULL_TRI +#undef FFB_CULL_QUAD diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_span.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_span.c new file mode 100644 index 000000000..f4698c64e --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_span.c @@ -0,0 +1,135 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_span.c,v 1.2 2002/02/22 21:32:59 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "mtypes.h" +#include "ffb_dd.h" +#include "ffb_span.h" +#include "ffb_context.h" +#include "ffb_lock.h" + +#include "swrast/swrast.h" + +#define DBG 0 + +#define HW_LOCK() \ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); \ + if (!fmesa->hw_locked) \ + LOCK_HARDWARE(fmesa); + +#define HW_UNLOCK() \ + if (!fmesa->hw_locked) \ + UNLOCK_HARDWARE(fmesa); \ + +#define LOCAL_VARS \ + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; \ + GLuint height = dPriv->h; \ + GLuint p; \ + char *buf; \ + (void) p + +#define INIT_MONO_PIXEL(p, color) \ + p = ((color[0] << 0) | \ + (color[1] << 8) | \ + (color[2] << 16)) + +/* We use WID clipping, so this test always passes. */ +#define CLIPPIXEL(__x, __y) (1) + +/* And also, due to WID clipping, we need not do anything + * special here. + */ +#define CLIPSPAN(__x,__y,__n,__x1,__n1,__i) \ + __n1 = __n; \ + __x1 = __x; \ + +#define HW_CLIPLOOP() \ +do { unsigned int fbc, ppc, cmp; \ + FFBWait(fmesa, fmesa->regs); \ + fbc = fmesa->regs->fbc; ppc = fmesa->regs->ppc; cmp = fmesa->regs->cmp; \ + fmesa->regs->fbc = ((fbc & \ + ~(FFB_FBC_WB_C | FFB_FBC_ZE_MASK | FFB_FBC_RGBE_MASK)) \ + | (FFB_FBC_ZE_OFF | FFB_FBC_RGBE_MASK)); \ + fmesa->regs->ppc = ((ppc & \ + ~(FFB_PPC_XS_MASK | FFB_PPC_ABE_MASK | FFB_PPC_DCE_MASK | \ + FFB_PPC_APE_MASK | FFB_PPC_CS_MASK)) \ + | (FFB_PPC_XS_WID | FFB_PPC_ABE_DISABLE | \ + FFB_PPC_DCE_DISABLE | FFB_PPC_APE_DISABLE | \ + FFB_PPC_CS_VAR)); \ + fmesa->regs->cmp = ((cmp & ~(0xff << 16)) | (0x80 << 16)); \ + fmesa->ffbScreen->rp_active = 1; \ + FFBWait(fmesa, fmesa->regs); \ + buf = (char *)(fmesa->sfb32 + (dPriv->x << 2) + (dPriv->y << 13));\ + if (dPriv->numClipRects) { + +#define HW_ENDCLIPLOOP() \ + } \ + fmesa->regs->fbc = fbc; \ + fmesa->regs->ppc = ppc; \ + fmesa->regs->cmp = cmp; \ + fmesa->ffbScreen->rp_active = 1; \ +} while(0) + +#define Y_FLIP(__y) (height - __y) + +#define READ_RGBA(rgba,__x,__y) \ +do { GLuint p = *(GLuint *)(buf + ((__x)<<2) + ((__y)<<13)); \ + rgba[0] = (p >> 0) & 0xff; \ + rgba[1] = (p >> 8) & 0xff; \ + rgba[2] = (p >> 16) & 0xff; \ + rgba[3] = 0xff; \ +} while(0) + +#define WRITE_RGBA(__x, __y, __r, __g, __b, __a) \ + *(GLuint *)(buf + ((__x)<<2) + ((__y)<<13)) = \ + ((((__r) & 0xff) << 0) | \ + (((__g) & 0xff) << 8) | \ + (((__b) & 0xff) << 16)) + +#define WRITE_PIXEL(__x, __y, __p) \ + *(GLuint *)(buf + ((__x)<<2) + ((__y)<<13)) = (__p) + +#define TAG(x) ffb##x##_888 + +#include <spantmp.h> + +/** + * Plug in the Get/Put routines for the given driRenderbuffer. + */ +void +ffbSetSpanFunctions(driRenderbuffer *drb, const GLvisual *vis) +{ + assert(vis->redBits == 8); + assert(vis->greenBits == 8); + assert(vis->blueBits == 8); + drb->Base.GetRow = ffbReadRGBASpan_888; + drb->Base.GetValues = ffbReadRGBAPixels_888; + drb->Base.PutRow = ffbWriteRGBASpan_888; + drb->Base.PutRowRGB = ffbWriteRGBSpan_888; + drb->Base.PutMonoRow = ffbWriteMonoRGBASpan_888; + drb->Base.PutValues = ffbWriteRGBAPixels_888; + drb->Base.PutMonoValues = ffbWriteMonoRGBAPixels_888; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_span.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_span.h new file mode 100644 index 000000000..5ae227910 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_span.h @@ -0,0 +1,10 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_span.h,v 1.1 2000/06/20 05:08:39 dawes Exp $ */ + +#ifndef _FFB_SPAN_H +#define _FFB_SPAN_H + +#include "drirenderbuffer.h" + +void ffbSetSpanFunctions(driRenderbuffer *drb, const GLvisual *vis); + +#endif /* !(_FFB_SPAN_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_state.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_state.c new file mode 100644 index 000000000..86df5b4bc --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_state.c @@ -0,0 +1,1223 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_state.c,v 1.5 2002/10/30 12:51:27 alanh Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000, 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "mtypes.h" +#include "buffers.h" +#include "colormac.h" +#include "mm.h" +#include "ffb_dd.h" +#include "ffb_span.h" +#include "ffb_depth.h" +#include "ffb_context.h" +#include "ffb_vb.h" +#include "ffb_tris.h" +#include "ffb_state.h" +#include "ffb_lock.h" +#include "extensions.h" +#include "enums.h" + +#include "swrast/swrast.h" +#include "array_cache/acache.h" +#include "tnl/tnl.h" +#include "swrast_setup/swrast_setup.h" + +#include "tnl/t_pipeline.h" + +#undef STATE_TRACE + +static unsigned int ffbComputeAlphaFunc(GLcontext *ctx) +{ + unsigned int xclip; + GLubyte alphaRef; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDAlphaFunc: func(%s) ref(%02x)\n", + _mesa_lookup_enum_by_nr(ctx->Color.AlphaFunc), + ctx->Color.AlphaRef & 0xff); +#endif + + switch (ctx->Color.AlphaFunc) { + case GL_NEVER: xclip = FFB_XCLIP_TEST_NEVER; break; + case GL_LESS: xclip = FFB_XCLIP_TEST_LT; break; + case GL_EQUAL: xclip = FFB_XCLIP_TEST_EQ; break; + case GL_LEQUAL: xclip = FFB_XCLIP_TEST_LE; break; + case GL_GREATER: xclip = FFB_XCLIP_TEST_GT; break; + case GL_NOTEQUAL: xclip = FFB_XCLIP_TEST_NE; break; + case GL_GEQUAL: xclip = FFB_XCLIP_TEST_GE; break; + case GL_ALWAYS: xclip = FFB_XCLIP_TEST_ALWAYS; break; + + default: + return FFB_XCLIP_TEST_ALWAYS | 0x00; + } + + CLAMPED_FLOAT_TO_UBYTE(alphaRef, ctx->Color.AlphaRef); + xclip |= (alphaRef & 0xff); + + return xclip; +} + +static void ffbDDAlphaFunc(GLcontext *ctx, GLenum func, GLfloat ref) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + if (ctx->Color.AlphaEnabled) { + unsigned int xclip = ffbComputeAlphaFunc(ctx); + + if (fmesa->xclip != xclip) { + fmesa->xclip = xclip; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_XCLIP, 1); + } + } +} + +static void ffbDDBlendEquationSeparate(GLcontext *ctx, + GLenum modeRGB, GLenum modeA) +{ + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDBlendEquation: mode(%s)\n", + _mesa_lookup_enum_by_nr(modeRGB)); +#endif + assert( modeRGB == modeA ); + FALLBACK( ctx, (modeRGB != GL_FUNC_ADD), FFB_BADATTR_BLENDEQN); +} + +static void ffbDDBlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB, + GLenum dfactorRGB, GLenum sfactorA, + GLenum dfactorA) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + unsigned int blendc = 1 << 4; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDBlendFuncSeparate: sRGB(%s) dRGB(%s) sA(%s) dA(%s)\n", + _mesa_lookup_enum_by_nr(sfactorRGB), + _mesa_lookup_enum_by_nr(dfactorRGB), + _mesa_lookup_enum_by_nr(sfactorA), + _mesa_lookup_enum_by_nr(dfactorA)); +#endif + switch (ctx->Color.BlendSrcRGB) { + case GL_ZERO: + blendc |= (0 << 0); + break; + + case GL_ONE: + blendc |= (1 << 0); + break; + + case GL_ONE_MINUS_SRC_ALPHA: + blendc |= (2 << 0); + break; + + case GL_SRC_ALPHA: + blendc |= (3 << 0); + break; + + default: + if (ctx->Color.BlendEnabled) + FALLBACK( ctx, FFB_BADATTR_BLENDFUNC, GL_TRUE ); + return; + }; + + switch (ctx->Color.BlendDstRGB) { + case GL_ZERO: + blendc |= (0 << 2); + break; + + case GL_ONE: + blendc |= (1 << 2); + break; + + case GL_ONE_MINUS_SRC_ALPHA: + blendc |= (2 << 2); + break; + + case GL_SRC_ALPHA: + blendc |= (3 << 2); + break; + + default: + if (ctx->Color.BlendEnabled) + FALLBACK( ctx, FFB_BADATTR_BLENDFUNC, GL_TRUE ); + return; + }; + + if (ctx->Color.BlendEnabled && + ctx->Color.ColorLogicOpEnabled && + ctx->Color.LogicOp != GL_COPY) { + /* We could avoid this if sfactor is GL_ONE and + * dfactor is GL_ZERO. I do not think that is even + * worthwhile to check because if someone is using + * blending they use more interesting settings and + * also it would add more state tracking to a lot + * of the code in this file. + */ + FALLBACK(ctx, FFB_BADATTR_BLENDROP, GL_TRUE); + return; + } + + FALLBACK( ctx, (FFB_BADATTR_BLENDFUNC|FFB_BADATTR_BLENDROP), GL_FALSE ); + + if (blendc != fmesa->blendc) { + fmesa->blendc = blendc; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_BLEND, 1); + } +} + +static void ffbDDDepthFunc(GLcontext *ctx, GLenum func) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLuint cmp; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDDepthFunc: func(%s)\n", + _mesa_lookup_enum_by_nr(func)); +#endif + + switch (func) { + case GL_NEVER: + cmp = FFB_CMP_MAGN_NEVER; + break; + case GL_ALWAYS: + cmp = FFB_CMP_MAGN_ALWAYS; + break; + case GL_LESS: + cmp = FFB_CMP_MAGN_LT; + break; + case GL_LEQUAL: + cmp = FFB_CMP_MAGN_LE; + break; + case GL_EQUAL: + cmp = FFB_CMP_MAGN_EQ; + break; + case GL_GREATER: + cmp = FFB_CMP_MAGN_GT; + break; + case GL_GEQUAL: + cmp = FFB_CMP_MAGN_GE; + break; + case GL_NOTEQUAL: + cmp = FFB_CMP_MAGN_NE; + break; + default: + return; + }; + + if (! ctx->Depth.Test) + cmp = FFB_CMP_MAGN_ALWAYS; + + cmp <<= 16; + cmp = (fmesa->cmp & ~(0xff<<16)) | cmp; + if (cmp != fmesa->cmp) { + fmesa->cmp = cmp; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_CMP, 1); + } +} + +static void ffbDDDepthMask(GLcontext *ctx, GLboolean flag) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLuint fbc = fmesa->fbc; + GLboolean enabled_now; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDDepthMask: flag(%d)\n", flag); +#endif + + if ((fbc & FFB_FBC_ZE_MASK) == FFB_FBC_ZE_OFF) + enabled_now = GL_FALSE; + else + enabled_now = GL_TRUE; + + if (flag != enabled_now) { + fbc &= ~FFB_FBC_ZE_MASK; + if (flag) { + fbc |= FFB_FBC_WB_C | FFB_FBC_ZE_ON; + } else { + fbc |= FFB_FBC_ZE_OFF; + fbc &= ~FFB_FBC_WB_C; + } + fmesa->fbc = fbc; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_FBC, 1); + } +} + +static void ffbDDStencilFunc(GLcontext *ctx, GLenum func, GLint ref, GLuint mask) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + unsigned int stencil, stencilctl, consty; + + /* We will properly update sw/hw state when stenciling is + * enabled. + */ + if (! ctx->Stencil.Enabled) + return; + + stencilctl = fmesa->stencilctl; + stencilctl &= ~(7 << 16); + + switch (func) { + case GL_ALWAYS: stencilctl |= (0 << 16); break; + case GL_GREATER: stencilctl |= (1 << 16); break; + case GL_EQUAL: stencilctl |= (2 << 16); break; + case GL_GEQUAL: stencilctl |= (3 << 16); break; + case GL_NEVER: stencilctl |= (4 << 16); break; + case GL_LEQUAL: stencilctl |= (5 << 16); break; + case GL_NOTEQUAL: stencilctl |= (6 << 16); break; + case GL_LESS: stencilctl |= (7 << 16); break; + + default: + return; + }; + + consty = ref & 0xf; + + stencil = fmesa->stencil; + stencil &= ~(0xf << 20); + stencil |= (mask & 0xf) << 20; + + if (fmesa->stencil != stencil || + fmesa->stencilctl != stencilctl || + fmesa->consty != consty) { + fmesa->stencil = stencil; + fmesa->stencilctl = stencilctl; + fmesa->consty = consty; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_STENCIL, 6); + } +} + +static void ffbDDStencilMask(GLcontext *ctx, GLuint mask) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + mask &= 0xf; + if (fmesa->ypmask != mask) { + fmesa->ypmask = mask; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_YPMASK, 1); + } +} + +static void ffbDDStencilOp(GLcontext *ctx, GLenum fail, GLenum zfail, GLenum zpass) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + unsigned int stencilctl; + + /* We will properly update sw/hw state when stenciling is + * enabled. + */ + if (! ctx->Stencil.Enabled) + return; + + stencilctl = fmesa->stencilctl; + stencilctl &= ~(0xfff00000); + + switch (fail) { + case GL_ZERO: stencilctl |= (0 << 28); break; + case GL_KEEP: stencilctl |= (1 << 28); break; + case GL_INVERT: stencilctl |= (2 << 28); break; + case GL_REPLACE: stencilctl |= (3 << 28); break; + case GL_INCR: stencilctl |= (4 << 28); break; + case GL_DECR: stencilctl |= (5 << 28); break; + + default: + return; + }; + + switch (zfail) { + case GL_ZERO: stencilctl |= (0 << 24); break; + case GL_KEEP: stencilctl |= (1 << 24); break; + case GL_INVERT: stencilctl |= (2 << 24); break; + case GL_REPLACE: stencilctl |= (3 << 24); break; + case GL_INCR: stencilctl |= (4 << 24); break; + case GL_DECR: stencilctl |= (5 << 24); break; + + default: + return; + }; + + switch (zpass) { + case GL_ZERO: stencilctl |= (0 << 20); break; + case GL_KEEP: stencilctl |= (1 << 20); break; + case GL_INVERT: stencilctl |= (2 << 20); break; + case GL_REPLACE: stencilctl |= (3 << 20); break; + case GL_INCR: stencilctl |= (4 << 20); break; + case GL_DECR: stencilctl |= (5 << 20); break; + + default: + return; + }; + + if (fmesa->stencilctl != stencilctl) { + fmesa->stencilctl = stencilctl; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_STENCIL, 6); + } +} + +static void ffbCalcViewportRegs(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + GLuint xmin, xmax, ymin, ymax, zmin, zmax; + unsigned int vcmin, vcmax; + + xmin = ctx->Viewport.X + dPriv->x; + xmax = xmin + ctx->Viewport.Width; + ymax = dPriv->y + dPriv->h - ctx->Viewport.Y; + ymin = ymax - ctx->Viewport.Height; + if (ctx->Scissor.Enabled) { + GLuint sc_xmin, sc_xmax, sc_ymin, sc_ymax; + + sc_xmin = ctx->Viewport.X + dPriv->x; + sc_xmax = sc_xmin + ctx->Viewport.Width; + sc_ymax = dPriv->y + dPriv->h - ctx->Viewport.Y; + sc_ymin = sc_ymax - ctx->Viewport.Height; + if (sc_xmin > xmin) + xmin = sc_xmin; + if (sc_xmax < xmax) + xmax = sc_xmax; + if (sc_ymin > ymin) + ymin = sc_ymin; + if (sc_ymax < ymax) + ymax = sc_ymax; + } + zmin = ((GLdouble)ctx->Viewport.Near * 0x0fffffff); + zmax = ((GLdouble)ctx->Viewport.Far * 0x0fffffff); + + vcmin = ((ymin & 0xffff) << 16) | (xmin & 0xffff); + vcmax = ((ymax & 0xffff) << 16) | (xmax & 0xffff); + if (fmesa->vclipmin != vcmin || + fmesa->vclipmax != vcmax || + fmesa->vclipzmin != zmin || + fmesa->vclipzmax != zmax) { + fmesa->vclipmin = vcmin; + fmesa->vclipmax = vcmax; + fmesa->vclipzmin = zmin; + fmesa->vclipzmax = zmax; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_CLIP, (4 + (4 * 2))); + } +} + +void ffbCalcViewport(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + const GLfloat *v = ctx->Viewport._WindowMap.m; + GLfloat *m = fmesa->hw_viewport; + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + + m[MAT_SX] = v[MAT_SX]; + m[MAT_TX] = v[MAT_TX] + dPriv->x + SUBPIXEL_X; + m[MAT_SY] = - v[MAT_SY]; + m[MAT_TY] = - v[MAT_TY] + dPriv->h + dPriv->y + SUBPIXEL_Y; + m[MAT_SZ] = v[MAT_SZ] * ((GLdouble)1.0 / (GLdouble)0x0fffffff); + m[MAT_TZ] = v[MAT_TZ] * ((GLdouble)1.0 / (GLdouble)0x0fffffff); + + fmesa->depth_scale = ((GLdouble)1.0 / (GLdouble)0x0fffffff); + + ffbCalcViewportRegs(ctx); + + fmesa->setupnewinputs |= VERT_BIT_POS; +} + +static void ffbDDViewport(GLcontext *ctx, GLint x, GLint y, + GLsizei width, GLsizei height) +{ + /* update size of Mesa/software ancillary buffers */ + _mesa_ResizeBuffersMESA(); + ffbCalcViewport(ctx); +} + +static void ffbDDDepthRange(GLcontext *ctx, GLclampd nearval, GLclampd farval) +{ + ffbCalcViewport(ctx); +} + +static void ffbDDScissor(GLcontext *ctx, GLint cx, GLint cy, + GLsizei cw, GLsizei ch) +{ + ffbCalcViewport(ctx); +} + +static void ffbDDDrawBuffer(GLcontext *ctx, GLenum buffer) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + unsigned int fbc = fmesa->fbc; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDDrawBuffer: mode(%s)\n", + _mesa_lookup_enum_by_nr(buffer)); +#endif + fbc &= ~(FFB_FBC_WB_AB | FFB_FBC_RB_MASK); + switch (buffer) { + case GL_FRONT: + if (fmesa->back_buffer == 0) + fbc |= FFB_FBC_WB_B | FFB_FBC_RB_B; + else + fbc |= FFB_FBC_WB_A | FFB_FBC_RB_A; + break; + + case GL_BACK: + if (fmesa->back_buffer == 0) + fbc |= FFB_FBC_WB_A | FFB_FBC_RB_A; + else + fbc |= FFB_FBC_WB_B | FFB_FBC_RB_B; + break; + + case GL_FRONT_AND_BACK: + fbc |= FFB_FBC_WB_AB; + break; + + default: + return; + }; + + if (fbc != fmesa->fbc) { + fmesa->fbc = fbc; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_FBC, 1); + } +} + + +static void ffbDDReadBuffer(GLcontext *ctx, GLenum buffer) +{ + /* no-op, unless you implement h/w glRead/CopyPixels */ +} + + +/* + * Specifies buffer for sw fallbacks (spans) + */ +static void ffbDDSetBuffer(GLcontext *ctx, GLframebuffer *colorBuffer, + GLuint bufferBit) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + unsigned int fbc = fmesa->fbc; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDSetReadBuffer: mode(%s)\n", + _mesa_lookup_enum_by_nr(buffer)); +#endif + fbc &= ~(FFB_FBC_RB_MASK); + switch (bufferBit) { + case BUFFER_BIT_FRONT_LEFT: + if (fmesa->back_buffer == 0) + fbc |= FFB_FBC_RB_B; + else + fbc |= FFB_FBC_RB_A; + break; + + case BUFFER_BIT_BACK_LEFT: + if (fmesa->back_buffer == 0) + fbc |= FFB_FBC_RB_A; + else + fbc |= FFB_FBC_RB_B; + break; + + default: + _mesa_problem(ctx, "Unexpected buffer in ffbDDSetBuffer()"); + return; + }; + + if (fbc != fmesa->fbc) { + fmesa->fbc = fbc; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_FBC, 1); + } +} + +static void ffbDDClearColor(GLcontext *ctx, const GLfloat color[4]) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLubyte c[4]; + CLAMPED_FLOAT_TO_UBYTE(c[0], color[0]); + CLAMPED_FLOAT_TO_UBYTE(c[1], color[1]); + CLAMPED_FLOAT_TO_UBYTE(c[2], color[2]); + + fmesa->clear_pixel = ((c[0] << 0) | + (c[1] << 8) | + (c[2] << 16)); +} + +static void ffbDDClearDepth(GLcontext *ctx, GLclampd depth) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + fmesa->clear_depth = Z_FROM_MESA(depth * 4294967295.0f); +} + +static void ffbDDClearStencil(GLcontext *ctx, GLint stencil) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + fmesa->clear_stencil = stencil & 0xf; +} + +/* XXX Actually, should I be using FBC controls for this? -DaveM */ +static void ffbDDColorMask(GLcontext *ctx, + GLboolean r, GLboolean g, + GLboolean b, GLboolean a) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + unsigned int new_pmask = 0x0; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDColorMask: r(%d) g(%d) b(%d) a(%d)\n", + r, g, b, a); +#endif + if (r) + new_pmask |= 0x000000ff; + if (g) + new_pmask |= 0x0000ff00; + if (b) + new_pmask |= 0x00ff0000; + if (a) + new_pmask |= 0xff000000; + + if (fmesa->pmask != new_pmask) { + fmesa->pmask = new_pmask; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_PMASK, 1); + } +} + +static void ffbDDLogicOp(GLcontext *ctx, GLenum op) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + unsigned int rop; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDLogicOp: op(%s)\n", + _mesa_lookup_enum_by_nr(op)); +#endif + switch (op) { + case GL_CLEAR: rop = FFB_ROP_ZERO; break; + case GL_SET: rop = FFB_ROP_ONES; break; + case GL_COPY: rop = FFB_ROP_NEW; break; + case GL_AND: rop = FFB_ROP_NEW_AND_OLD; break; + case GL_NAND: rop = FFB_ROP_NEW_AND_NOLD; break; + case GL_OR: rop = FFB_ROP_NEW_OR_OLD; break; + case GL_NOR: rop = FFB_ROP_NEW_OR_NOLD; break; + case GL_XOR: rop = FFB_ROP_NEW_XOR_OLD; break; + case GL_NOOP: rop = FFB_ROP_OLD; break; + case GL_COPY_INVERTED: rop = FFB_ROP_NNEW; break; + case GL_INVERT: rop = FFB_ROP_NOLD; break; + case GL_EQUIV: rop = FFB_ROP_NNEW_XOR_NOLD; break; + case GL_AND_REVERSE: rop = FFB_ROP_NEW_AND_NOLD; break; + case GL_AND_INVERTED: rop = FFB_ROP_NNEW_AND_OLD; break; + case GL_OR_REVERSE: rop = FFB_ROP_NEW_OR_NOLD; break; + case GL_OR_INVERTED: rop = FFB_ROP_NNEW_OR_OLD; break; + + default: + return; + }; + + rop |= fmesa->rop & ~0xff; + if (rop != fmesa->rop) { + fmesa->rop = rop; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_ROP, 1); + + if (op == GL_COPY) + FALLBACK( ctx, FFB_BADATTR_BLENDROP, GL_FALSE ); + } +} + +#if 0 +/* XXX Also need to track near/far just like 3dfx driver. + * XXX + * XXX Actually, that won't work, because the 3dfx chip works by + * XXX having 1/w coordinates fed to it for each primitive, and + * XXX it uses this to index it's 64 entry fog table. + */ +static void ffb_fog_linear(GLcontext *ctx, ffbContextPtr fmesa) +{ + GLfloat c = ctx->ProjectionMatrix.m[10]; + GLfloat d = ctx->ProjectionMatrix.m[14]; + GLfloat tz = ctx->Viewport.WindowMap.m[MAT_TZ]; + GLfloat szInv = 1.0F / ctx->Viewport.WindowMap.m[MAT_SZ]; + GLfloat fogEnd = ctx->Fog.End; + GLfloat fogScale = 1.0F / (ctx->Fog.End - ctx->Fog.Start); + GLfloat ndcz; + GLfloat eyez; + GLfloat Zzero, Zone; + unsigned int zb, zf; + + /* Compute the Z at which f reaches 0.0, this is the full + * saturation point. + * + * Thus compute Z (as seen by the chip during rendering), + * such that: + * + * 0.0 = (fogEnd - eyez) * fogScale + * + * fogScale is usually not zero, thus we are looking for: + * + * fogEnd = eyez + * + * fogEnd = -d / (c + ((Z - tz) * szInv)) + * fogEnd * (c + ((Z - tz) * szInv)) = -d + * (c + ((Z - tz) * szInv)) = -d / fogEnd + * (Z - tz) * szInv = (-d / fogEnd) - c + * (Z - tz) = ((-d / fogEnd) - c) / szInv + * Z = (((-d / fogEnd) - c) / szInv) + tz + */ + Zzero = (((-d / fogEnd) - c) / szInv) + tz; + + /* Compute the Z at which f reaches 1.0, this is where + * the incoming frag's full intensity is shown. This + * equation is: + * + * 1.0 = (fogEnd - eyez) + * + * We are looking for: + * + * 1.0 + eyez = fogEnd + * + * 1.0 + (-d / (c + ((Z - tz) * szInv))) = fogEnd + * -d / (c + ((Z - tz) * szInv)) = fogEnd - 1.0 + * -d / (FogEnd - 1.0) = (c + ((Z - tz) * szInv)) + * (-d / (fogEnd - 1.0)) - c = ((Z - tz) * szInv) + * ((-d / (fogEnd - 1.0)) - c) / szInv = (Z - tz) + * (((-d / (fogEnd - 1.0)) - c) / szInv) + tz = Z + */ + Zone = (((-d / (fogEnd - 1.0)) - c) / szInv) + tz; + + /* FFB's Zfront must be less than Zback, thus we may have + * to invert Sf/Sb to satisfy this constraint. + */ + if (Zzero < Zone) { + sf = 0.0; + sb = 1.0; + zf = Z_FROM_MESA(Zzero); + zb = Z_FROM_MESA(Zone); + } else { + sf = 1.0; + sb = 0.0; + zf = Z_FROM_MESA(Zone); + zb = Z_FROM_MESA(Zzero); + } +} +#endif + +static void ffbDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param) +{ +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDFogfv: pname(%s)\n", _mesa_lookup_enum_by_nr(pname)); +#endif +} + +static void ffbDDLineStipple(GLcontext *ctx, GLint factor, GLushort pattern) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDLineStipple: factor(%d) pattern(%04x)\n", + factor, pattern); +#endif + if (ctx->Line.StippleFlag) { + factor = ctx->Line.StippleFactor; + pattern = ctx->Line.StipplePattern; + if ((GLuint) factor > 15) { + fmesa->lpat = FFB_LPAT_BAD; + } else { + fmesa->lpat = ((factor << FFB_LPAT_SCALEVAL_SHIFT) | + (0 << FFB_LPAT_PATLEN_SHIFT) | + ((pattern & 0xffff) << FFB_LPAT_PATTERN_SHIFT)); + } + } else { + fmesa->lpat = 0; + } +} + +void ffbXformAreaPattern(ffbContextPtr fmesa, const GLubyte *mask) +{ + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + int i, lines, xoff; + + lines = 0; + i = (dPriv->y + dPriv->h) & (32 - 1); + xoff = dPriv->x & (32 - 1); + while (lines++ < 32) { + GLuint raw = + (((GLuint)mask[0] << 24) | + ((GLuint)mask[1] << 16) | + ((GLuint)mask[2] << 8) | + ((GLuint)mask[3] << 0)); + + fmesa->pattern[i] = + (raw << xoff) | (raw >> (32 - xoff)); + i = (i - 1) & (32 - 1); + mask += 4; + } + + FFB_MAKE_DIRTY(fmesa, FFB_STATE_APAT, 32); +} + +static void ffbDDPolygonStipple(GLcontext *ctx, const GLubyte *mask) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDPolygonStipple: state(%d)\n", + ctx->Polygon.StippleFlag); +#endif + ffbXformAreaPattern(fmesa, mask); +} + +static void ffbDDEnable(GLcontext *ctx, GLenum cap, GLboolean state) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + unsigned int tmp; + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDEnable: %s state(%d)\n", + _mesa_lookup_enum_by_nr(cap), state); +#endif + switch (cap) { + case GL_ALPHA_TEST: + if (state) + tmp = ffbComputeAlphaFunc(ctx); + else + tmp = FFB_XCLIP_TEST_ALWAYS; + + if (tmp != fmesa->xclip) { + fmesa->xclip = tmp; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_XCLIP, 1); + } + break; + + case GL_BLEND: + tmp = (fmesa->ppc & ~FFB_PPC_ABE_MASK); + if (state) { + tmp |= FFB_PPC_ABE_ENABLE; + } else { + tmp |= FFB_PPC_ABE_DISABLE; + } + if (fmesa->ppc != tmp) { + fmesa->ppc = tmp; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_PPC, 1); + ffbDDBlendFuncSeparate(ctx, 0, 0, 0, 0 ); + } + break; + + case GL_DEPTH_TEST: + if (state) + tmp = 0x0fffffff; + else + tmp = 0x00000000; + if (tmp != fmesa->magnc) { + unsigned int fbc = fmesa->fbc; + fbc &= ~FFB_FBC_ZE_MASK; + if (state) + fbc |= FFB_FBC_ZE_ON; + else + fbc |= FFB_FBC_ZE_OFF; + fmesa->fbc = fbc; + ffbDDDepthFunc(ctx, ctx->Depth.Func); + fmesa->magnc = tmp; + FFB_MAKE_DIRTY(fmesa, (FFB_STATE_MAGNC | FFB_STATE_FBC), 2); + } + break; + + case GL_SCISSOR_TEST: + ffbDDScissor(ctx, ctx->Scissor.X, ctx->Scissor.Y, + ctx->Scissor.Width, ctx->Scissor.Height); + break; + + case GL_STENCIL_TEST: + if (!(fmesa->ffb_sarea->flags & FFB_DRI_FFB2PLUS)) { + FALLBACK( ctx, FFB_BADATTR_STENCIL, state ); + } + + tmp = fmesa->fbc & ~FFB_FBC_YE_MASK; + if (state) { + ffbDDStencilFunc(ctx, + ctx->Stencil.Function[0], + ctx->Stencil.Ref[0], + ctx->Stencil.ValueMask[0]); + ffbDDStencilMask(ctx, ctx->Stencil.WriteMask[0]); + ffbDDStencilOp(ctx, + ctx->Stencil.FailFunc[0], + ctx->Stencil.ZFailFunc[0], + ctx->Stencil.ZPassFunc[0]); + tmp |= FFB_FBC_YE_MASK; + } else { + fmesa->stencil = 0xf0000000; + fmesa->stencilctl = 0x33300000; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_STENCIL, 6); + tmp |= FFB_FBC_YE_OFF; + } + if (tmp != fmesa->fbc) { + fmesa->fbc = tmp; + FFB_MAKE_DIRTY(fmesa, FFB_STATE_FBC, 1); + } + break; + + case GL_FOG: + /* Until I implement the fog support... */ + FALLBACK( ctx, FFB_BADATTR_FOG, state ); + break; + + case GL_LINE_STIPPLE: + if (! state) + fmesa->lpat = 0; + else + ffbDDLineStipple(ctx, + ctx->Line.StippleFactor, + ctx->Line.StipplePattern); + break; + + case GL_POLYGON_STIPPLE: + /* Do nothing, we interrogate the state during + * reduced primitive changes. Since our caller + * will set NEW_POLYGON in the ctx NewState this + * will cause the driver rasterization functions + * to be reevaluated, which will cause us to force + * a reduced primitive change next rendering pass + * and it all works out. + */ + break; + + default: + break; + }; +} + +void ffbSyncHardware(ffbContextPtr fmesa) +{ + ffb_fbcPtr ffb = fmesa->regs; + unsigned int dirty; + int i; + + FFBFifo(fmesa, fmesa->state_fifo_ents); + + dirty = fmesa->state_dirty; + if (dirty & (FFB_STATE_FBC | FFB_STATE_PPC | FFB_STATE_DRAWOP | + FFB_STATE_ROP | FFB_STATE_LPAT | FFB_STATE_WID)) { + if (dirty & FFB_STATE_FBC) + ffb->fbc = fmesa->fbc; + if (dirty & FFB_STATE_PPC) + ffb->ppc = fmesa->ppc; + if (dirty & FFB_STATE_DRAWOP) + ffb->drawop = fmesa->drawop; + if (dirty & FFB_STATE_ROP) + ffb->rop = fmesa->rop; + if (dirty & FFB_STATE_LPAT) + ffb->rop = fmesa->lpat; + if (dirty & FFB_STATE_WID) + ffb->wid = fmesa->wid; + } + if (dirty & (FFB_STATE_PMASK | FFB_STATE_XPMASK | FFB_STATE_YPMASK | + FFB_STATE_ZPMASK | FFB_STATE_XCLIP | FFB_STATE_CMP | + FFB_STATE_MATCHAB | FFB_STATE_MAGNAB | FFB_STATE_MATCHC | + FFB_STATE_MAGNC)) { + if (dirty & FFB_STATE_PMASK) + ffb->pmask = fmesa->pmask; + if (dirty & FFB_STATE_XPMASK) + ffb->xpmask = fmesa->xpmask; + if (dirty & FFB_STATE_YPMASK) + ffb->ypmask = fmesa->ypmask; + if (dirty & FFB_STATE_ZPMASK) + ffb->zpmask = fmesa->zpmask; + if (dirty & FFB_STATE_XCLIP) + ffb->xclip = fmesa->xclip; + if (dirty & FFB_STATE_CMP) + ffb->cmp = fmesa->cmp; + if (dirty & FFB_STATE_MATCHAB) + ffb->matchab = fmesa->matchab; + if (dirty & FFB_STATE_MAGNAB) + ffb->magnab = fmesa->magnab; + if (dirty & FFB_STATE_MATCHC) + ffb->matchc = fmesa->matchc; + if (dirty & FFB_STATE_MAGNC) + ffb->magnc = fmesa->magnc; + } + + if (dirty & FFB_STATE_DCUE) { + ffb->dcss = fmesa->dcss; + ffb->dcsf = fmesa->dcsf; + ffb->dcsb = fmesa->dcsb; + ffb->dczf = fmesa->dczf; + ffb->dczb = fmesa->dczb; + if (fmesa->ffb_sarea->flags & (FFB_DRI_FFB2 | FFB_DRI_FFB2PLUS)) { + ffb->dcss1 = fmesa->dcss1; + ffb->dcss2 = fmesa->dcss2; + ffb->dcss3 = fmesa->dcss3; + ffb->dcs2 = fmesa->dcs2; + ffb->dcs3 = fmesa->dcs3; + ffb->dcs4 = fmesa->dcs4; + ffb->dcd2 = fmesa->dcd2; + ffb->dcd3 = fmesa->dcd3; + ffb->dcd4 = fmesa->dcd4; + } + } + + if (dirty & FFB_STATE_BLEND) { + ffb->blendc = fmesa->blendc; + ffb->blendc1 = fmesa->blendc1; + ffb->blendc2 = fmesa->blendc2; + } + + if (dirty & FFB_STATE_CLIP) { + ffb->vclipmin = fmesa->vclipmin; + ffb->vclipmax = fmesa->vclipmax; + ffb->vclipzmin = fmesa->vclipzmin; + ffb->vclipzmax = fmesa->vclipzmax; + for (i = 0; i < 4; i++) { + ffb->auxclip[i].min = fmesa->aux_clips[i].min; + ffb->auxclip[i].max = fmesa->aux_clips[i].max; + } + } + + if ((dirty & FFB_STATE_STENCIL) && + (fmesa->ffb_sarea->flags & FFB_DRI_FFB2PLUS)) { + ffb->stencil = fmesa->stencil; + ffb->stencilctl = fmesa->stencilctl; + ffb->fbc = FFB_FBC_WB_C; + ffb->rawstencilctl = (fmesa->stencilctl | (1 << 19)); + ffb->fbc = fmesa->fbc; + ffb->consty = fmesa->consty; + } + + if (dirty & FFB_STATE_APAT) { + for (i = 0; i < 32; i++) + ffb->pattern[i] = fmesa->pattern[i]; + } + + fmesa->state_dirty = 0; + fmesa->state_fifo_ents = 0; + fmesa->ffbScreen->rp_active = 1; +} + +static void ffbDDUpdateState(GLcontext *ctx, GLuint newstate) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + /* When we are hw rendering, changing certain kinds of + * state does not require flushing all of our context. + */ + if (fmesa->bad_fragment_attrs == 0 && + (newstate & ~_NEW_COLOR) == 0) + return; + + _swrast_InvalidateState( ctx, newstate ); + _swsetup_InvalidateState( ctx, newstate ); + _ac_InvalidateState( ctx, newstate ); + _tnl_InvalidateState( ctx, newstate ); + + if (newstate & _NEW_TEXTURE) + FALLBACK( ctx, FFB_BADATTR_TEXTURE, + (ctx->Texture._EnabledUnits != 0)); + +#ifdef STATE_TRACE + fprintf(stderr, "ffbDDUpdateState: newstate(%08x)\n", newstate); +#endif + + fmesa->new_gl_state |= newstate; + + /* Force a reduced primitive change next rendering + * pass. + */ + fmesa->raster_primitive = GL_POLYGON + 1; + +#if 0 + /* When the modelview matrix changes, this changes what + * the eye coordinates will be so we have to recompute + * the depth cueing parameters. + * + * XXX DD_HAVE_HARDWARE_FOG. + */ + if (ctx->Fog.Enabled && (newstate & _NEW_MODELVIEW)) + ffb_update_fog(); +#endif +} + + +void ffbDDInitStateFuncs(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + ctx->Driver.UpdateState = ffbDDUpdateState; + + ctx->Driver.Enable = ffbDDEnable; + ctx->Driver.AlphaFunc = ffbDDAlphaFunc; + ctx->Driver.BlendEquationSeparate = ffbDDBlendEquationSeparate; + ctx->Driver.BlendFuncSeparate = ffbDDBlendFuncSeparate; + ctx->Driver.DepthFunc = ffbDDDepthFunc; + ctx->Driver.DepthMask = ffbDDDepthMask; + ctx->Driver.Fogfv = ffbDDFogfv; + ctx->Driver.LineStipple = ffbDDLineStipple; + ctx->Driver.PolygonStipple = ffbDDPolygonStipple; + ctx->Driver.Scissor = ffbDDScissor; + ctx->Driver.ColorMask = ffbDDColorMask; + ctx->Driver.LogicOpcode = ffbDDLogicOp; + ctx->Driver.Viewport = ffbDDViewport; + ctx->Driver.DepthRange = ffbDDDepthRange; + + if (fmesa->ffb_sarea->flags & FFB_DRI_FFB2PLUS) { + ctx->Driver.StencilFunc = ffbDDStencilFunc; + ctx->Driver.StencilMask = ffbDDStencilMask; + ctx->Driver.StencilOp = ffbDDStencilOp; + } + + ctx->Driver.DrawBuffer = ffbDDDrawBuffer; + ctx->Driver.ReadBuffer = ffbDDReadBuffer; + ctx->Driver.ClearColor = ffbDDClearColor; + ctx->Driver.ClearDepth = ffbDDClearDepth; + ctx->Driver.ClearStencil = ffbDDClearStencil; + + /* We will support color index modes later... -DaveM */ + /* + ctx->Driver.ClearIndex = 0; + ctx->Driver.IndexMask = 0; + */ + + { + struct swrast_device_driver *swdd = + _swrast_GetDeviceDriverReference(ctx); + swdd->SetBuffer = ffbDDSetBuffer; + } + + +} + +void ffbDDInitContextHwState(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + int fifo_count = 0; + int i; + + fmesa->hw_locked = 0; + + fmesa->bad_fragment_attrs = 0; + fmesa->state_dirty = FFB_STATE_ALL; + fmesa->new_gl_state = ~0; + + fifo_count = 1; + fmesa->fbc = (FFB_FBC_WE_FORCEON | FFB_FBC_WM_COMBINED | + FFB_FBC_SB_BOTH | FFB_FBC_ZE_MASK | + FFB_FBC_YE_OFF | FFB_FBC_XE_OFF | + FFB_FBC_RGBE_MASK); + if (ctx->Visual.doubleBufferMode) { + /* Buffer B is the initial back buffer. */ + fmesa->back_buffer = 1; + fmesa->fbc |= FFB_FBC_WB_BC | FFB_FBC_RB_B; + } else { + fmesa->back_buffer = 0; + fmesa->fbc |= FFB_FBC_WB_A | FFB_FBC_RB_A; + } + + fifo_count += 1; + fmesa->ppc = (FFB_PPC_ACE_DISABLE | FFB_PPC_DCE_DISABLE | + FFB_PPC_ABE_DISABLE | FFB_PPC_VCE_3D | + FFB_PPC_APE_DISABLE | FFB_PPC_TBE_OPAQUE | + FFB_PPC_ZS_CONST | FFB_PPC_YS_CONST | + FFB_PPC_XS_WID | FFB_PPC_CS_VAR); + + fifo_count += 3; + fmesa->drawop = FFB_DRAWOP_RECTANGLE; + + /* GL_COPY is the default LogicOp. */ + fmesa->rop = (FFB_ROP_NEW << 16) | (FFB_ROP_NEW << 8) | FFB_ROP_NEW; + + /* No line patterning enabled. */ + fmesa->lpat = 0x00000000; + + /* We do not know the WID value until the first context switch. */ + fifo_count += 1; + fmesa->wid = ~0; + + fifo_count += 5; + + /* ColorMask, all enabled. */ + fmesa->pmask = 0xffffffff; + + fmesa->xpmask = 0x000000ff; + fmesa->ypmask = 0x0000000f; + fmesa->zpmask = 0x0fffffff; + + /* AlphaFunc GL_ALWAYS, AlphaRef 0 */ + fmesa->xclip = FFB_XCLIP_TEST_ALWAYS | 0x00; + + /* This sets us up to use WID clipping (so the DRI clipping + * rectangle is unneeded by us). All other match and magnitude + * tests are set to pass. + */ + fifo_count += 5; + fmesa->cmp = ((FFB_CMP_MATCH_ALWAYS << 24) | /* MATCH C */ + (FFB_CMP_MAGN_ALWAYS << 16) | /* MAGN C */ + (FFB_CMP_MATCH_EQ << 8) | /* MATCH AB */ + (FFB_CMP_MAGN_ALWAYS << 0)); /* MAGN AB */ + fmesa->matchab = 0xff000000; + fmesa->magnab = 0x00000000; + fmesa->matchc = 0x00000000; + fmesa->magnc = 0x00000000; + + /* Depth cue parameters, all zeros to start. */ + fifo_count += 14; + fmesa->dcss = 0x00000000; + fmesa->dcsf = 0x00000000; + fmesa->dcsb = 0x00000000; + fmesa->dczf = 0x00000000; + fmesa->dczb = 0x00000000; + fmesa->dcss1 = 0x00000000; + fmesa->dcss2 = 0x00000000; + fmesa->dcss3 = 0x00000000; + fmesa->dcs2 = 0x00000000; + fmesa->dcs3 = 0x00000000; + fmesa->dcs4 = 0x00000000; + fmesa->dcd2 = 0x00000000; + fmesa->dcd3 = 0x00000000; + fmesa->dcd4 = 0x00000000; + + /* Alpha blending unit state. */ + fifo_count += 3; + fmesa->blendc = (1 << 0) | (0 << 2); /* src(GL_ONE) | dst(GL_ZERO) */ + fmesa->blendc1 = 0x00000000; + fmesa->blendc2 = 0x00000000; + + /* ViewPort clip state. */ + fifo_count += 4 + (4 * 2); + fmesa->vclipmin = 0x00000000; + fmesa->vclipmax = 0xffffffff; + fmesa->vclipzmin = 0x00000000; + fmesa->vclipzmax = 0x0fffffff; + for (i = 0; i < 4; i++) { + fmesa->aux_clips[0].min = 0x00000000; + fmesa->aux_clips[0].max = 0x00000000; + } + + /* Stenciling state. */ + fifo_count += 6; + fmesa->stencil = 0xf0000000; /* Stencil MASK, Y plane */ + fmesa->stencilctl = 0x33300000; /* All stencil tests disabled */ + fmesa->consty = 0x0; + + /* Area pattern, used for polygon stipples. */ + fifo_count += 32; + for (i = 0; i < 32; i++) + fmesa->pattern[i] = 0x00000000; + + fmesa->state_fifo_ents = fifo_count; + fmesa->state_all_fifo_ents = fifo_count; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_state.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_state.h new file mode 100644 index 000000000..17b6fa20a --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_state.h @@ -0,0 +1,13 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_state.h,v 1.2 2002/02/22 21:32:59 dawes Exp $ */ + +#ifndef _FFB_STATE_H +#define _FFB_STATE_H + +extern void ffbDDInitStateFuncs(GLcontext *); +extern void ffbDDInitContextHwState(GLcontext *); + +extern void ffbCalcViewport(GLcontext *); +extern void ffbXformAreaPattern(ffbContextPtr, const GLubyte *); +extern void ffbSyncHardware(ffbContextPtr fmesa); + +#endif /* !(_FFB_STATE_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_stencil.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_stencil.c new file mode 100644 index 000000000..2f13ee921 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_stencil.c @@ -0,0 +1,226 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_stencil.c,v 1.2 2002/02/22 21:32:59 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "mtypes.h" +#include "ffb_dd.h" +#include "ffb_span.h" +#include "ffb_context.h" +#include "ffb_stencil.h" +#include "ffb_lock.h" + +#include "swrast/swrast.h" + +#undef STENCIL_TRACE + +static void FFBWriteStencilSpan( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, GLint x, GLint y, + const void *values, const GLubyte mask[] ) +{ + const GLubyte *stencil = (const GLubyte *) values; +#ifdef STENCIL_TRACE + fprintf(stderr, "FFBWriteStencilSpan: n(%d) x(%d) y(%d)\n", + (int) n, x, y); +#endif + if (ctx->Depth.Mask) { + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + GLuint *zptr; + GLuint i; + + if (!fmesa->hw_locked) + LOCK_HARDWARE(fmesa); + FFBFifo(fmesa, 2); + fmesa->regs->fbc = (FFB_FBC_WB_C | FFB_FBC_ZE_OFF | + FFB_FBC_YE_ON | FFB_FBC_RGBE_OFF); + fmesa->regs->ppc = FFB_PPC_YS_VAR; + FFBWait(fmesa, fmesa->regs); + + y = (dPriv->h - y); + zptr = (GLuint *) + ((char *)fmesa->sfb32 + + ((dPriv->x + x) << 2) + + ((dPriv->y + y) << 13)); + + for (i = 0; i < n; i++) { + if (mask[i]) + *zptr = (stencil[i] & 0xf) << 28; + zptr++; + } + + FFBFifo(fmesa, 2); + fmesa->regs->fbc = fmesa->fbc; + fmesa->regs->ppc = fmesa->ppc; + fmesa->ffbScreen->rp_active = 1; + if (!fmesa->hw_locked) + UNLOCK_HARDWARE(fmesa); + } +} + +static void FFBWriteStencilPixels( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, + const GLint x[], const GLint y[], + const void *values, const GLubyte mask[] ) +{ + const GLubyte *stencil = (const GLubyte *) values; +#ifdef STENCIL_TRACE + fprintf(stderr, "FFBWriteStencilPixels: n(%d)\n", (int) n); +#endif + if (ctx->Depth.Mask) { + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + char *zbase; + GLuint i; + + if (!fmesa->hw_locked) + LOCK_HARDWARE(fmesa); + FFBFifo(fmesa, 2); + fmesa->regs->fbc = (FFB_FBC_WB_C | FFB_FBC_ZE_OFF | + FFB_FBC_YE_ON | FFB_FBC_RGBE_OFF); + fmesa->regs->ppc = FFB_PPC_YS_VAR; + fmesa->ffbScreen->rp_active = 1; + FFBWait(fmesa, fmesa->regs); + + zbase = ((char *)fmesa->sfb32 + + (dPriv->x << 2) + (dPriv->y << 13)); + + for (i = 0; i < n; i++) { + GLint y1 = (dPriv->h - y[i]); + GLint x1 = x[i]; + GLuint *zptr; + + zptr = (GLuint *) + (zbase + (x1 << 2) + (y1 << 13)); + if (mask[i]) + *zptr = (stencil[i] & 0xf) << 28; + } + + FFBFifo(fmesa, 2); + fmesa->regs->fbc = fmesa->fbc; + fmesa->regs->ppc = fmesa->ppc; + fmesa->ffbScreen->rp_active = 1; + if (!fmesa->hw_locked) + UNLOCK_HARDWARE(fmesa); + } +} + +static void FFBReadStencilSpan( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, GLint x, GLint y, + void *values) +{ + GLubyte *stencil = (GLubyte *) values; + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + GLuint *zptr; + GLuint i; + +#ifdef STENCIL_TRACE + fprintf(stderr, "FFBReadStencilSpan: n(%d) x(%d) y(%d)\n", + (int) n, x, y); +#endif + if (!fmesa->hw_locked) + LOCK_HARDWARE(fmesa); + FFBFifo(fmesa, 1); + fmesa->regs->fbc = FFB_FBC_RB_C; + fmesa->ffbScreen->rp_active = 1; + FFBWait(fmesa, fmesa->regs); + + y = (dPriv->h - y); + zptr = (GLuint *) + ((char *)fmesa->sfb32 + + ((dPriv->x + x) << 2) + + ((dPriv->y + y) << 13)); + + for (i = 0; i < n; i++) { + stencil[i] = (*zptr >> 28) & 0xf; + zptr++; + } + + FFBFifo(fmesa, 1); + fmesa->regs->fbc = fmesa->fbc; + fmesa->ffbScreen->rp_active = 1; + if (!fmesa->hw_locked) + UNLOCK_HARDWARE(fmesa); +} + +static void FFBReadStencilPixels( GLcontext *ctx, + struct gl_renderbuffer *rb, + GLuint n, const GLint x[], const GLint y[], + void *values ) +{ + GLubyte *stencil = (GLubyte *) values; + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + char *zbase; + GLuint i; + +#ifdef STENCIL_TRACE + fprintf(stderr, "FFBReadStencilPixels: n(%d)\n", (int) n); +#endif + if (!fmesa->hw_locked) + LOCK_HARDWARE(fmesa); + FFBFifo(fmesa, 1); + fmesa->regs->fbc = FFB_FBC_RB_C; + fmesa->ffbScreen->rp_active = 1; + FFBWait(fmesa, fmesa->regs); + + zbase = ((char *)fmesa->sfb32 + + (dPriv->x << 2) + (dPriv->y << 13)); + + for (i = 0; i < n; i++) { + GLint y1 = (dPriv->h - y[i]); + GLint x1 = x[i]; + GLuint *zptr; + + zptr = (GLuint *) + (zbase + (x1 << 2) + (y1 << 13)); + stencil[i] = (*zptr >> 28) & 0xf; + } + + FFBFifo(fmesa, 1); + fmesa->regs->fbc = fmesa->fbc; + fmesa->ffbScreen->rp_active = 1; + if (!fmesa->hw_locked) + UNLOCK_HARDWARE(fmesa); +} + +/** + * Plug in the Get/Put routines for the given driRenderbuffer. + */ +void +ffbSetStencilFunctions(driRenderbuffer *drb, const GLvisual *vis) +{ + assert(drb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT); + drb->Base.GetRow = FFBReadStencilSpan; + drb->Base.GetValues = FFBReadStencilPixels; + drb->Base.PutRow = FFBWriteStencilSpan; + /*drb->Base.PutMonoRow = FFBWriteMonoStencilSpan;*/ + drb->Base.PutValues = FFBWriteStencilPixels; + drb->Base.PutMonoValues = NULL; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_stencil.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_stencil.h new file mode 100644 index 000000000..c7da1ca68 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_stencil.h @@ -0,0 +1,8 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_stencil.h,v 1.1 2000/06/20 05:08:39 dawes Exp $ */ + +#ifndef _FFB_STENCIL_H +#define _FFB_STENCIL_H + +void ffbSetStencilFunctions(driRenderbuffer *drb, const GLvisual *vis); + +#endif /* !(_FFB_STENCIL_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tex.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tex.c new file mode 100644 index 000000000..d6763b7cd --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tex.c @@ -0,0 +1,53 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_tex.c,v 1.1 2002/02/22 21:32:59 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "glheader.h" +#include "mtypes.h" +#include "ffb_tex.h" + +/* No texture unit, all software. */ +/* XXX this function isn't needed since _mesa_init_driver_functions() + * will make all these assignments. + */ +void ffbDDInitTexFuncs(GLcontext *ctx) +{ + /* + ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format; + ctx->Driver.TexImage1D = _mesa_store_teximage1d; + ctx->Driver.TexImage2D = _mesa_store_teximage2d; + ctx->Driver.TexImage3D = _mesa_store_teximage3d; + ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d; + ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d; + ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d; + ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d; + ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d; + ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d; + ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d; + ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d; + ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage; + */ +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tex.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tex.h new file mode 100644 index 000000000..dba0e08af --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tex.h @@ -0,0 +1,34 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_tex.h,v 1.1 2002/02/22 21:32:59 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D. + * Copyright (C) 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#ifndef _FFB_TEX_H +#define _FFB_TEX_H + +extern void ffbDDInitTexFuncs(GLcontext *ctx); + +#endif /* !(_FFB_DD_H) */ + diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tris.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tris.c new file mode 100644 index 000000000..ca0e514dc --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tris.c @@ -0,0 +1,945 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_tris.c,v 1.3 2002/10/30 12:51:28 alanh Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000, 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "glheader.h" +#include "mtypes.h" +#include "macros.h" +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" +#include "swrast/s_context.h" +#include "tnl/t_context.h" +#include "tnl/t_pipeline.h" + +#include "ffb_context.h" +#include "ffb_tris.h" +#include "ffb_lines.h" +#include "ffb_lock.h" +#include "ffb_points.h" +#include "ffb_state.h" +#include "ffb_vb.h" + +#undef TRI_DEBUG +#undef FFB_RENDER_TRACE +#undef STATE_TRACE + +#ifdef TRI_DEBUG +static void ffb_print_vertex(const ffb_vertex *v) +{ + fprintf(stderr, "Vertex @(%p): " + "X[%f] Y[%f] Z[%f]\n", + v, v->x, v->y, v->z); + fprintf(stderr, "Vertex @(%p): " + "A[%f] R[%f] G[%f] B[%f]\n", + v, + v->color[0].alpha, + v->color[0].red, + v->color[0].green, + v->color[0].blue); +} +#define FFB_DUMP_VERTEX(V) ffb_print_vertex(V) +#else +#define FFB_DUMP_VERTEX(V) do { } while(0) +#endif + +#define FFB_ALPHA_BIT 0x01 +#define FFB_FLAT_BIT 0x02 +#define FFB_TRI_CULL_BIT 0x04 +#define MAX_FFB_RENDER_FUNCS 0x08 + +/*********************************************************************** + * Build low-level triangle/quad rasterize functions * + ***********************************************************************/ + +#define FFB_TRI_FLAT_BIT 0x01 +#define FFB_TRI_ALPHA_BIT 0x02 +/*#define FFB_TRI_CULL_BIT 0x04*/ + +static ffb_tri_func ffb_tri_tab[0x8]; +static ffb_quad_func ffb_quad_tab[0x8]; + +#define IND (0) +#define TAG(x) x +#include "ffb_tritmp.h" + +#define IND (FFB_TRI_FLAT_BIT) +#define TAG(x) x##_flat +#include "ffb_tritmp.h" + +#define IND (FFB_TRI_CULL_BIT) +#define TAG(x) x##_cull +#include "ffb_tritmp.h" + +#define IND (FFB_TRI_CULL_BIT|FFB_TRI_FLAT_BIT) +#define TAG(x) x##_cull_flat +#include "ffb_tritmp.h" + +#define IND (FFB_TRI_ALPHA_BIT) +#define TAG(x) x##_alpha +#include "ffb_tritmp.h" + +#define IND (FFB_TRI_ALPHA_BIT|FFB_TRI_FLAT_BIT) +#define TAG(x) x##_alpha_flat +#include "ffb_tritmp.h" + +#define IND (FFB_TRI_ALPHA_BIT|FFB_TRI_CULL_BIT) +#define TAG(x) x##_alpha_cull +#include "ffb_tritmp.h" + +#define IND (FFB_TRI_ALPHA_BIT|FFB_TRI_CULL_BIT|FFB_TRI_FLAT_BIT) +#define TAG(x) x##_alpha_cull_flat +#include "ffb_tritmp.h" + +static void init_tri_tab(void) +{ + ffb_init(); + ffb_init_flat(); + ffb_init_cull(); + ffb_init_cull_flat(); + ffb_init_alpha(); + ffb_init_alpha_flat(); + ffb_init_alpha_cull(); + ffb_init_alpha_cull_flat(); +} + +/* Build a SWvertex from a hardware vertex. */ +static void ffb_translate_vertex(GLcontext *ctx, const ffb_vertex *src, + SWvertex *dst) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLfloat *m = ctx->Viewport._WindowMap.m; + const GLfloat sx = m[0]; + const GLfloat sy = m[5]; + const GLfloat sz = m[10]; + const GLfloat tx = m[12]; + const GLfloat ty = m[13]; + const GLfloat tz = m[14]; + + dst->win[0] = sx * src->x + tx; + dst->win[1] = sy * src->y + ty; + dst->win[2] = sz * src->z + tz; + dst->win[3] = 1.0; + + dst->color[0] = FFB_UBYTE_FROM_COLOR(src->color[0].red); + dst->color[1] = FFB_UBYTE_FROM_COLOR(src->color[0].green); + dst->color[2] = FFB_UBYTE_FROM_COLOR(src->color[0].blue); + dst->color[3] = FFB_UBYTE_FROM_COLOR(src->color[0].alpha); +} + +/*********************************************************************** + * Build fallback triangle/quad rasterize functions * + ***********************************************************************/ + +static void ffb_fallback_triangle(GLcontext *ctx, ffb_vertex *v0, + ffb_vertex *v1, ffb_vertex *v2) +{ + SWvertex v[3]; + + ffb_translate_vertex(ctx, v0, &v[0]); + ffb_translate_vertex(ctx, v1, &v[1]); + ffb_translate_vertex(ctx, v2, &v[2]); + + _swrast_Triangle(ctx, &v[0], &v[1], &v[2]); +} + +static void ffb_fallback_quad(GLcontext *ctx, + ffb_vertex *v0, ffb_vertex *v1, + ffb_vertex *v2, ffb_vertex *v3) +{ + SWvertex v[4]; + + ffb_translate_vertex(ctx, v0, &v[0]); + ffb_translate_vertex(ctx, v1, &v[1]); + ffb_translate_vertex(ctx, v2, &v[2]); + ffb_translate_vertex(ctx, v3, &v[3]); + + _swrast_Quad(ctx, &v[0], &v[1], &v[2], &v[3]); +} + +void ffb_fallback_line(GLcontext *ctx, ffb_vertex *v0, ffb_vertex *v1) +{ + SWvertex v[2]; + + ffb_translate_vertex(ctx, v0, &v[0]); + ffb_translate_vertex(ctx, v1, &v[1]); + + _swrast_Line(ctx, &v[0], &v[1]); +} + +void ffb_fallback_point(GLcontext *ctx, ffb_vertex *v0) +{ + SWvertex v[1]; + + ffb_translate_vertex(ctx, v0, &v[0]); + + _swrast_Point(ctx, &v[0]); +} + +/*********************************************************************** + * Rasterization functions for culled tris/quads * + ***********************************************************************/ + +static void ffb_nodraw_triangle(GLcontext *ctx, ffb_vertex *v0, + ffb_vertex *v1, ffb_vertex *v2) +{ + (void) (ctx && v0 && v1 && v2); +} + +static void ffb_nodraw_quad(GLcontext *ctx, + ffb_vertex *v0, ffb_vertex *v1, + ffb_vertex *v2, ffb_vertex *v3) +{ + (void) (ctx && v0 && v1 && v2 && v3); +} + +static void ffb_update_cullsign(GLcontext *ctx) +{ + GLfloat backface_sign = 1; + + switch (ctx->Polygon.CullFaceMode) { + case GL_BACK: + if (ctx->Polygon.FrontFace==GL_CCW) + backface_sign = -1; + break; + + case GL_FRONT: + if (ctx->Polygon.FrontFace!=GL_CCW) + backface_sign = -1; + break; + + default: + break; + }; + + FFB_CONTEXT(ctx)->backface_sign = backface_sign; +} + +/*********************************************************************** + * Choose triangle/quad rasterize functions * + ***********************************************************************/ + +void ffbChooseTriangleState(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLuint flags = ctx->_TriangleCaps; + GLuint ind = 0; + + if (flags & DD_TRI_SMOOTH) { + fmesa->draw_tri = ffb_fallback_triangle; + fmesa->draw_quad = ffb_fallback_quad; + return; + } + + if (flags & DD_FLATSHADE) + ind |= FFB_TRI_FLAT_BIT; + + if (ctx->Polygon.CullFlag) { + if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) { + fmesa->draw_tri = ffb_nodraw_triangle; + fmesa->draw_quad = ffb_nodraw_quad; + return; + } + + ind |= FFB_TRI_CULL_BIT; + ffb_update_cullsign(ctx); + } else + FFB_CONTEXT(ctx)->backface_sign = 0; + + /* If blending or the alpha test is enabled we need to + * provide alpha components to the chip, else we can + * do without it and thus feed vertex data to the chip + * more efficiently. + */ + if (ctx->Color.BlendEnabled || ctx->Color.AlphaEnabled) + ind |= FFB_TRI_ALPHA_BIT; + + fmesa->draw_tri = ffb_tri_tab[ind]; + fmesa->draw_quad = ffb_quad_tab[ind]; +} + +static const GLenum reduced_prim[GL_POLYGON+1] = { + GL_POINTS, + GL_LINES, + GL_LINES, + GL_LINES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES, + GL_TRIANGLES +}; + +static void ffbRenderPrimitive(GLcontext *ctx, GLenum prim); +static void ffbRasterPrimitive(GLcontext *ctx, GLenum rprim); + +/*********************************************************************** + * Build render functions from dd templates * + ***********************************************************************/ + +#define FFB_OFFSET_BIT 0x01 +#define FFB_TWOSIDE_BIT 0x02 +#define FFB_UNFILLED_BIT 0x04 +#define FFB_MAX_TRIFUNC 0x08 + +static struct { + tnl_triangle_func triangle; + tnl_quad_func quad; +} rast_tab[FFB_MAX_TRIFUNC]; + +#define DO_OFFSET (IND & FFB_OFFSET_BIT) +#define DO_UNFILLED (IND & FFB_UNFILLED_BIT) +#define DO_TWOSIDE (IND & FFB_TWOSIDE_BIT) +#define DO_FLAT 0 +#define DO_QUAD 1 +#define DO_FULL_QUAD 1 +#define DO_TRI 1 +#define DO_LINE 0 +#define DO_POINTS 0 + +#define QUAD( a, b, c, d ) fmesa->draw_quad( ctx, a, b, c, d ) +#define TRI( a, b, c ) fmesa->draw_tri( ctx, a, b, c ) +#define LINE( a, b ) fmesa->draw_line( ctx, a, b ) +#define POINT( a ) fmesa->draw_point( ctx, a ) + +#define HAVE_BACK_COLORS 1 +#define HAVE_RGBA 1 +#define HAVE_SPEC 0 +#define HAVE_HW_FLATSHADE 1 +#define VERTEX ffb_vertex +#define TAB rast_tab + +#define UNFILLED_TRI unfilled_tri +#define UNFILLED_QUAD unfilled_quad +#define DEPTH_SCALE (fmesa->depth_scale) +#define VERT_X(_v) (_v->x) +#define VERT_Y(_v) (_v->y) +#define VERT_Z(_v) (_v->z) +#define AREA_IS_CCW( a ) (a < fmesa->ffb_zero) +#define GET_VERTEX(e) (&fmesa->verts[e]) +#define INSANE_VERTICES +#define VERT_SET_Z(v,val) ((v)->z = (val)) +#define VERT_Z_ADD(v,val) ((v)->z += (val)) + +#define VERT_COPY_RGBA1( _v ) _v->color[0] = _v->color[1] +#define VERT_COPY_RGBA( v0, v1 ) v0->color[0] = v1->color[0] +#define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->color[0] +#define VERT_RESTORE_RGBA( idx ) v[idx]->color[0] = color[idx] + +#define LOCAL_VARS(n) \ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); \ + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; \ + ffb_color color[n]; \ + (void) color; (void) dPriv; + +/*********************************************************************** + * Helpers for rendering unfilled primitives * + ***********************************************************************/ + +#define RASTERIZE(x) if (fmesa->raster_primitive != reduced_prim[x]) \ + ffbRasterPrimitive( ctx, reduced_prim[x] ) +#define RENDER_PRIMITIVE fmesa->render_primitive +#define TAG(x) x +#include "tnl_dd/t_dd_unfilled.h" + +/*********************************************************************** + * Generate GL render functions * + ***********************************************************************/ + +#define IND (0) +#define TAG(x) x +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (FFB_OFFSET_BIT) +#define TAG(x) x##_offset +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (FFB_TWOSIDE_BIT) +#define TAG(x) x##_twoside +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (FFB_TWOSIDE_BIT|FFB_OFFSET_BIT) +#define TAG(x) x##_twoside_offset +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (FFB_UNFILLED_BIT) +#define TAG(x) x##_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (FFB_OFFSET_BIT|FFB_UNFILLED_BIT) +#define TAG(x) x##_offset_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (FFB_TWOSIDE_BIT|FFB_UNFILLED_BIT) +#define TAG(x) x##_twoside_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +#define IND (FFB_TWOSIDE_BIT|FFB_OFFSET_BIT|FFB_UNFILLED_BIT) +#define TAG(x) x##_twoside_offset_unfilled +#include "tnl_dd/t_dd_tritmp.h" + +static void init_rast_tab( void ) +{ + init(); + init_offset(); + init_twoside(); + init_twoside_offset(); + init_unfilled(); + init_offset_unfilled(); + init_twoside_unfilled(); + init_twoside_offset_unfilled(); +} + +/**********************************************************************/ +/* Render clipped primitives */ +/**********************************************************************/ + +static void ffbRenderClippedPolygon(GLcontext *ctx, const GLuint *elts, GLuint n) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + GLuint prim = fmesa->render_primitive; + + /* Render the new vertices as an unclipped polygon. */ + { + GLuint *tmp = VB->Elts; + VB->Elts = (GLuint *)elts; + tnl->Driver.Render.PrimTabElts[GL_POLYGON](ctx, 0, n, PRIM_BEGIN|PRIM_END); + VB->Elts = tmp; + } + + /* Restore the render primitive. */ + if (prim != GL_POLYGON) + tnl->Driver.Render.PrimitiveNotify(ctx, prim); +} + +static void ffbRenderClippedLine(GLcontext *ctx, GLuint ii, GLuint jj) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->Driver.Render.Line(ctx, ii, jj); +} + +/**********************************************************************/ +/* Render unclipped begin/end objects */ +/**********************************************************************/ + +static void ffb_vb_noop(GLcontext *ctx, GLuint start, GLuint count, GLuint flags) +{ + (void)(ctx && start && count && flags); +} + +#define ELT(x) x + +#define IND 0 +#define TAG(x) x +#include "ffb_rendertmp.h" + +#define IND (FFB_FLAT_BIT) +#define TAG(x) x##_flat +#include "ffb_rendertmp.h" + +#define IND (FFB_ALPHA_BIT) +#define TAG(x) x##_alpha +#include "ffb_rendertmp.h" + +#define IND (FFB_FLAT_BIT | FFB_ALPHA_BIT) +#define TAG(x) x##_flat_alpha +#include "ffb_rendertmp.h" + +#define IND (FFB_TRI_CULL_BIT) +#define TAG(x) x##_tricull +#include "ffb_rendertmp.h" + +#define IND (FFB_FLAT_BIT | FFB_TRI_CULL_BIT) +#define TAG(x) x##_flat_tricull +#include "ffb_rendertmp.h" + +#define IND (FFB_ALPHA_BIT | FFB_TRI_CULL_BIT) +#define TAG(x) x##_alpha_tricull +#include "ffb_rendertmp.h" + +#define IND (FFB_FLAT_BIT | FFB_ALPHA_BIT | FFB_TRI_CULL_BIT) +#define TAG(x) x##_flat_alpha_tricull +#include "ffb_rendertmp.h" + +#undef ELT +#define ELT(x) elt[x] + +#define IND 0 +#define TAG(x) x##_elt +#include "ffb_rendertmp.h" + +#define IND (FFB_FLAT_BIT) +#define TAG(x) x##_flat_elt +#include "ffb_rendertmp.h" + +#define IND (FFB_ALPHA_BIT) +#define TAG(x) x##_alpha_elt +#include "ffb_rendertmp.h" + +#define IND (FFB_FLAT_BIT | FFB_ALPHA_BIT) +#define TAG(x) x##_flat_alpha_elt +#include "ffb_rendertmp.h" + +#define IND (FFB_TRI_CULL_BIT) +#define TAG(x) x##_tricull_elt +#include "ffb_rendertmp.h" + +#define IND (FFB_FLAT_BIT | FFB_TRI_CULL_BIT) +#define TAG(x) x##_flat_tricull_elt +#include "ffb_rendertmp.h" + +#define IND (FFB_ALPHA_BIT | FFB_TRI_CULL_BIT) +#define TAG(x) x##_alpha_tricull_elt +#include "ffb_rendertmp.h" + +#define IND (FFB_FLAT_BIT | FFB_ALPHA_BIT | FFB_TRI_CULL_BIT) +#define TAG(x) x##_flat_alpha_tricull_elt +#include "ffb_rendertmp.h" + +static void *render_tabs[MAX_FFB_RENDER_FUNCS]; +static void *render_tabs_elt[MAX_FFB_RENDER_FUNCS]; + +static void init_render_tab(void) +{ + int i; + + render_tabs[0] = render_tab; + render_tabs[FFB_FLAT_BIT] = render_tab_flat; + render_tabs[FFB_ALPHA_BIT] = render_tab_alpha; + render_tabs[FFB_FLAT_BIT|FFB_ALPHA_BIT] = render_tab_flat_alpha; + render_tabs[FFB_TRI_CULL_BIT] = render_tab_tricull; + render_tabs[FFB_FLAT_BIT|FFB_TRI_CULL_BIT] = render_tab_flat_tricull; + render_tabs[FFB_ALPHA_BIT|FFB_TRI_CULL_BIT] = render_tab_alpha_tricull; + render_tabs[FFB_FLAT_BIT|FFB_ALPHA_BIT|FFB_TRI_CULL_BIT] = + render_tab_flat_alpha_tricull; + + render_tabs_elt[0] = render_tab_elt; + render_tabs_elt[FFB_FLAT_BIT] = render_tab_flat_elt; + render_tabs_elt[FFB_ALPHA_BIT] = render_tab_alpha_elt; + render_tabs_elt[FFB_FLAT_BIT|FFB_ALPHA_BIT] = render_tab_flat_alpha_elt; + render_tabs_elt[FFB_TRI_CULL_BIT] = render_tab_tricull_elt; + render_tabs_elt[FFB_FLAT_BIT|FFB_TRI_CULL_BIT] = render_tab_flat_tricull_elt; + render_tabs_elt[FFB_ALPHA_BIT|FFB_TRI_CULL_BIT] = render_tab_alpha_tricull_elt; + render_tabs_elt[FFB_FLAT_BIT|FFB_ALPHA_BIT|FFB_TRI_CULL_BIT] = + render_tab_flat_alpha_tricull_elt; + + for (i = 0; i < MAX_FFB_RENDER_FUNCS; i++) { + tnl_render_func *rf = render_tabs[i]; + tnl_render_func *rfe = render_tabs_elt[i]; + + if (i & FFB_TRI_CULL_BIT) { + int from_idx = (i & ~FFB_TRI_CULL_BIT); + tnl_render_func *rf_from = render_tabs[from_idx]; + tnl_render_func *rfe_from = render_tabs_elt[from_idx]; + int j; + + for (j = GL_POINTS; j < GL_TRIANGLES; j++) { + rf[j] = rf_from[j]; + rfe[j] = rfe_from[j]; + } + } + } +} + +/**********************************************************************/ +/* Choose render functions */ +/**********************************************************************/ + +#ifdef FFB_RENDER_TRACE +static void ffbPrintRenderFlags(GLuint index, GLuint render_index) +{ + fprintf(stderr, + "ffbChooseRenderState: " + "index(%s%s%s) " + "render_index(%s%s%s)\n", + ((index & FFB_TWOSIDE_BIT) ? "twoside " : ""), + ((index & FFB_OFFSET_BIT) ? "offset " : ""), + ((index & FFB_UNFILLED_BIT) ? "unfilled " : ""), + ((render_index & FFB_FLAT_BIT) ? "flat " : ""), + ((render_index & FFB_ALPHA_BIT) ? "alpha " : ""), + ((render_index & FFB_TRI_CULL_BIT) ? "tricull " : "")); +} +#endif + +void ffbChooseRenderState(GLcontext *ctx) +{ + GLuint flags = ctx->_TriangleCaps; + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint index = 0; + + /* Per-primitive fallbacks and the selection of fmesa->draw_* are + * handled elsewhere. + */ + if (flags & DD_TRI_LIGHT_TWOSIDE) + index |= FFB_TWOSIDE_BIT; + + if (flags & DD_TRI_OFFSET) + index |= FFB_OFFSET_BIT; + + if (flags & DD_TRI_UNFILLED) + index |= FFB_UNFILLED_BIT; + + tnl->Driver.Render.Triangle = rast_tab[index].triangle; + tnl->Driver.Render.Quad = rast_tab[index].quad; + + if (index == 0) { + GLuint render_index = 0; + + if (flags & DD_FLATSHADE) + render_index |= FFB_FLAT_BIT; + + if (ctx->Color.BlendEnabled || ctx->Color.AlphaEnabled) + render_index |= FFB_ALPHA_BIT; + + if (ctx->Polygon.CullFlag) + render_index |= FFB_TRI_CULL_BIT; + +#ifdef FFB_RENDER_TRACE + ffbPrintRenderFlags(index, render_index); +#endif + tnl->Driver.Render.PrimTabVerts = render_tabs[render_index]; + tnl->Driver.Render.PrimTabElts = render_tabs_elt[render_index]; + } else { +#ifdef FFB_RENDER_TRACE + ffbPrintRenderFlags(index, 0); +#endif + tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts; + tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts; + } + + tnl->Driver.Render.ClippedPolygon = ffbRenderClippedPolygon; + tnl->Driver.Render.ClippedLine = ffbRenderClippedLine; +} + +static void ffbRunPipeline(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + if (fmesa->bad_fragment_attrs == 0 && + fmesa->new_gl_state) { + if (fmesa->new_gl_state & _FFB_NEW_TRIANGLE) + ffbChooseTriangleState(ctx); + if (fmesa->new_gl_state & _FFB_NEW_LINE) + ffbChooseLineState(ctx); + if (fmesa->new_gl_state & _FFB_NEW_POINT) + ffbChoosePointState(ctx); + if (fmesa->new_gl_state & _FFB_NEW_RENDER) + ffbChooseRenderState(ctx); + if (fmesa->new_gl_state & _FFB_NEW_VERTEX) + ffbChooseVertexState(ctx); + + fmesa->new_gl_state = 0; + } + + _tnl_run_pipeline(ctx); +} + +static void ffbRenderStart(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + LOCK_HARDWARE(fmesa); + fmesa->hw_locked = 1; + + if (fmesa->state_dirty != 0) + ffbSyncHardware(fmesa); +} + +static void ffbRenderFinish(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + UNLOCK_HARDWARE(fmesa); + fmesa->hw_locked = 0; +} + +/* Even when doing full software rendering we need to + * wrap render{start,finish} so that the hardware is kept + * in sync (because multipass rendering changes the write + * buffer etc.) + */ +static void ffbSWRenderStart(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + LOCK_HARDWARE(fmesa); + fmesa->hw_locked = 1; + + if (fmesa->state_dirty != 0) + ffbSyncHardware(fmesa); +} + +static void ffbSWRenderFinish(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + UNLOCK_HARDWARE(fmesa); + fmesa->hw_locked = 0; +} + +static void ffbRasterPrimitive(GLcontext *ctx, GLenum rprim) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLuint drawop, fbc, ppc; + int do_sw = 0; + + fmesa->raster_primitive = rprim; + + drawop = fmesa->drawop; + fbc = fmesa->fbc; + ppc = fmesa->ppc & ~(FFB_PPC_ZS_MASK | FFB_PPC_CS_MASK); + +#ifdef STATE_TRACE + fprintf(stderr, + "ffbReducedPrimitiveChange: rprim(%d) ", rprim); +#endif + switch(rprim) { + case GL_POINTS: +#ifdef STATE_TRACE + fprintf(stderr, "GL_POINTS "); +#endif + if (fmesa->draw_point == ffb_fallback_point) { + do_sw = 1; + break; + } + + if (ctx->Point.SmoothFlag) { + ppc |= (FFB_PPC_ZS_VAR | FFB_PPC_CS_CONST); + drawop = FFB_DRAWOP_AADOT; + } else { + ppc |= (FFB_PPC_ZS_CONST | FFB_PPC_CS_CONST); + drawop = FFB_DRAWOP_DOT; + } + break; + + case GL_LINES: +#ifdef STATE_TRACE + fprintf(stderr, "GL_LINES "); +#endif + if (fmesa->draw_line == ffb_fallback_line) { + do_sw = 1; + break; + } + + if (ctx->_TriangleCaps & DD_FLATSHADE) { + ppc |= FFB_PPC_ZS_VAR | FFB_PPC_CS_CONST; + } else { + ppc |= FFB_PPC_ZS_VAR | FFB_PPC_CS_VAR; + } + if (ctx->Line.SmoothFlag) + drawop = FFB_DRAWOP_AALINE; + else + drawop = FFB_DRAWOP_DDLINE; + break; + + case GL_TRIANGLES: +#ifdef STATE_TRACE + fprintf(stderr, "GL_POLYGON "); +#endif + if (fmesa->draw_tri == ffb_fallback_triangle) { + do_sw = 1; + break; + } + + ppc &= ~FFB_PPC_APE_MASK; + if (ctx->Polygon.StippleFlag) + ppc |= FFB_PPC_APE_ENABLE; + else + ppc |= FFB_PPC_APE_DISABLE; + + if (ctx->_TriangleCaps & DD_FLATSHADE) { + ppc |= FFB_PPC_ZS_VAR | FFB_PPC_CS_CONST; + } else { + ppc |= FFB_PPC_ZS_VAR | FFB_PPC_CS_VAR; + } + drawop = FFB_DRAWOP_TRIANGLE; + break; + + default: +#ifdef STATE_TRACE + fprintf(stderr, "unknown %d!\n", rprim); +#endif + return; + }; + +#ifdef STATE_TRACE + fprintf(stderr, "do_sw(%d) ", do_sw); +#endif + if (do_sw != 0) { + fbc &= ~(FFB_FBC_WB_C); + fbc &= ~(FFB_FBC_ZE_MASK | FFB_FBC_RGBE_MASK); + fbc |= FFB_FBC_ZE_OFF | FFB_FBC_RGBE_MASK; + ppc &= ~(FFB_PPC_XS_MASK | FFB_PPC_ABE_MASK | + FFB_PPC_DCE_MASK | FFB_PPC_APE_MASK); + ppc |= (FFB_PPC_ZS_VAR | FFB_PPC_CS_VAR | FFB_PPC_XS_WID | + FFB_PPC_ABE_DISABLE | FFB_PPC_DCE_DISABLE | + FFB_PPC_APE_DISABLE); + } else { + fbc |= FFB_FBC_WB_C; + fbc &= ~(FFB_FBC_RGBE_MASK); + fbc |= FFB_FBC_RGBE_MASK; + ppc &= ~(FFB_PPC_ABE_MASK | FFB_PPC_XS_MASK); + if (ctx->Color.BlendEnabled) { + if ((rprim == GL_POINTS && !ctx->Point.SmoothFlag) || + (rprim != GL_POINTS && ctx->_TriangleCaps & DD_FLATSHADE)) + ppc |= FFB_PPC_ABE_ENABLE | FFB_PPC_XS_CONST; + else + ppc |= FFB_PPC_ABE_ENABLE | FFB_PPC_XS_VAR; + } else { + ppc |= FFB_PPC_ABE_DISABLE | FFB_PPC_XS_WID; + } + } +#ifdef STATE_TRACE + fprintf(stderr, "fbc(%08x) ppc(%08x)\n", fbc, ppc); +#endif + + FFBFifo(fmesa, 4); + if (fmesa->drawop != drawop) + fmesa->regs->drawop = fmesa->drawop = drawop; + if (fmesa->fbc != fbc) + fmesa->regs->fbc = fmesa->fbc = fbc; + if (fmesa->ppc != ppc) + fmesa->regs->ppc = fmesa->ppc = ppc; + if (do_sw != 0) { + fmesa->regs->cmp = + (fmesa->cmp & ~(0xff<<16)) | (0x80 << 16); + } else + fmesa->regs->cmp = fmesa->cmp; +} + +static void ffbRenderPrimitive(GLcontext *ctx, GLenum prim) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLuint rprim = reduced_prim[prim]; + + fmesa->render_primitive = prim; + + if (rprim == GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED)) + return; + + if (fmesa->raster_primitive != rprim) { + ffbRasterPrimitive( ctx, rprim ); + } +} + + + + +/**********************************************************************/ +/* Transition to/from hardware rasterization. */ +/**********************************************************************/ + +static char *fallbackStrings[] = { + "Fog enabled", + "Blend function", + "Blend ROP", + "Blend equation", + "Stencil", + "Texture", + "LIBGL_SOFTWARE_RENDERING" +}; + +static char *getFallbackString(GLuint bit) +{ + int i = 0; + + while (bit > 1) { + i++; + bit >>= 1; + } + return fallbackStrings[i]; +} + +void ffbFallback( GLcontext *ctx, GLuint bit, GLboolean mode ) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint oldfallback = fmesa->bad_fragment_attrs; + + if (mode) { + fmesa->bad_fragment_attrs |= bit; + if (oldfallback == 0) { +/* FFB_FIREVERTICES(fmesa); */ + _swsetup_Wakeup( ctx ); + if (fmesa->debugFallbacks) + fprintf(stderr, "FFB begin software fallback: 0x%x %s\n", + bit, getFallbackString(bit)); + } + } else { + fmesa->bad_fragment_attrs &= ~bit; + if (oldfallback == bit) { + _swrast_flush( ctx ); + + tnl->Driver.Render.Start = ffbRenderStart; + tnl->Driver.Render.PrimitiveNotify = ffbRenderPrimitive; + tnl->Driver.Render.Finish = ffbRenderFinish; + fmesa->new_gl_state = ~0; + + /* Just re-choose everything: + */ + ffbChooseVertexState(ctx); + ffbChooseRenderState(ctx); + ffbChooseTriangleState(ctx); + ffbChooseLineState(ctx); + ffbChoosePointState(ctx); + + if (fmesa->debugFallbacks) + fprintf(stderr, "FFB end software fallback: 0x%x %s\n", + bit, getFallbackString(bit)); + } + } +} + +/**********************************************************************/ +/* Initialization. */ +/**********************************************************************/ + +void ffbDDInitRenderFuncs( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + SWcontext *swrast = SWRAST_CONTEXT(ctx); + static int firsttime = 1; + + if (firsttime) { + init_rast_tab(); + init_tri_tab(); + init_render_tab(); + firsttime = 0; + } + + tnl->Driver.RunPipeline = ffbRunPipeline; + tnl->Driver.Render.Start = ffbRenderStart; + tnl->Driver.Render.Finish = ffbRenderFinish; + tnl->Driver.Render.PrimitiveNotify = ffbRenderPrimitive; + tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple; + tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts; + tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts; + + swrast->Driver.SpanRenderStart = ffbSWRenderStart; + swrast->Driver.SpanRenderFinish = ffbSWRenderFinish; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tris.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tris.h new file mode 100644 index 000000000..a803174b3 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tris.h @@ -0,0 +1,26 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_tris.h,v 1.2 2002/02/22 21:32:59 dawes Exp $ */ + +#ifndef _FFB_TRIS_H +#define _FFB_TRIS_H + +extern void ffbDDInitRenderFuncs( GLcontext *ctx ); + + +#define _FFB_NEW_RENDER (_DD_NEW_TRI_LIGHT_TWOSIDE | \ + _DD_NEW_TRI_OFFSET | \ + _DD_NEW_TRI_UNFILLED) + +extern void ffbChooseRenderState(GLcontext *ctx); + + +#define _FFB_NEW_TRIANGLE (_DD_NEW_TRI_SMOOTH | \ + _DD_NEW_FLATSHADE | \ + _NEW_POLYGON | \ + _NEW_COLOR) + +extern void ffbChooseTriangleState(GLcontext *ctx); + +extern void ffbFallback( GLcontext *ctx, GLuint bit, GLboolean mode ); +#define FALLBACK( ctx, bit, mode ) ffbFallback( ctx, bit, mode ) + +#endif /* !(_FFB_TRIS_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tritmp.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tritmp.h new file mode 100644 index 000000000..612ef2433 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tritmp.h @@ -0,0 +1,239 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_tritmp.h,v 1.2 2002/02/22 21:32:59 dawes Exp $ */ + +static void TAG(ffb_triangle)( GLcontext *ctx, + ffb_vertex *v0, + ffb_vertex *v1, + ffb_vertex *v2 ) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_fbcPtr ffb = fmesa->regs; +#if (IND & FFB_TRI_FLAT_BIT) + GLuint const_fg; +#endif + FFB_DELAYED_VIEWPORT_VARS; + +#ifdef TRI_DEBUG + fprintf(stderr, "FFB: ffb_triangle [" +#if (IND & FFB_TRI_CULL_BIT) + " CULL" +#endif +#if (IND & FFB_TRI_FLAT_BIT) + " FLAT" +#endif +#if (IND & FFB_TRI_ALPHA_BIT) + " ALPHA" +#endif + " ]\n"); +#endif + +#if (IND & FFB_TRI_CULL_BIT) + { /* NOTE: These are not viewport transformed yet. */ + GLfloat ex = v1->x - v0->x; + GLfloat ey = v1->y - v0->y; + GLfloat fx = v2->x - v0->x; + GLfloat fy = v2->y - v0->y; + GLfloat c = ex*fy-ey*fx; + + /* Culled... */ + if (c * fmesa->backface_sign > fmesa->ffb_zero) + return; + } +#endif + +#if (IND & FFB_TRI_FLAT_BIT) + const_fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR( v2->color[0] ); +#ifdef TRI_DEBUG + fprintf(stderr, "FFB_tri: const_fg %08x (B[%f] G[%f] R[%f])\n", + const_fg, + FFB_2_30_FIXED_TO_FLOAT(v2->color[0].blue), + FFB_2_30_FIXED_TO_FLOAT(v2->color[0].green), + FFB_2_30_FIXED_TO_FLOAT(v2->color[0].red)); +#endif +#endif + + +#if (IND & FFB_TRI_FLAT_BIT) + FFBFifo(fmesa, 1); + ffb->fg = const_fg; +#endif + +#if (IND & FFB_TRI_FLAT_BIT) + FFBFifo(fmesa, 9); +#else +#if (IND & FFB_TRI_ALPHA_BIT) + FFBFifo(fmesa, 21); +#else + FFBFifo(fmesa, 18); +#endif +#endif + + FFB_DUMP_VERTEX(v0); +#if !(IND & FFB_TRI_FLAT_BIT) +#if (IND & FFB_TRI_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v0); +#endif + ffb->red = FFB_GET_RED(v0); + ffb->green = FFB_GET_GREEN(v0); + ffb->blue = FFB_GET_BLUE(v0); +#endif + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_DUMP_VERTEX(v1); +#if !(IND & FFB_TRI_FLAT_BIT) +#if (IND & FFB_TRI_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v1); +#endif + ffb->red = FFB_GET_RED(v1); + ffb->green = FFB_GET_GREEN(v1); + ffb->blue = FFB_GET_BLUE(v1); +#endif + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + FFB_DUMP_VERTEX(v2); +#if !(IND & FFB_TRI_FLAT_BIT) +#if (IND & FFB_TRI_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v2); +#endif + ffb->red = FFB_GET_RED(v2); + ffb->green = FFB_GET_GREEN(v2); + ffb->blue = FFB_GET_BLUE(v2); +#endif + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + + fmesa->ffbScreen->rp_active = 1; +} + + +static void TAG(ffb_quad)(GLcontext *ctx, + ffb_vertex *v0, + ffb_vertex *v1, + ffb_vertex *v2, + ffb_vertex *v3 ) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_fbcPtr ffb = fmesa->regs; +#if (IND & FFB_TRI_FLAT_BIT) + GLuint const_fg; +#endif + FFB_DELAYED_VIEWPORT_VARS; + +#ifdef TRI_DEBUG + fprintf(stderr, "FFB: ffb_quad [" +#if (IND & FFB_TRI_CULL_BIT) + " CULL" +#endif +#if (IND & FFB_TRI_FLAT_BIT) + " FLAT" +#endif +#if (IND & FFB_TRI_ALPHA_BIT) + " ALPHA" +#endif + " ]\n"); +#endif /* TRI_DEBUG */ + +#if (IND & FFB_TRI_CULL_BIT) + { /* NOTE: These are not viewport transformed yet. */ + GLfloat ex = v2->x - v0->x; + GLfloat ey = v2->y - v0->y; + GLfloat fx = v3->x - v1->x; + GLfloat fy = v3->y - v1->y; + GLfloat c = ex*fy-ey*fx; + + /* Culled... */ + if (c * fmesa->backface_sign > fmesa->ffb_zero) + return; + } +#endif + +#if (IND & FFB_TRI_FLAT_BIT) + const_fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR( v3->color[0] ); +#ifdef TRI_DEBUG + fprintf(stderr, "FFB_quad: const_fg %08x (B[%f] G[%f] R[%f])\n", + const_fg, + FFB_2_30_FIXED_TO_FLOAT(v3->color[0].blue), + FFB_2_30_FIXED_TO_FLOAT(v3->color[0].green), + FFB_2_30_FIXED_TO_FLOAT(v3->color[0].red)); +#endif +#endif + + +#if (IND & FFB_TRI_FLAT_BIT) + FFBFifo(fmesa, 13); + ffb->fg = const_fg; +#else +#if (IND & FFB_TRI_ALPHA_BIT) + FFBFifo(fmesa, 28); +#else + FFBFifo(fmesa, 24); +#endif +#endif + + FFB_DUMP_VERTEX(v0); +#if !(IND & FFB_TRI_FLAT_BIT) +#if (IND & FFB_TRI_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v0); +#endif + ffb->red = FFB_GET_RED(v0); + ffb->green = FFB_GET_GREEN(v0); + ffb->blue = FFB_GET_BLUE(v0); +#endif + ffb->z = FFB_GET_Z(v0); + ffb->ryf = FFB_GET_Y(v0); + ffb->rxf = FFB_GET_X(v0); + + FFB_DUMP_VERTEX(v1); +#if !(IND & FFB_TRI_FLAT_BIT) +#if (IND & FFB_TRI_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v1); +#endif + ffb->red = FFB_GET_RED(v1); + ffb->green = FFB_GET_GREEN(v1); + ffb->blue = FFB_GET_BLUE(v1); +#endif + ffb->z = FFB_GET_Z(v1); + ffb->y = FFB_GET_Y(v1); + ffb->x = FFB_GET_X(v1); + + FFB_DUMP_VERTEX(v2); +#if !(IND & FFB_TRI_FLAT_BIT) +#if (IND & FFB_TRI_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v2); +#endif + ffb->red = FFB_GET_RED(v2); + ffb->green = FFB_GET_GREEN(v2); + ffb->blue = FFB_GET_BLUE(v2); +#endif + ffb->z = FFB_GET_Z(v2); + ffb->y = FFB_GET_Y(v2); + ffb->x = FFB_GET_X(v2); + + FFB_DUMP_VERTEX(v3); +#if !(IND & FFB_TRI_FLAT_BIT) +#if (IND & FFB_TRI_ALPHA_BIT) + ffb->alpha = FFB_GET_ALPHA(v3); +#endif + ffb->red = FFB_GET_RED(v3); + ffb->green = FFB_GET_GREEN(v3); + ffb->blue = FFB_GET_BLUE(v3); +#endif + ffb->z = FFB_GET_Z(v3); + ffb->dmyf = FFB_GET_Y(v3); + ffb->dmxf = FFB_GET_X(v3); + + fmesa->ffbScreen->rp_active = 1; +} + +static void TAG(ffb_init)(void) +{ + ffb_tri_tab[IND] = TAG(ffb_triangle); + ffb_quad_tab[IND] = TAG(ffb_quad); +} + +#undef IND +#undef TAG diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vb.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vb.c new file mode 100644 index 000000000..6ba1eabbf --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vb.c @@ -0,0 +1,209 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_vb.c,v 1.4 2002/02/22 21:32:59 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000, 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "ffb_xmesa.h" +#include "ffb_context.h" +#include "ffb_vb.h" +#include "imports.h" +#include "tnl/t_context.h" +#include "swrast_setup/swrast_setup.h" +#include "math/m_translate.h" + +#undef VB_DEBUG + +static void ffb_copy_pv_oneside(GLcontext *ctx, GLuint edst, GLuint esrc) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_vertex *dst = &fmesa->verts[edst]; + ffb_vertex *src = &fmesa->verts[esrc]; + +#ifdef VB_DEBUG + fprintf(stderr, "ffb_copy_pv_oneside: edst(%d) esrc(%d)\n", edst, esrc); +#endif + dst->color[0].alpha = src->color[0].alpha; + dst->color[0].red = src->color[0].red; + dst->color[0].green = src->color[0].green; + dst->color[0].blue = src->color[0].blue; +} + +static void ffb_copy_pv_twoside(GLcontext *ctx, GLuint edst, GLuint esrc) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + ffb_vertex *dst = &fmesa->verts[edst]; + ffb_vertex *src = &fmesa->verts[esrc]; + +#ifdef VB_DEBUG + fprintf(stderr, "ffb_copy_pv_twoside: edst(%d) esrc(%d)\n", edst, esrc); +#endif + dst->color[0].alpha = src->color[0].alpha; + dst->color[0].red = src->color[0].red; + dst->color[0].green = src->color[0].green; + dst->color[0].blue = src->color[0].blue; + dst->color[1].alpha = src->color[1].alpha; + dst->color[1].red = src->color[1].red; + dst->color[1].green = src->color[1].green; + dst->color[1].blue = src->color[1].blue; +} + +#define FFB_VB_RGBA_BIT 0x01 +#define FFB_VB_XYZ_BIT 0x02 +#define FFB_VB_TWOSIDE_BIT 0x04 +#define FFB_VB_MAX 0x08 + +typedef void (*ffb_emit_func)(GLcontext *, GLuint, GLuint); + +static struct { + ffb_emit_func emit; + tnl_interp_func interp; +} setup_tab[FFB_VB_MAX]; + + +#define IND (FFB_VB_XYZ_BIT) +#define TAG(x) x##_w +#include "ffb_vbtmp.h" + +#define IND (FFB_VB_RGBA_BIT) +#define TAG(x) x##_g +#include "ffb_vbtmp.h" + +#define IND (FFB_VB_XYZ_BIT | FFB_VB_RGBA_BIT) +#define TAG(x) x##_wg +#include "ffb_vbtmp.h" + +#define IND (FFB_VB_TWOSIDE_BIT) +#define TAG(x) x##_t +#include "ffb_vbtmp.h" + +#define IND (FFB_VB_XYZ_BIT | FFB_VB_TWOSIDE_BIT) +#define TAG(x) x##_wt +#include "ffb_vbtmp.h" + +#define IND (FFB_VB_RGBA_BIT | FFB_VB_TWOSIDE_BIT) +#define TAG(x) x##_gt +#include "ffb_vbtmp.h" + +#define IND (FFB_VB_XYZ_BIT | FFB_VB_RGBA_BIT | FFB_VB_TWOSIDE_BIT) +#define TAG(x) x##_wgt +#include "ffb_vbtmp.h" + +static void init_setup_tab( void ) +{ + init_w(); + init_g(); + init_wg(); + init_t(); + init_wt(); + init_gt(); + init_wgt(); +} + +#ifdef VB_DEBUG +static void ffbPrintSetupFlags(char *msg, GLuint flags) +{ + fprintf(stderr, "%s(%x): %s%s%s\n", + msg, + (int)flags, + (flags & FFB_VB_XYZ_BIT) ? " xyz," : "", + (flags & FFB_VB_RGBA_BIT) ? " rgba," : "", + (flags & FFB_VB_TWOSIDE_BIT) ? " twoside," : ""); +} +#endif + +static void ffbDDBuildVertices(GLcontext *ctx, GLuint start, GLuint count, + GLuint newinputs) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + newinputs |= fmesa->setupnewinputs; + fmesa->setupnewinputs = 0; + + if (!newinputs) + return; + + if (newinputs & VERT_BIT_POS) { + setup_tab[fmesa->setupindex].emit(ctx, start, count); + } else { + GLuint ind = 0; + + if (newinputs & VERT_BIT_COLOR0) + ind |= (FFB_VB_RGBA_BIT | FFB_VB_TWOSIDE_BIT); + + ind &= fmesa->setupindex; + + if (ind) + setup_tab[ind].emit(ctx, start, count); + } +} + +void ffbChooseVertexState( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + int ind = FFB_VB_XYZ_BIT | FFB_VB_RGBA_BIT; + + if (ctx->_TriangleCaps & DD_TRI_LIGHT_TWOSIDE) + ind |= FFB_VB_TWOSIDE_BIT; + +#ifdef VB_DEBUG + ffbPrintSetupFlags("ffb: full setup function", ind); +#endif + + fmesa->setupindex = ind; + + tnl->Driver.Render.BuildVertices = ffbDDBuildVertices; + tnl->Driver.Render.Interp = setup_tab[ind].interp; + if (ind & FFB_VB_TWOSIDE_BIT) + tnl->Driver.Render.CopyPV = ffb_copy_pv_twoside; + else + tnl->Driver.Render.CopyPV = ffb_copy_pv_oneside; +} + +void ffbInitVB( GLcontext *ctx ) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLuint size = TNL_CONTEXT(ctx)->vb.Size; + + fmesa->verts = (ffb_vertex *)ALIGN_MALLOC(size * sizeof(ffb_vertex), 32); + + { + static int firsttime = 1; + if (firsttime) { + init_setup_tab(); + firsttime = 0; + } + } +} + + +void ffbFreeVB( GLcontext *ctx ) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + if (fmesa->verts) { + ALIGN_FREE(fmesa->verts); + fmesa->verts = 0; + } +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vb.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vb.h new file mode 100644 index 000000000..9eb6759f6 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vb.h @@ -0,0 +1,45 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_vb.h,v 1.2 2002/02/22 21:32:59 dawes Exp $ */ + +#ifndef _FFB_VB_H +#define _FFB_VB_H + +#include "mtypes.h" +#include "macros.h" +#include "tnl/t_context.h" +#include "swrast/swrast.h" + +#define __FFB_2_30_FIXED_SCALE 1073741824.0f +#define FFB_2_30_FLOAT_TO_FIXED(X) \ + (IROUND((X) * fmesa->ffb_2_30_fixed_scale)) +#define FFB_2_30_FIXED_TO_FLOAT(X) \ + (((GLfloat)(X)) * fmesa->ffb_one_over_2_30_fixed_scale) + +#define __FFB_16_16_FIXED_SCALE 65536.0f +#define FFB_16_16_FLOAT_TO_FIXED(X) \ + (IROUND((X) * fmesa->ffb_16_16_fixed_scale)) +#define FFB_16_16_FIXED_TO_FLOAT(X) \ + (((GLfloat)(X)) * fmesa->ffb_one_over_16_16_fixed_scale) + +#define FFB_Z_FROM_FLOAT(VAL) FFB_2_30_FLOAT_TO_FIXED(VAL) +#define FFB_Z_TO_FLOAT(VAL) FFB_2_30_FIXED_TO_FLOAT(VAL) +#define FFB_XY_FROM_FLOAT(VAL) FFB_16_16_FLOAT_TO_FIXED(VAL) +#define FFB_XY_TO_FLOAT(VAL) FFB_16_16_FIXED_TO_FLOAT(VAL) + +#define FFB_UBYTE_FROM_COLOR(VAL) ((IROUND((VAL) * fmesa->ffb_ubyte_color_scale))) + +#define FFB_PACK_CONST_UBYTE_ARGB_COLOR(C) \ + ((FFB_UBYTE_FROM_COLOR(C.alpha) << 24) | \ + (FFB_UBYTE_FROM_COLOR(C.blue) << 16) | \ + (FFB_UBYTE_FROM_COLOR(C.green) << 8) | \ + (FFB_UBYTE_FROM_COLOR(C.red) << 0)) + +#define FFB_COLOR_FROM_FLOAT(VAL) FFB_2_30_FLOAT_TO_FIXED(VAL) + +#define _FFB_NEW_VERTEX (_DD_NEW_TRI_LIGHT_TWOSIDE) + +extern void ffbDDSetupInit(void); +extern void ffbChooseVertexState(GLcontext *); +extern void ffbInitVB( GLcontext *ctx ); +extern void ffbFreeVB( GLcontext *ctx ); + +#endif /* !(_FFB_VB_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vbtmp.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vbtmp.h new file mode 100644 index 000000000..a1d1254d9 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vbtmp.h @@ -0,0 +1,151 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_vbtmp.h,v 1.1 2002/02/22 21:32:59 dawes Exp $ */ + +static void TAG(emit)(GLcontext *ctx, GLuint start, GLuint end) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); +#if defined(VB_DEBUG) || (IND & (FFB_VB_XYZ_BIT | FFB_VB_RGBA_BIT)) + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; +#endif +#if (IND & (FFB_VB_RGBA_BIT)) + GLfloat (*col0)[4]; + GLuint col0_stride; +#if (IND & (FFB_VB_TWOSIDE_BIT)) + GLfloat (*col1)[4]; + GLuint col1_stride; +#endif +#endif +#if (IND & FFB_VB_XYZ_BIT) + GLfloat (*proj)[4] = VB->NdcPtr->data; + GLuint proj_stride = VB->NdcPtr->stride; + const GLubyte *mask = VB->ClipMask; +#endif + ffb_vertex *v = &fmesa->verts[start]; + int i; + +#ifdef VB_DEBUG + fprintf(stderr, "FFB: ffb_emit [" +#if (IND & (FFB_VB_XYZ_BIT)) + " XYZ" +#endif +#if (IND & (FFB_VB_RGBA_BIT)) + " RGBA" +#endif +#if (IND & (FFB_VB_TWOSIDE_BIT)) + " TWOSIDE" +#endif + "] start(%d) end(%d) import(%d)\n", + start, end, + VB->importable_data); +#endif + +#if (IND & (FFB_VB_RGBA_BIT)) + col0 = VB->ColorPtr[0]->data; + col0_stride = VB->ColorPtr[0]->stride; +#if (IND & (FFB_VB_TWOSIDE_BIT)) + col1 = VB->ColorPtr[1]->data; + col1_stride = VB->ColorPtr[1]->stride; +#endif +#endif + + { + if (start) { +#if (IND & (FFB_VB_XYZ_BIT)) + proj = (GLfloat (*)[4])((GLubyte *)proj + start * proj_stride); +#endif +#if (IND & (FFB_VB_RGBA_BIT)) + col0 = (GLfloat (*)[4])((GLubyte *)col0 + start * col0_stride); +#if (IND & (FFB_VB_TWOSIDE_BIT)) + col1 = (GLfloat (*)[4])((GLubyte *)col1 + start * col1_stride); +#endif +#endif + } + for (i = start; i < end; i++, v++) { +#if (IND & (FFB_VB_XYZ_BIT)) + if (mask[i] == 0) { + v->x = proj[0][0]; + v->y = proj[0][1]; + v->z = proj[0][2]; + } + proj = (GLfloat (*)[4])((GLubyte *)proj + proj_stride); +#endif +#if (IND & (FFB_VB_RGBA_BIT)) + v->color[0].alpha = CLAMP(col0[0][3], 0.0f, 1.0f); + v->color[0].red = CLAMP(col0[0][0], 0.0f, 1.0f); + v->color[0].green = CLAMP(col0[0][1], 0.0f, 1.0f); + v->color[0].blue = CLAMP(col0[0][2], 0.0f, 1.0f); + col0 = (GLfloat (*)[4])((GLubyte *)col0 + col0_stride); +#if (IND & (FFB_VB_TWOSIDE_BIT)) + v->color[1].alpha = CLAMP(col1[0][3], 0.0f, 1.0f); + v->color[1].red = CLAMP(col1[0][0], 0.0f, 1.0f); + v->color[1].green = CLAMP(col1[0][1], 0.0f, 1.0f); + v->color[1].blue = CLAMP(col1[0][2], 0.0f, 1.0f); + col1 = (GLfloat (*)[4])((GLubyte *)col1 + col1_stride); +#endif +#endif + } + } +} + +static void TAG(interp)(GLcontext *ctx, GLfloat t, + GLuint edst, GLuint eout, GLuint ein, + GLboolean force_boundary) +{ +#if (IND & (FFB_VB_XYZ_BIT | FFB_VB_RGBA_BIT)) + ffbContextPtr fmesa = FFB_CONTEXT(ctx); +#endif +#if (IND & (FFB_VB_XYZ_BIT)) + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + const GLfloat *dstclip = VB->ClipPtr->data[edst]; + GLfloat oow = 1.0 / dstclip[3]; +#endif +#if (IND & (FFB_VB_XYZ_BIT | FFB_VB_RGBA_BIT)) + ffb_vertex *dst = &fmesa->verts[edst]; +#endif +#if (IND & (FFB_VB_RGBA_BIT)) + ffb_vertex *in = &fmesa->verts[eout]; + ffb_vertex *out = &fmesa->verts[ein]; +#endif + +#ifdef VB_DEBUG + fprintf(stderr, "FFB: ffb_interp [" +#if (IND & (FFB_VB_XYZ_BIT)) + " XYZ" +#endif +#if (IND & (FFB_VB_RGBA_BIT)) + " RGBA" +#endif +#if (IND & (FFB_VB_TWOSIDE_BIT)) + " TWOSIDE" +#endif + "] edst(%d) eout(%d) ein(%d)\n", + edst, eout, ein); +#endif + +#if (IND & (FFB_VB_XYZ_BIT)) + dst->x = dstclip[0] * oow; + dst->y = dstclip[1] * oow; + dst->z = dstclip[2] * oow; +#endif + +#if (IND & (FFB_VB_RGBA_BIT)) + INTERP_F(t, dst->color[0].alpha, out->color[0].alpha, in->color[0].alpha); + INTERP_F(t, dst->color[0].red, out->color[0].red, in->color[0].red); + INTERP_F(t, dst->color[0].green, out->color[0].green, in->color[0].green); + INTERP_F(t, dst->color[0].blue, out->color[0].blue, in->color[0].blue); +#if (IND & (FFB_VB_TWOSIDE_BIT)) + INTERP_F(t, dst->color[1].alpha, out->color[1].alpha, in->color[1].alpha); + INTERP_F(t, dst->color[1].red, out->color[1].red, in->color[1].red); + INTERP_F(t, dst->color[1].green, out->color[1].green, in->color[1].green); + INTERP_F(t, dst->color[1].blue, out->color[1].blue, in->color[1].blue); +#endif +#endif +} + +static void TAG(init)(void) +{ + setup_tab[IND].emit = TAG(emit); + setup_tab[IND].interp = TAG(interp); +} + +#undef IND +#undef TAG diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vtxfmt.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vtxfmt.c new file mode 100644 index 000000000..d6a61d98e --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vtxfmt.c @@ -0,0 +1,427 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_vtxfmt.c,v 1.1 2002/02/22 21:32:59 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "glheader.h" +#include "api_noop.h" +#include "context.h" +#include "light.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" +#include "simple_list.h" +#include "vtxfmt.h" +#include "ffb_xmesa.h" +#include "ffb_context.h" +#include "ffb_vb.h" +#include "tnl/tnl.h" +#include "tnl/t_context.h" + +#include "ffb_vtxfmt.h" + +#ifndef __GNUC__ +#define __inline /**/ +#endif + +#define TNL_VERTEX ffbTnlVertex + +#define INTERP_RGBA(t, out, a, b) \ +do { \ + GLint i; \ + for ( i = 0 ; i < 4 ; i++ ) { \ + GLfloat fa = a[i]; \ + GLfloat fb = b[i]; \ + out[i] = LINTERP( t, fa, fb ); \ + } \ +} while (0) + +/* Color functions: */ + +static __inline void ffb_recalc_base_color(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + struct gl_light *light; + + COPY_3V(fmesa->vtx_state.light.base_color, ctx->Light._BaseColor[0]); + foreach (light, &ctx->Light.EnabledList) { + ACC_3V(fmesa->vtx_state.light.base_color, + light->_MatAmbient[0]); + } + + fmesa->vtx_state.light.base_alpha = ctx->Light._BaseAlpha[0]; +} + +#define GET_CURRENT \ + GET_CURRENT_CONTEXT(ctx); \ + ffbContextPtr fmesa = FFB_CONTEXT(ctx) + +#define CURRENT_COLOR(COMP) fmesa->vtx_state.current.color[COMP] +#define CURRENT_SPECULAR(COMP) fmesa->vtx_state.current.specular[COMP] +#define COLOR_IS_FLOAT +#define RECALC_BASE_COLOR(ctx) ffb_recalc_base_color(ctx) + +#define TAG(x) ffb_##x +#include "tnl_dd/t_dd_imm_capi.h" + +/* Normal functions: */ + +struct ffb_norm_tab { + void (*normal3f_multi)(GLfloat x, GLfloat y, GLfloat z); + void (*normal3fv_multi)(const GLfloat *v); + void (*normal3f_single)(GLfloat x, GLfloat y, GLfloat z); + void (*normal3fv_single)(const GLfloat *v); +}; + +static struct ffb_norm_tab norm_tab[0x4]; + +#define HAVE_HW_LIGHTING 0 +#define GET_CURRENT_VERTEX \ + GET_CURRENT_CONTEXT(ctx); \ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); \ + ffbTnlVertexPtr v = fmesa->imm.v0 + +#define CURRENT_NORMAL fmesa->vtx_state.current.normal +#define BASE_COLOR fmesa->vtx_state.light.base_color +#define BASE_ALPHA fmesa->vtx_state.light.base_alpha +#define VERT_COLOR( COMP ) v->color[COMP] +#define VERT_COLOR_IS_FLOAT + +#define IND (0) +#define TAG(x) ffb_##x +#define PRESERVE_NORMAL_DEFS +#include "tnl_dd/t_dd_imm_napi.h" + +#define IND (NORM_RESCALE) +#define TAG(x) ffb_##x##_rescale +#define PRESERVE_NORMAL_DEFS +#include "tnl_dd/t_dd_imm_napi.h" + +#define IND (NORM_NORMALIZE) +#define TAG(x) ffb_##x##_normalize +#include "tnl_dd/t_dd_imm_napi.h" + +static void ffb_init_norm_funcs(void) +{ + ffb_init_norm(); + ffb_init_norm_rescale(); + ffb_init_norm_normalize(); +} + +static void choose_normals(void) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint index; + + if (ctx->Light.Enabled) { + if (ctx->Transform.Normalize) { + index = NORM_NORMALIZE; + } else if (!ctx->Transform.RescaleNormals && + ctx->_ModelViewInvScale != 1.0) { + index = NORM_RESCALE; + } else { + index = 0; + } + + if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev) { + SET_Normal3f(ctx->Exec, norm_tab[index].normal3f_single); + SET_Normal3fv(ctx->Exec, norm_tab[index].normal3fv_single); + } else { + SET_Normal3f(ctx->Exec, norm_tab[index].normal3f_multi); + SET_Normal3fv(ctx->Exec, norm_tab[index].normal3fv_multi); + } + } else { + SET_Normal3f(ctx->Exec, _mesa_noop_Normal3f); + SET_Normal3fv(ctx->Exec, _mesa_noop_Normal3fv); + } +} + +static void ffb_choose_Normal3f(GLfloat x, GLfloat y, GLfloat z) +{ + choose_normals(); + CALL_Normal3f(GET_DISPATCH(), (x, y, z)); +} + +static void ffb_choose_Normal3fv(const GLfloat *v) +{ + choose_normals(); + CALL_Normal3fv(GET_DISPATCH(), (v)); +} + +/* Vertex functions: */ + +#define GET_CURRENT_VERTEX \ + GET_CURRENT_CONTEXT(ctx); \ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); \ + ffbTnlVertexPtr v = fmesa->imm.v0 + +#define CURRENT_VERTEX v->obj +#define SAVE_VERTEX fmesa->imm.save_vertex(ctx, v) + +#define TAG(x) ffb_##x +#include "tnl_dd/t_dd_imm_vapi.h" + +struct ffb_vert_tab { + void (*save_vertex)(GLcontext *ctx, ffbTnlVertexPtr v); + void (*interpolate_vertex)(GLfloat t, + ffbTnlVertex *O, + const ffbTnlVertex *I, + const ffbTnlVertex *J); +}; + +static struct ffb_vert_tab vert_tab[0xf]; + +#define VTX_NORMAL 0x0 +#define VTX_RGBA 0x1 + +#define LOCAL_VARS \ + ffbContextPtr fmesa = FFB_CONTEXT(ctx) + +#define CURRENT_COLOR fmesa->vtx_state.current.color +#define COLOR_IS_FLOAT +#define FLUSH_VERTEX fmesa->imm.flush_vertex( ctx, v ); + +#define IND (VTX_NORMAL) +#define TAG(x) ffb_##x##_NORMAL +#define PRESERVE_VERTEX_DEFS +#include "tnl_dd/t_dd_imm_vertex.h" + +#define IND (VTX_RGBA) +#define TAG(x) ffb_##x##_RGBA +#include "tnl_dd/t_dd_imm_vertex.h" + +static void ffb_init_vert_funcs( void ) +{ + ffb_init_vert_NORMAL(); + ffb_init_vert_RGBA(); +} + +#define LOCAL_VARS \ + ffbContextPtr fmesa = FFB_CONTEXT(ctx) + +#define GET_INTERP_FUNC \ + ffb_interp_func interp = fmesa->imm.interp + +#define FLUSH_VERTEX fmesa->imm.flush_vertex +#define IMM_VERTEX( V ) fmesa->imm.V +#define IMM_VERTICES( n ) fmesa->imm.vertices[n] + +#define EMIT_VERTEX_USES_HWREGS + +/* XXX Implement me XXX */ +#define EMIT_VERTEX_TRI(VTX0, VTX1, VTX2) \ + do { } while (0) +#define EMIT_VERTEX_LINE(VTX0, VTX1) \ + do { } while (0) +#define EMIT_VERTEX_POINT(VTX0) \ + do { } while (0) + +#define TAG(x) ffb_##x +#include "tnl_dd/t_dd_imm_primtmp.h" + +/* Bzzt: Material changes are lost on fallback. */ +static void ffb_Materialfv(GLenum face, GLenum pname, + const GLfloat *params) +{ + GET_CURRENT_CONTEXT(ctx); + + _mesa_noop_Materialfv( face, pname, params ); + ffb_recalc_base_color( ctx ); +} + +/* Fallback functions: */ + +static void ffb_do_fallback(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + struct ffb_current_state *current = &fmesa->vtx_state.current; + + /* Tell tnl to restore its exec vtxfmt, rehook its driver callbacks + * and revive internal state that depended on those callbacks: + */ + _tnl_wakeup_exec(ctx); + + /* Replay enough vertices that the current primitive is continued + * correctly: + */ + if (fmesa->imm.prim != PRIM_OUTSIDE_BEGIN_END ) + CALL_Begin(GET_DISPATCH(), (fmesa->imm.prim)); + + if (ctx->Light.Enabled) { + /* Catch ColorMaterial */ + CALL_Color4fv(GET_DISPATCH(), (ctx->Current.Color)); + CALL_Normal3fv(GET_DISPATCH(), (current->normal)); + } else { + CALL_Color4fv(GET_DISPATCH(), (current->color)); + } +} + +#define PRE_LOOPBACK( FUNC ) do { \ + GET_CURRENT_CONTEXT(ctx); \ + ffb_do_fallback( ctx ); \ +} while (0) + +#define TAG(x) ffb_fallback_##x +#include "vtxfmt_tmp.h" + +static void ffb_Begin(GLenum prim) +{ + GET_CURRENT_CONTEXT(ctx); + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + if (prim > GL_POLYGON) { + _mesa_error( ctx, GL_INVALID_ENUM, "glBegin" ); + return; + } + + if (fmesa->imm.prim != PRIM_OUTSIDE_BEGIN_END) { + _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" ); + return; + } + + ctx->Driver.NeedFlush |= (FLUSH_STORED_VERTICES | + FLUSH_UPDATE_CURRENT); + + fmesa->imm.prim = prim; + fmesa->imm.v0 = &fmesa->imm.vertices[0]; + fmesa->imm.save_vertex = ffb_save_vertex_RGBA; + fmesa->imm.flush_vertex = ffb_flush_tab[prim]; + + /* XXX Lock hardware, update FBC, PPC, DRAWOP, etc. XXX */ +} + +static void ffb_End(void) +{ + GET_CURRENT_CONTEXT(ctx); + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + + if (fmesa->imm.prim == PRIM_OUTSIDE_BEGIN_END) { + _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" ); + return; + } + + fmesa->imm.prim = PRIM_OUTSIDE_BEGIN_END; + + ctx->Driver.NeedFlush &= ~(FLUSH_STORED_VERTICES | + FLUSH_UPDATE_CURRENT); + + /* XXX Unlock hardware, etc. */ +} + +void ffbInitTnlModule(GLcontext *ctx) +{ + ffbContextPtr fmesa = FFB_CONTEXT(ctx); + GLvertexformat *vfmt = &(fmesa->imm.vtxfmt); + + /* Work in progress... */ + return; + + ffb_init_norm_funcs(); + ffb_init_vert_funcs(); + + MEMSET(vfmt, 0, sizeof(GLvertexformat)); + + /* Handled fully in supported states: */ + vfmt->ArrayElement = NULL; /* FIXME: ... */ + vfmt->Color3f = ffb_choose_Color3f; + vfmt->Color3fv = ffb_choose_Color3fv; + vfmt->Color3ub = ffb_choose_Color3ub; + vfmt->Color3ubv = ffb_choose_Color3ubv; + vfmt->Color4f = ffb_choose_Color4f; + vfmt->Color4fv = ffb_choose_Color4fv; + vfmt->Color4ub = ffb_choose_Color4ub; + vfmt->Color4ubv = ffb_choose_Color4ubv; + vfmt->FogCoordfvEXT = ffb_FogCoordfvEXT; + vfmt->FogCoordfEXT = ffb_FogCoordfEXT; + vfmt->Materialfv = ffb_Materialfv; + vfmt->MultiTexCoord1fARB = ffb_fallback_MultiTexCoord1fARB; + vfmt->MultiTexCoord1fvARB = ffb_fallback_MultiTexCoord1fvARB; + vfmt->MultiTexCoord2fARB = ffb_fallback_MultiTexCoord2fARB; + vfmt->MultiTexCoord2fvARB = ffb_fallback_MultiTexCoord2fvARB; + vfmt->MultiTexCoord3fARB = ffb_fallback_MultiTexCoord3fARB; + vfmt->MultiTexCoord3fvARB = ffb_fallback_MultiTexCoord3fvARB; + vfmt->MultiTexCoord4fARB = ffb_fallback_MultiTexCoord4fARB; + vfmt->MultiTexCoord4fvARB = ffb_fallback_MultiTexCoord4fvARB; + vfmt->Normal3f = ffb_choose_Normal3f; + vfmt->Normal3fv = ffb_choose_Normal3fv; + vfmt->SecondaryColor3ubEXT = ffb_SecondaryColor3ubEXT; + vfmt->SecondaryColor3ubvEXT = ffb_SecondaryColor3ubvEXT; + vfmt->SecondaryColor3fEXT = ffb_SecondaryColor3fEXT; + vfmt->SecondaryColor3fvEXT = ffb_SecondaryColor3fvEXT; + vfmt->TexCoord1f = ffb_fallback_TexCoord1f; + vfmt->TexCoord1fv = ffb_fallback_TexCoord1fv; + vfmt->TexCoord2f = ffb_fallback_TexCoord2f; + vfmt->TexCoord2fv = ffb_fallback_TexCoord2fv; + vfmt->TexCoord3f = ffb_fallback_TexCoord3f; + vfmt->TexCoord3fv = ffb_fallback_TexCoord3fv; + vfmt->TexCoord4f = ffb_fallback_TexCoord4f; + vfmt->TexCoord4fv = ffb_fallback_TexCoord4fv; + + vfmt->Vertex2f = ffb_Vertex2f; + vfmt->Vertex2fv = ffb_Vertex2fv; + vfmt->Vertex3f = ffb_Vertex3f; + vfmt->Vertex3fv = ffb_Vertex3fv; + vfmt->Vertex4f = ffb_Vertex4f; + vfmt->Vertex4fv = ffb_Vertex4fv; + + vfmt->Begin = ffb_Begin; + vfmt->End = ffb_End; + + vfmt->Rectf = _mesa_noop_Rectf; /* generic helper */ + + vfmt->DrawArrays = NULL; + vfmt->DrawElements = NULL; + vfmt->DrawRangeElements = _mesa_noop_DrawRangeElements; /* discard range */ + + + /* Not active in supported states; just keep ctx->Current uptodate: */ + vfmt->EdgeFlag = _mesa_noop_EdgeFlag; + vfmt->EdgeFlagv = _mesa_noop_EdgeFlagv; + vfmt->Indexi = _mesa_noop_Indexi; + vfmt->Indexiv = _mesa_noop_Indexiv; + + /* Active but unsupported -- fallback if we receive these: + * + * All of these fallbacks can be fixed with additional code, except + * CallList, unless we build a play_immediate_noop() command which + * turns an immediate back into glBegin/glEnd commands... + */ + vfmt->CallList = ffb_fallback_CallList; + vfmt->EvalCoord1f = ffb_fallback_EvalCoord1f; + vfmt->EvalCoord1fv = ffb_fallback_EvalCoord1fv; + vfmt->EvalCoord2f = ffb_fallback_EvalCoord2f; + vfmt->EvalCoord2fv = ffb_fallback_EvalCoord2fv; + vfmt->EvalMesh1 = ffb_fallback_EvalMesh1; + vfmt->EvalMesh2 = ffb_fallback_EvalMesh2; + vfmt->EvalPoint1 = ffb_fallback_EvalPoint1; + vfmt->EvalPoint2 = ffb_fallback_EvalPoint2; + + vfmt->prefer_float_colors = GL_TRUE; + + fmesa->imm.prim = PRIM_OUTSIDE_BEGIN_END; + + /* THIS IS A HACK! */ + _mesa_install_exec_vtxfmt( ctx, vfmt ); +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vtxfmt.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vtxfmt.h new file mode 100644 index 000000000..063bb4923 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vtxfmt.h @@ -0,0 +1,8 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_vtxfmt.h,v 1.1 2002/02/22 21:32:59 dawes Exp $ */ + +#ifndef _FFB_VTXFMT_H +#define _FFB_VTXFMT_H + +extern void ffbInitTnlModule(GLcontext *); + +#endif /* !(_FFB_VTXFMT_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_xmesa.c b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_xmesa.c new file mode 100644 index 000000000..530c5373a --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_xmesa.c @@ -0,0 +1,753 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_xmesa.c,v 1.4 2002/02/22 21:32:59 dawes Exp $ + * + * GLX Hardware Device Driver for Sun Creator/Creator3D + * Copyright (C) 2000, 2001 David S. Miller + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * David S. Miller <davem@redhat.com> + */ + +#include "ffb_xmesa.h" +#include "context.h" +#include "framebuffer.h" +#include "matrix.h" +#include "renderbuffer.h" +#include "simple_list.h" +#include "imports.h" +#include "utils.h" + +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" +#include "tnl/tnl.h" +#include "tnl/t_pipeline.h" +#include "array_cache/acache.h" +#include "drivers/common/driverfuncs.h" + +#include "ffb_context.h" +#include "ffb_dd.h" +#include "ffb_span.h" +#include "ffb_depth.h" +#include "ffb_stencil.h" +#include "ffb_clear.h" +#include "ffb_vb.h" +#include "ffb_tris.h" +#include "ffb_lines.h" +#include "ffb_points.h" +#include "ffb_state.h" +#include "ffb_tex.h" +#include "ffb_lock.h" +#include "ffb_vtxfmt.h" +#include "ffb_bitmap.h" + +#include "drm_sarea.h" + +static GLboolean +ffbInitDriver(__DRIscreenPrivate *sPriv) +{ + ffbScreenPrivate *ffbScreen; + FFBDRIPtr gDRIPriv = (FFBDRIPtr) sPriv->pDevPriv; + drmAddress map; + + if (getenv("LIBGL_FORCE_XSERVER")) + return GL_FALSE; + + + if (sPriv->devPrivSize != sizeof(FFBDRIRec)) { + fprintf(stderr,"\nERROR! sizeof(FFBDRIRec) does not match passed size from device driver\n"); + return GL_FALSE; + } + + /* Allocate the private area. */ + ffbScreen = (ffbScreenPrivate *) MALLOC(sizeof(ffbScreenPrivate)); + if (!ffbScreen) + return GL_FALSE; + + /* Map FBC registers. */ + if (drmMap(sPriv->fd, + gDRIPriv->hFbcRegs, + gDRIPriv->sFbcRegs, + &map)) { + FREE(ffbScreen); + return GL_FALSE; + } + ffbScreen->regs = (ffb_fbcPtr) map; + + /* Map ramdac registers. */ + if (drmMap(sPriv->fd, + gDRIPriv->hDacRegs, + gDRIPriv->sDacRegs, + &map)) { + drmUnmap((drmAddress)ffbScreen->regs, gDRIPriv->sFbcRegs); + FREE(ffbScreen); + return GL_FALSE; + } + ffbScreen->dac = (ffb_dacPtr) map; + + /* Map "Smart" framebuffer views. */ + if (drmMap(sPriv->fd, + gDRIPriv->hSfb8r, + gDRIPriv->sSfb8r, + &map)) { + drmUnmap((drmAddress)ffbScreen->regs, gDRIPriv->sFbcRegs); + drmUnmap((drmAddress)ffbScreen->dac, gDRIPriv->sDacRegs); + FREE(ffbScreen); + return GL_FALSE; + } + ffbScreen->sfb8r = (volatile char *) map; + + if (drmMap(sPriv->fd, + gDRIPriv->hSfb32, + gDRIPriv->sSfb32, + &map)) { + drmUnmap((drmAddress)ffbScreen->regs, gDRIPriv->sFbcRegs); + drmUnmap((drmAddress)ffbScreen->dac, gDRIPriv->sDacRegs); + drmUnmap((drmAddress)ffbScreen->sfb8r, gDRIPriv->sSfb8r); + FREE(ffbScreen); + return GL_FALSE; + } + ffbScreen->sfb32 = (volatile char *) map; + + if (drmMap(sPriv->fd, + gDRIPriv->hSfb64, + gDRIPriv->sSfb64, + &map)) { + drmUnmap((drmAddress)ffbScreen->regs, gDRIPriv->sFbcRegs); + drmUnmap((drmAddress)ffbScreen->dac, gDRIPriv->sDacRegs); + drmUnmap((drmAddress)ffbScreen->sfb8r, gDRIPriv->sSfb8r); + drmUnmap((drmAddress)ffbScreen->sfb32, gDRIPriv->sSfb32); + FREE(ffbScreen); + return GL_FALSE; + } + ffbScreen->sfb64 = (volatile char *) map; + + ffbScreen->fifo_cache = 0; + ffbScreen->rp_active = 0; + + ffbScreen->sPriv = sPriv; + sPriv->private = (void *) ffbScreen; + + ffbDDLinefuncInit(); + ffbDDPointfuncInit(); + + return GL_TRUE; +} + + +static void +ffbDestroyScreen(__DRIscreenPrivate *sPriv) +{ + ffbScreenPrivate *ffbScreen = sPriv->private; + FFBDRIPtr gDRIPriv = (FFBDRIPtr) sPriv->pDevPriv; + + drmUnmap((drmAddress)ffbScreen->regs, gDRIPriv->sFbcRegs); + drmUnmap((drmAddress)ffbScreen->dac, gDRIPriv->sDacRegs); + drmUnmap((drmAddress)ffbScreen->sfb8r, gDRIPriv->sSfb8r); + drmUnmap((drmAddress)ffbScreen->sfb32, gDRIPriv->sSfb32); + drmUnmap((drmAddress)ffbScreen->sfb64, gDRIPriv->sSfb64); + + FREE(ffbScreen); +} + +static const struct tnl_pipeline_stage *ffb_pipeline[] = { + &_tnl_vertex_transform_stage, + &_tnl_normal_transform_stage, + &_tnl_lighting_stage, + /* REMOVE: fog coord stage */ + &_tnl_texgen_stage, + &_tnl_texture_transform_stage, + /* REMOVE: point attenuation stage */ + &_tnl_render_stage, + 0, +}; + +/* Create and initialize the Mesa and driver specific context data */ +static GLboolean +ffbCreateContext(const __GLcontextModes *mesaVis, + __DRIcontextPrivate *driContextPriv, + void *sharedContextPrivate) +{ + ffbContextPtr fmesa; + GLcontext *ctx, *shareCtx; + __DRIscreenPrivate *sPriv; + ffbScreenPrivate *ffbScreen; + char *debug; + struct dd_function_table functions; + + /* Allocate ffb context */ + fmesa = (ffbContextPtr) CALLOC(sizeof(ffbContextRec)); + if (!fmesa) + return GL_FALSE; + + _mesa_init_driver_functions(&functions); + + /* Allocate Mesa context */ + if (sharedContextPrivate) + shareCtx = ((ffbContextPtr) sharedContextPrivate)->glCtx; + else + shareCtx = NULL; + fmesa->glCtx = _mesa_create_context(mesaVis, shareCtx, + &functions, fmesa); + if (!fmesa->glCtx) { + FREE(fmesa); + return GL_FALSE; + } + driContextPriv->driverPrivate = fmesa; + ctx = fmesa->glCtx; + + sPriv = driContextPriv->driScreenPriv; + ffbScreen = (ffbScreenPrivate *) sPriv->private; + + /* Dri stuff. */ + fmesa->hHWContext = driContextPriv->hHWContext; + fmesa->driFd = sPriv->fd; + fmesa->driHwLock = &sPriv->pSAREA->lock; + + fmesa->ffbScreen = ffbScreen; + fmesa->driScreen = sPriv; + fmesa->ffb_sarea = FFB_DRISHARE(sPriv->pSAREA); + + /* Register and framebuffer hw pointers. */ + fmesa->regs = ffbScreen->regs; + fmesa->sfb32 = ffbScreen->sfb32; + + ffbDDInitContextHwState(ctx); + + /* Default clear and depth colors. */ + { + GLubyte r = (GLint) (ctx->Color.ClearColor[0] * 255.0F); + GLubyte g = (GLint) (ctx->Color.ClearColor[1] * 255.0F); + GLubyte b = (GLint) (ctx->Color.ClearColor[2] * 255.0F); + + fmesa->clear_pixel = ((r << 0) | + (g << 8) | + (b << 16)); + } + fmesa->clear_depth = Z_FROM_MESA(ctx->Depth.Clear * 4294967295.0f); + fmesa->clear_stencil = ctx->Stencil.Clear & 0xf; + + /* No wide points. */ + ctx->Const.MinPointSize = 1.0; + ctx->Const.MinPointSizeAA = 1.0; + ctx->Const.MaxPointSize = 1.0; + ctx->Const.MaxPointSizeAA = 1.0; + + /* Disable wide lines as we can't antialias them correctly in + * hardware. + */ + ctx->Const.MinLineWidth = 1.0; + ctx->Const.MinLineWidthAA = 1.0; + ctx->Const.MaxLineWidth = 1.0; + ctx->Const.MaxLineWidthAA = 1.0; + ctx->Const.LineWidthGranularity = 1.0; + + /* Instead of having GCC emit these constants a zillion times + * everywhere in the driver, put them here. + */ + fmesa->ffb_2_30_fixed_scale = __FFB_2_30_FIXED_SCALE; + fmesa->ffb_one_over_2_30_fixed_scale = (1.0 / __FFB_2_30_FIXED_SCALE); + fmesa->ffb_16_16_fixed_scale = __FFB_16_16_FIXED_SCALE; + fmesa->ffb_one_over_16_16_fixed_scale = (1.0 / __FFB_16_16_FIXED_SCALE); + fmesa->ffb_ubyte_color_scale = 255.0f; + fmesa->ffb_zero = 0.0f; + + fmesa->debugFallbacks = GL_FALSE; + debug = getenv("LIBGL_DEBUG"); + if (debug && strstr(debug, "fallbacks")) + fmesa->debugFallbacks = GL_TRUE; + + /* Initialize the software rasterizer and helper modules. */ + _swrast_CreateContext( ctx ); + _ac_CreateContext( ctx ); + _tnl_CreateContext( ctx ); + _swsetup_CreateContext( ctx ); + + /* All of this need only be done once for a new context. */ + /* XXX these should be moved right after the + * _mesa_init_driver_functions() call above. + */ + ffbDDExtensionsInit(ctx); + ffbDDInitDriverFuncs(ctx); + ffbDDInitStateFuncs(ctx); + ffbDDInitRenderFuncs(ctx); + /*ffbDDInitTexFuncs(ctx); not needed */ + ffbDDInitBitmapFuncs(ctx); + ffbInitVB(ctx); + +#if 0 + ffbInitTnlModule(ctx); +#endif + + _tnl_destroy_pipeline(ctx); + _tnl_install_pipeline(ctx, ffb_pipeline); + + return GL_TRUE; +} + +static void +ffbDestroyContext(__DRIcontextPrivate *driContextPriv) +{ + ffbContextPtr fmesa = (ffbContextPtr) driContextPriv->driverPrivate; + + if (fmesa) { + ffbFreeVB(fmesa->glCtx); + + _swsetup_DestroyContext( fmesa->glCtx ); + _tnl_DestroyContext( fmesa->glCtx ); + _ac_DestroyContext( fmesa->glCtx ); + _swrast_DestroyContext( fmesa->glCtx ); + + /* free the Mesa context */ + fmesa->glCtx->DriverCtx = NULL; + _mesa_destroy_context(fmesa->glCtx); + + FREE(fmesa); + } +} + +/* Create and initialize the Mesa and driver specific pixmap buffer data */ +static GLboolean +ffbCreateBuffer(__DRIscreenPrivate *driScrnPriv, + __DRIdrawablePrivate *driDrawPriv, + const __GLcontextModes *mesaVis, + GLboolean isPixmap ) +{ + /* Mesa checks for pitch > 0, but ffb doesn't use pitches */ + int bogusPitch = 1; + int bpp = 4; /* we've always got a 32bpp framebuffer */ + int offset = 0; /* always at 0 for offset */ + + if (isPixmap) { + return GL_FALSE; /* not implemented */ + } else { + GLboolean swStencil = (mesaVis->stencilBits > 0 && + mesaVis->depthBits != 24); +#if 0 + driDrawPriv->driverPrivate = (void *) + _mesa_create_framebuffer(mesaVis, + GL_FALSE, /* software depth buffer? */ + mesaVis->stencilBits > 0, + mesaVis->accumRedBits > 0, + mesaVis->alphaBits > 0); +#else + struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis); + + { + driRenderbuffer *frontRb + = driNewRenderbuffer(GL_RGBA, bpp, offset, bogusPitch); + ffbSetSpanFunctions(frontRb, mesaVis); + _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontRb->Base); + } + + if (mesaVis->doubleBufferMode) { + driRenderbuffer *backRb + = driNewRenderbuffer(GL_RGBA, bpp, offset, bogusPitch); + ffbSetSpanFunctions(backRb, mesaVis); + _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backRb->Base); + } + + if (mesaVis->depthBits == 16) { + driRenderbuffer *depthRb + = driNewRenderbuffer(GL_DEPTH_COMPONENT16, bpp, offset, bogusPitch); + ffbSetDepthFunctions(depthRb, mesaVis); + _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base); + } + + if (mesaVis->stencilBits > 0 && !swStencil) { + driRenderbuffer *stencilRb + = driNewRenderbuffer(GL_STENCIL_INDEX8_EXT, bpp, offset,bogusPitch); + ffbSetStencilFunctions(stencilRb, mesaVis); + _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &stencilRb->Base); + } + + _mesa_add_soft_renderbuffers(fb, + GL_FALSE, /* color */ + GL_FALSE, /* depth */ + swStencil, + mesaVis->accumRedBits > 0, + GL_FALSE, /* alpha */ + GL_FALSE /* aux */); + driDrawPriv->driverPrivate = (void *) fb; +#endif + return (driDrawPriv->driverPrivate != NULL); + } +} + + +static void +ffbDestroyBuffer(__DRIdrawablePrivate *driDrawPriv) +{ + _mesa_destroy_framebuffer((GLframebuffer *) (driDrawPriv->driverPrivate)); +} + + +#define USE_FAST_SWAP + +static void +ffbSwapBuffers( __DRIdrawablePrivate *dPriv ) +{ + ffbContextPtr fmesa = (ffbContextPtr) dPriv->driContextPriv->driverPrivate; + unsigned int fbc, wid, wid_reg_val, dac_db_bit; + unsigned int shadow_dac_addr, active_dac_addr; + ffb_fbcPtr ffb; + ffb_dacPtr dac; + + if (fmesa == NULL || + fmesa->glCtx->Visual.doubleBufferMode == 0) + return; + + /* Flush pending rendering commands */ + _mesa_notifySwapBuffers(fmesa->glCtx); + + ffb = fmesa->regs; + dac = fmesa->ffbScreen->dac; + + fbc = fmesa->fbc; + wid = fmesa->wid; + + /* Swap the buffer we render into and read pixels from. */ + fmesa->back_buffer ^= 1; + + /* If we are writing into both buffers, don't mess with + * the WB setting. + */ + if ((fbc & FFB_FBC_WB_AB) != FFB_FBC_WB_AB) { + if ((fbc & FFB_FBC_WB_A) != 0) + fbc = (fbc & ~FFB_FBC_WB_A) | FFB_FBC_WB_B; + else + fbc = (fbc & ~FFB_FBC_WB_B) | FFB_FBC_WB_A; + } + + /* But either way, we must flip the read buffer setting. */ + if ((fbc & FFB_FBC_RB_A) != 0) + fbc = (fbc & ~FFB_FBC_RB_A) | FFB_FBC_RB_B; + else + fbc = (fbc & ~FFB_FBC_RB_B) | FFB_FBC_RB_A; + + LOCK_HARDWARE(fmesa); + + if (fmesa->fbc != fbc) { + FFBFifo(fmesa, 1); + ffb->fbc = fmesa->fbc = fbc; + fmesa->ffbScreen->rp_active = 1; + } + + /* And swap the buffer displayed in the WID. */ + if (fmesa->ffb_sarea->flags & FFB_DRI_PAC1) { + shadow_dac_addr = FFBDAC_PAC1_SPWLUT(wid); + active_dac_addr = FFBDAC_PAC1_APWLUT(wid); + dac_db_bit = FFBDAC_PAC1_WLUT_DB; + } else { + shadow_dac_addr = FFBDAC_PAC2_SPWLUT(wid); + active_dac_addr = FFBDAC_PAC2_APWLUT(wid); + dac_db_bit = FFBDAC_PAC2_WLUT_DB; + } + + FFBWait(fmesa, ffb); + + wid_reg_val = DACCFG_READ(dac, active_dac_addr); + if (fmesa->back_buffer == 0) + wid_reg_val |= dac_db_bit; + else + wid_reg_val &= ~dac_db_bit; +#ifdef USE_FAST_SWAP + DACCFG_WRITE(dac, active_dac_addr, wid_reg_val); +#else + DACCFG_WRITE(dac, shadow_dac_addr, wid_reg_val); + + /* Schedule the window transfer. */ + DACCFG_WRITE(dac, FFBDAC_CFG_WTCTRL, + (FFBDAC_CFG_WTCTRL_TCMD | FFBDAC_CFG_WTCTRL_TE)); + + { + int limit = 1000000; + while (limit--) { + unsigned int wtctrl = DACCFG_READ(dac, FFBDAC_CFG_WTCTRL); + + if ((wtctrl & FFBDAC_CFG_WTCTRL_DS) == 0) + break; + } + } +#endif + + UNLOCK_HARDWARE(fmesa); +} + +static void ffb_init_wid(ffbContextPtr fmesa, unsigned int wid) +{ + ffb_dacPtr dac = fmesa->ffbScreen->dac; + unsigned int wid_reg_val, dac_db_bit, active_dac_addr; + unsigned int shadow_dac_addr; + + if (fmesa->ffb_sarea->flags & FFB_DRI_PAC1) { + shadow_dac_addr = FFBDAC_PAC1_SPWLUT(wid); + active_dac_addr = FFBDAC_PAC1_APWLUT(wid); + dac_db_bit = FFBDAC_PAC1_WLUT_DB; + } else { + shadow_dac_addr = FFBDAC_PAC2_SPWLUT(wid); + active_dac_addr = FFBDAC_PAC2_APWLUT(wid); + dac_db_bit = FFBDAC_PAC2_WLUT_DB; + } + + wid_reg_val = DACCFG_READ(dac, active_dac_addr); + wid_reg_val &= ~dac_db_bit; +#ifdef USE_FAST_SWAP + DACCFG_WRITE(dac, active_dac_addr, wid_reg_val); +#else + DACCFG_WRITE(dac, shadow_dac_addr, wid_reg_val); + + /* Schedule the window transfer. */ + DACCFG_WRITE(dac, FFBDAC_CFG_WTCTRL, + (FFBDAC_CFG_WTCTRL_TCMD | FFBDAC_CFG_WTCTRL_TE)); + + { + int limit = 1000000; + while (limit--) { + unsigned int wtctrl = DACCFG_READ(dac, FFBDAC_CFG_WTCTRL); + + if ((wtctrl & FFBDAC_CFG_WTCTRL_DS) == 0) + break; + } + } +#endif +} + +/* Force the context `c' to be the current context and associate with it + buffer `b' */ +static GLboolean +ffbMakeCurrent(__DRIcontextPrivate *driContextPriv, + __DRIdrawablePrivate *driDrawPriv, + __DRIdrawablePrivate *driReadPriv) +{ + if (driContextPriv) { + ffbContextPtr fmesa = (ffbContextPtr) driContextPriv->driverPrivate; + int first_time; + + fmesa->driDrawable = driDrawPriv; + + _mesa_make_current(fmesa->glCtx, + (GLframebuffer *) driDrawPriv->driverPrivate, + (GLframebuffer *) driReadPriv->driverPrivate); + + first_time = 0; + if (fmesa->wid == ~0) { + first_time = 1; + if (getenv("LIBGL_SOFTWARE_RENDERING")) + FALLBACK( fmesa->glCtx, FFB_BADATTR_SWONLY, GL_TRUE ); + } + + LOCK_HARDWARE(fmesa); + if (first_time) { + fmesa->wid = fmesa->ffb_sarea->wid_table[driDrawPriv->index]; + ffb_init_wid(fmesa, fmesa->wid); + } + + fmesa->state_dirty |= FFB_STATE_ALL; + fmesa->state_fifo_ents = fmesa->state_all_fifo_ents; + ffbSyncHardware(fmesa); + UNLOCK_HARDWARE(fmesa); + + if (first_time) { + /* Also, at the first switch to a new context, + * we need to clear all the hw buffers. + */ + ffbDDClear(fmesa->glCtx, + (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT | + BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL), + 1, 0, 0, 0, 0); + } + } else { + _mesa_make_current(NULL, NULL, NULL); + } + + return GL_TRUE; +} + +/* Force the context `c' to be unbound from its buffer */ +static GLboolean +ffbUnbindContext(__DRIcontextPrivate *driContextPriv) +{ + return GL_TRUE; +} + +void ffbXMesaUpdateState(ffbContextPtr fmesa) +{ + __DRIdrawablePrivate *dPriv = fmesa->driDrawable; + __DRIscreenPrivate *sPriv = fmesa->driScreen; + int stamp = dPriv->lastStamp; + + DRI_VALIDATE_DRAWABLE_INFO(sPriv, dPriv); + + if (dPriv->lastStamp != stamp) { + GLcontext *ctx = fmesa->glCtx; + + ffbCalcViewport(ctx); + if (ctx->Polygon.StippleFlag) + ffbXformAreaPattern(fmesa, + (const GLubyte *)ctx->PolygonStipple); + } +} + +static const struct __DriverAPIRec ffbAPI = { + .InitDriver = ffbInitDriver, + .DestroyScreen = ffbDestroyScreen, + .CreateContext = ffbCreateContext, + .DestroyContext = ffbDestroyContext, + .CreateBuffer = ffbCreateBuffer, + .DestroyBuffer = ffbDestroyBuffer, + .SwapBuffers = ffbSwapBuffers, + .MakeCurrent = ffbMakeCurrent, + .UnbindContext = ffbUnbindContext, + .GetSwapInfo = NULL, + .GetMSC = NULL, + .WaitForMSC = NULL, + .WaitForSBC = NULL, + .SwapBuffersMSC = NULL +}; + + +static __GLcontextModes * +ffbFillInModes( unsigned pixel_bits, unsigned depth_bits, + unsigned stencil_bits, GLboolean have_back_buffer ) +{ + __GLcontextModes * modes; + __GLcontextModes * m; + unsigned num_modes; + unsigned depth_buffer_factor; + unsigned back_buffer_factor; + GLenum fb_format; + GLenum fb_type; + + /* GLX_SWAP_COPY_OML is only supported because the FFB driver doesn't + * support pageflipping at all. + */ + static const GLenum back_buffer_modes[] = { + GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML + }; + + u_int8_t depth_bits_array[3]; + u_int8_t stencil_bits_array[3]; + + + depth_bits_array[0] = 0; + depth_bits_array[1] = depth_bits; + depth_bits_array[2] = depth_bits; + + /* Just like with the accumulation buffer, always provide some modes + * with a stencil buffer. It will be a sw fallback, but some apps won't + * care about that. + */ + stencil_bits_array[0] = 0; + stencil_bits_array[1] = 0; + stencil_bits_array[2] = (stencil_bits == 0) ? 8 : stencil_bits; + + depth_buffer_factor = ((depth_bits != 0) || (stencil_bits != 0)) ? 3 : 1; + back_buffer_factor = (have_back_buffer) ? 3 : 1; + + num_modes = depth_buffer_factor * back_buffer_factor * 4; + + if ( pixel_bits == 16 ) { + fb_format = GL_RGB; + fb_type = GL_UNSIGNED_SHORT_5_6_5; + } + else { + fb_format = GL_BGRA; + fb_type = GL_UNSIGNED_INT_8_8_8_8_REV; + } + + modes = (*dri_interface->createContextModes)( num_modes, sizeof( __GLcontextModes ) ); + m = modes; + if ( ! driFillInModes( & m, fb_format, fb_type, + depth_bits_array, stencil_bits_array, depth_buffer_factor, + back_buffer_modes, back_buffer_factor, + GLX_TRUE_COLOR ) ) { + fprintf( stderr, "[%s:%u] Error creating FBConfig!\n", + __func__, __LINE__ ); + return NULL; + } + if ( ! driFillInModes( & m, fb_format, fb_type, + depth_bits_array, stencil_bits_array, depth_buffer_factor, + back_buffer_modes, back_buffer_factor, + GLX_DIRECT_COLOR ) ) { + fprintf( stderr, "[%s:%u] Error creating FBConfig!\n", + __func__, __LINE__ ); + return NULL; + } + + + /* Mark the visual as slow if there are "fake" stencil bits. + */ + for ( m = modes ; m != NULL ; m = m->next ) { + if ( (m->stencilBits != 0) && (m->stencilBits != stencil_bits) ) { + m->visualRating = GLX_SLOW_CONFIG; + } + } + + return modes; +} + + +/** + * This is the bootstrap function for the driver. libGL supplies all of the + * requisite information about the system, and the driver initializes itself. + * This routine also fills in the linked list pointed to by \c driver_modes + * with the \c __GLcontextModes that the driver can support for windows or + * pbuffers. + * + * \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on + * failure. + */ +PUBLIC +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, + const __GLcontextModes * modes, + const __DRIversion * ddx_version, + const __DRIversion * dri_version, + const __DRIversion * drm_version, + const __DRIframebuffer * frame_buffer, + drmAddress pSAREA, int fd, + int internal_api_version, + const __DRIinterfaceMethods * interface, + __GLcontextModes ** driver_modes ) + +{ + __DRIscreenPrivate *psp; + static const __DRIversion ddx_expected = { 0, 1, 1 }; + static const __DRIversion dri_expected = { 4, 0, 0 }; + static const __DRIversion drm_expected = { 0, 0, 1 }; + + dri_interface = interface; + + if ( ! driCheckDriDdxDrmVersions2( "ffb", + dri_version, & dri_expected, + ddx_version, & ddx_expected, + drm_version, & drm_expected ) ) { + return NULL; + } + + psp = __driUtilCreateNewScreen(dpy, scrn, psc, NULL, + ddx_version, dri_version, drm_version, + frame_buffer, pSAREA, fd, + internal_api_version, &ffbAPI); + if ( psp != NULL ) { + *driver_modes = ffbFillInModes( 32, 16, 0, GL_TRUE ); + } + + return (void *) psp; +} diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_xmesa.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_xmesa.h new file mode 100644 index 000000000..b7580780a --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_xmesa.h @@ -0,0 +1,26 @@ +/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_xmesa.h,v 1.2 2002/02/22 21:32:59 dawes Exp $ */ + +#ifndef _FFB_XMESA_H_ +#define _FFB_XMESA_H_ + +#include <sys/time.h> +#include "dri_util.h" +#include "mtypes.h" +#include "ffb_drishare.h" +#include "ffb_regs.h" +#include "ffb_dac.h" +#include "ffb_fifo.h" + +typedef struct { + __DRIscreenPrivate *sPriv; + ffb_fbcPtr regs; + ffb_dacPtr dac; + volatile char *sfb8r; + volatile char *sfb32; + volatile char *sfb64; + + int fifo_cache; + int rp_active; +} ffbScreenPrivate; + +#endif /* !(_FFB_XMESA_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_dac.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_dac.h new file mode 100644 index 000000000..08114282e --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_dac.h @@ -0,0 +1,367 @@ +/* + * Acceleration for the Creator and Creator3D framebuffer - DAC register layout. + * + * Copyright (C) 2000 David S. Miller (davem@redhat.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DAVID MILLER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_dac.h,v 1.2 2001/04/05 17:42:33 dawes Exp $ */ + +#ifndef _FFB_DAC_H +#define _FFB_DAC_H + +#define Bool int + +/* FFB utilizes two different ramdac chips: + * + * 1) BT9068 "Pacifica1", used in all FFB1 and + * FFB2 boards. + * + * 2) BT498(a) "Pacifica2", used in FFB2+ and + * AFB boards. + * + * They are mostly equivalent, except in a few key areas: + * + * 1) WID register layout + * 2) Number of CLUT tables + * 3) Presence of Window Address Mask register + * 4) Method of GAMMA correction support + */ + +/* NOTE: All addresses described in this file are DAC + * indirect addresses. + */ + +/* DAC color values are in the following format. */ +#define FFBDAC_COLOR_BLUE 0x00ff0000 +#define FFBDAC_COLOR_BLUE_SHFT 16 +#define FFBDAC_COLOR_GREEN 0x0000ff00 +#define FFBDAC_COLOR_GREEN_SHFT 8 +#define FFBDAC_COLOR_RED 0x000000ff +#define FFBDAC_COLOR_RED_SHFT 0 + +/* Cursor DAC register addresses. */ +#define FFBDAC_CUR_BITMAP_P0 0x000 /* Plane 0 cursor bitmap */ +#define FFBDAC_CUR_BITMAP_P1 0x080 /* Plane 1 cursor bitmap */ +#define FFBDAC_CUR_CTRL 0x100 /* Cursor control */ +#define FFBDAC_CUR_COLOR0 0x101 /* Cursor Color 0 */ +#define FFBDAC_CUR_COLOR1 0x102 /* Cursor Color 1 (bg) */ +#define FFBDAC_CUR_COLOR2 0x103 /* Cursor Color 2 (fg) */ +#define FFBDAC_CUR_POS 0x104 /* Active cursor position */ + +/* Cursor control register. + * WARNING: Be careful, reverse logic on these bits. + */ +#define FFBDAC_CUR_CTRL_P0 0x00000001 /* Plane0 display disable */ +#define FFBDAC_CUR_CTRL_P1 0x00000002 /* Plane1 display disable */ + +/* Active cursor position register */ +#define FFBDAC_CUR_POS_Y_SIGN 0x80000000 /* Sign of Y position */ +#define FFBDAC_CUR_POS_Y 0x0fff0000 /* Y position */ +#define FFBDAC_CUR_POS_X_SIGN 0x00008000 /* Sign of X position */ +#define FFBDAC_CUR_POS_X 0x00000fff /* X position */ + +/* Configuration and Palette DAC register addresses. */ +#define FFBDAC_CFG_PPLLCTRL 0x0000 /* Pixel PLL Control */ +#define FFBDAC_CFG_GPLLCTRL 0x0001 /* General Purpose PLL Control */ +#define FFBDAC_CFG_PFCTRL 0x1000 /* Pixel Format Control */ +#define FFBDAC_CFG_UCTRL 0x1001 /* User Control */ +#define FFBDAC_CFG_CLUP_BASE 0x2000 /* Color Lookup Palette */ +#define FFBDAC_CFG_CLUP(entry) (FFBDAC_CFG_CLUP_BASE + ((entry) * 0x100)) +#define FFBDAC_PAC2_SOVWLUT0 0x3100 /* Shadow Overlay Window Lookup 0*/ +#define FFBDAC_PAC2_SOVWLUT1 0x3101 /* Shadow Overlay Window Lookup 1*/ +#define FFBDAC_PAC2_SOVWLUT2 0x3102 /* Shadow Overlay Window Lookup 2*/ +#define FFBDAC_PAC2_SOVWLUT3 0x3103 /* Shadow Overlay Window Lookup 3*/ +#define FFBDAC_PAC2_AOVWLUT0 0x3210 /* Active Overlay Window Lookup 0*/ +#define FFBDAC_PAC2_AOVWLUT1 0x3211 /* Active Overlay Window Lookup 1*/ +#define FFBDAC_PAC2_AOVWLUT2 0x3212 /* Active Overlay Window Lookup 2*/ +#define FFBDAC_PAC2_AOVWLUT3 0x3213 /* Active Overlay Window Lookup 3*/ +#define FFBDAC_CFG_WTCTRL 0x3150 /* Window Transfer Control */ +#define FFBDAC_CFG_TMCTRL 0x3151 /* Transparent Mask Control */ +#define FFBDAC_CFG_TCOLORKEY 0x3152 /* Transparent Color Key */ +#define FFBDAC_CFG_WAMASK 0x3153 /* Window Address Mask (PAC2 only) */ +#define FFBDAC_PAC1_SPWLUT_BASE 0x3100 /* Shadow Primary Window Lookups */ +#define FFBDAC_PAC1_SPWLUT(entry) (FFBDAC_PAC1_SPWLUT_BASE + (entry)) +#define FFBDAC_PAC1_APWLUT_BASE 0x3120 /* Active Primary Window Lookups */ +#define FFBDAC_PAC1_APWLUT(entry) (FFBDAC_PAC1_APWLUT_BASE + (entry)) +#define FFBDAC_PAC2_SPWLUT_BASE 0x3200 /* Shadow Primary Window Lookups */ +#define FFBDAC_PAC2_SPWLUT(entry) (FFBDAC_PAC2_SPWLUT_BASE + (entry)) +#define FFBDAC_PAC2_APWLUT_BASE 0x3240 /* Active Primary Window Lookups */ +#define FFBDAC_PAC2_APWLUT(entry) (FFBDAC_PAC2_APWLUT_BASE + (entry)) +#define FFBDAC_CFG_SANAL 0x5000 /* Signature Analysis Control */ +#define FFBDAC_CFG_DACCTRL 0x5001 /* DAC Control */ +#define FFBDAC_CFG_TGEN 0x6000 /* Timing Generator Control */ +#define FFBDAC_CFG_VBNP 0x6001 /* Vertical Blank Negation Point */ +#define FFBDAC_CFG_VBAP 0x6002 /* Vertical Blank Assertion Point*/ +#define FFBDAC_CFG_VSNP 0x6003 /* Vertical Sync Negation Point */ +#define FFBDAC_CFG_VSAP 0x6004 /* Vertical Sync Assertion Point */ +#define FFBDAC_CFG_HSNP 0x6005 /* Horz Serration Negation Point */ +#define FFBDAC_CFG_HBNP 0x6006 /* Horz Blank Negation Point */ +#define FFBDAC_CFG_HBAP 0x6007 /* Horz Blank Assertion Point */ +#define FFBDAC_CFG_HSYNCNP 0x6008 /* Horz Sync Negation Point */ +#define FFBDAC_CFG_HSYNCAP 0x6009 /* Horz Sync Assertion Point */ +#define FFBDAC_CFG_HSCENNP 0x600A /* Horz SCEN Negation Point */ +#define FFBDAC_CFG_HSCENAP 0x600B /* Horz SCEN Assertion Point */ +#define FFBDAC_CFG_EPNP 0x600C /* Eql'zing Pulse Negation Point */ +#define FFBDAC_CFG_EINP 0x600D /* Eql'zing Intvl Negation Point */ +#define FFBDAC_CFG_EIAP 0x600E /* Eql'zing Intvl Assertion Point*/ +#define FFBDAC_CFG_TGVC 0x600F /* Timing Generator Vert Counter */ +#define FFBDAC_CFG_TGHC 0x6010 /* Timing Generator Horz Counter */ +#define FFBDAC_CFG_DID 0x8000 /* Device Identification */ +#define FFBDAC_CFG_MPDATA 0x8001 /* Monitor Port Data */ +#define FFBDAC_CFG_MPSENSE 0x8002 /* Monitor Port Sense */ + +/* Pixel PLL Control Register */ +#define FFBDAC_CFG_PPLLCTRL_M 0x0000007f /* PLL VCO Multiplicand */ +#define FFBDAC_CFG_PPLLCTRL_D 0x00000780 /* PLL VCO Divisor */ +#define FFBDAC_CFG_PPLLCTRL_PFD 0x00001800 /* Post VCO Frequency Divider */ +#define FFBDAC_CFG_PPLLCTRL_EN 0x00004000 /* Enable PLL as pixel clock src */ + +/* General Purpose PLL Control Register */ +#define FFBDAC_CFG_GPLLCTRL_M 0x0000007f /* PLL VCO Multiplicand */ +#define FFBDAC_CFG_GPLLCTRL_D 0x00000780 /* PLL VCO Divisor */ +#define FFBDAC_CFG_GPLLCTRL_PFD 0x00001800 /* Post VCO Frequency Divider */ +#define FFBDAC_CFG_GPLLCTRL_EN 0x00004000 /* Enable PLL as Gen. Purpose clk*/ + +/* Pixel Format Control Register */ +#define FFBDAC_CFG_PFCTRL_2_1 0x00000000 /* 2:1 pixel interleave format */ +#define FFBDAC_CFG_PFCTRL_4_1 0x00000001 /* 4:1 pixel interleave format */ +#define FFBDAC_CFG_PFCTRL_42_1 0x00000002 /* 4/2:1 pixel interleave format */ +#define FFBDAC_CFG_PFCTRL_82_1 0x00000003 /* 8/2:1 pixel interleave format */ + +/* User Control Register */ +#define FFBDAC_UCTRL_IPDISAB 0x00000001 /* Disable input pullup resistors*/ +#define FFBDAC_UCTRL_ABLANK 0x00000002 /* Asynchronous Blank */ +#define FFBDAC_UCTRL_DBENAB 0x00000004 /* Double-Buffer Enable */ +#define FFBDAC_UCTRL_OVENAB 0x00000008 /* Overlay Enable */ +#define FFBDAC_UCTRL_WMODE 0x00000030 /* Window Mode */ +#define FFBDAC_UCTRL_WM_COMB 0x00000000 /* Window Mode = Combined */ +#define FFBDAC_UCTRL_WM_S4 0x00000010 /* Window Mode = Seperate_4 */ +#define FFBDAC_UCTRL_WM_S8 0x00000020 /* Window Mode = Seperate_8 */ +#define FFBDAC_UCTRL_WM_RESV 0x00000030 /* Window Mode = reserved */ +#define FFBDAC_UCTRL_MANREV 0x00000f00 /* 4-bit Manufacturing Revision */ + +/* Overlay Window Lookup Registers (PAC2 only) */ +#define FFBDAC_CFG_OVWLUT_PSEL 0x0000000f /* Palette Section, Seperate_4 */ +#define FFBDAC_CFG_OVWLUT_PTBL 0x00000030 /* Palette Table */ +#define FFBDAC_CFG_OVWLUT_LKUP 0x00000100 /* 1 = Use palette, 0 = Bypass */ +#define FFBDAC_CFG_OVWLUT_OTYP 0x00000c00 /* Overlay Type */ +#define FFBDAC_CFG_OVWLUT_O_N 0x00000000 /* Overlay Type - None */ +#define FFBDAC_CFG_OVWLUT_O_T 0x00000400 /* Overlay Type - Transparent */ +#define FFBDAC_CFG_OVWLUT_O_O 0x00000800 /* Overlay Type - Opaque */ +#define FFBDAC_CFG_OVWLUT_O_R 0x00000c00 /* Overlay Type - Reserved */ +#define FFBDAC_CFG_OVWLUT_PCS 0x00003000 /* Psuedocolor Src */ +#define FFBDAC_CFG_OVWLUT_P_XO 0x00000000 /* Psuedocolor Src - XO[7:0] */ +#define FFBDAC_CFG_OVWLUT_P_R 0x00001000 /* Psuedocolor Src - R[7:0] */ +#define FFBDAC_CFG_OVWLUT_P_G 0x00002000 /* Psuedocolor Src - G[7:0] */ +#define FFBDAC_CFG_OVWLUT_P_B 0x00003000 /* Psuedocolor Src - B[7:0] */ + +/* Window Transfer Control Register */ +#define FFBDAC_CFG_WTCTRL_DS 0x00000001 /* Device Status, 1 = Busy */ +#define FFBDAC_CFG_WTCTRL_TCMD 0x00000002 /* Transfer Command + * 1 = Transfer, 0 = No Action + */ +#define FFBDAC_CFG_WTCTRL_TE 0x00000004 /* Transfer Event + * 1 = Next Frame, 0 = Next Field + */ +#define FFBDAC_CFG_WTCTRL_DRD 0x00000008 /* Drawing Data + * 1 = Local Drawing Active + * 0 = Local Drawing Idle + */ +#define FFBDAC_CFG_WTCTRL_DRS 0x00000010 /* Drawing Status + * 1 = Network Drawing Active + * 0 = Network Drawing Idle + */ + +/* Transparent Mask Control Register */ +#define FFBDAC_CFG_TMCTRL_OMSK 0x000000ff /* Overlay Mask */ + +/* Transparent Color Key Register */ +#define FFBDAC_CFG_TCOLORKEY_K 0x000000ff /* Overlay Color Key */ + +/* Window Address Mask Register (PAC2 only) */ +#define FFBDAC_CFG_WAMASK_PMSK 0x0000003f /* PWLUT select PMASK */ +#define FFBDAC_CFG_WAMASK_OMSK 0x00000300 /* OWLUT control OMASK */ + +/* (non-Overlay) Window Lookup Table Registers, PAC1 format */ +#define FFBDAC_PAC1_WLUT_DB 0x00000020 /* 0 = Buffer A, 1 = Buffer B */ +#define FFBDAC_PAC1_WLUT_C 0x0000001c /* C: Color Model Selection */ +#define FFBDAC_PAC1_WLUT_C_8P 0x00000000 /* C: 8bpp Pseudocolor */ +#define FFBDAC_PAC1_WLUT_C_8LG 0x00000004 /* C: 8bpp Linear Grey */ +#define FFBDAC_PAC1_WLUT_C_8NG 0x00000008 /* C: 8bpp Non-Linear Grey */ +#define FFBDAC_PAC1_WLUT_C_24D 0x00000010 /* C: 24bpp Directcolor */ +#define FFBDAC_PAC1_WLUT_C_24LT 0x00000014 /* C: 24bpp Linear Truecolor */ +#define FFBDAC_PAC1_WLUT_C_24NT 0x00000018 /* C: 24bpp Non-Linear Truecolor */ +#define FFBDAC_PAC1_WLUT_PCS 0x00000003 /* Pseudocolor Src */ +#define FFBDAC_PAC1_WLUT_P_XO 0x00000000 /* Pseudocolor Src - XO[7:0] */ +#define FFBDAC_PAC1_WLUT_P_R 0x00000001 /* Pseudocolor Src - R[7:0] */ +#define FFBDAC_PAC1_WLUT_P_G 0x00000002 /* Pseudocolor Src - G[7:0] */ +#define FFBDAC_PAC1_WLUT_P_B 0x00000003 /* Pseudocolor Src - B[7:0] */ + +/* (non-Overlay) Window Lookup Table Registers, PAC2 format */ +#define FFBDAC_PAC2_WLUT_PTBL 0x00000030 /* Palette Table Entry */ +#define FFBDAC_PAC2_WLUT_LKUP 0x00000100 /* 1 = Use palette, 0 = Bypass */ +#define FFBDAC_PAC2_WLUT_PCS 0x00003000 /* Pseudocolor Src */ +#define FFBDAC_PAC2_WLUT_P_XO 0x00000000 /* Pseudocolor Src - XO[7:0] */ +#define FFBDAC_PAC2_WLUT_P_R 0x00001000 /* Pseudocolor Src - R[7:0] */ +#define FFBDAC_PAC2_WLUT_P_G 0x00002000 /* Pseudocolor Src - G[7:0] */ +#define FFBDAC_PAC2_WLUT_P_B 0x00003000 /* Pseudocolor Src - B[7:0] */ +#define FFBDAC_PAC2_WLUT_DEPTH 0x00004000 /* 0 = Pseudocolor, 1 = Truecolor*/ +#define FFBDAC_PAC2_WLUT_DB 0x00008000 /* 0 = Buffer A, 1 = Buffer B */ + +/* Signature Analysis Control Register */ +#define FFBDAC_CFG_SANAL_SRR 0x000000ff /* DAC Seed/Result for Red */ +#define FFBDAC_CFG_SANAL_SRG 0x0000ff00 /* DAC Seed/Result for Green */ +#define FFBDAC_CFG_SANAL_SRB 0x00ff0000 /* DAC Seed/Result for Blue */ +#define FFBDAC_CFG_SANAL_RQST 0x01000000 /* Signature Capture Request */ +#define FFBDAC_CFG_SANAL_BSY 0x02000000 /* Signature Analysis Busy */ +#define FFBDAC_CFG_SANAL_DSM 0x04000000 /* Data Strobe Mode + * 0 = Signature Analysis Mode + * 1 = Data Strobe Mode + */ + +/* DAC Control Register */ +#define FFBDAC_CFG_DACCTRL_O2 0x00000003 /* Operand 2 Select + * 00 = Normal Operation + * 01 = Select 145mv Reference + * 10 = Select Blue DAC Output + * 11 = Reserved + */ +#define FFBDAC_CFG_DACCTRL_O1 0x0000000c /* Operand 1 Select + * 00 = Normal Operation + * 01 = Select Green DAC Output + * 10 = Select Red DAC Output + * 11 = Reserved + */ +#define FFBDAC_CFG_DACCTRL_CR 0x00000010 /* Comparator Result + * 0 = operand1 < operand2 + * 1 = operand1 > operand2 + */ +#define FFBDAC_CFG_DACCTRL_SGE 0x00000020 /* Sync-on-Green Enable */ +#define FFBDAC_CFG_DACCTRL_PE 0x00000040 /* Pedestal Enable */ +#define FFBDAC_CFG_DACCTRL_VPD 0x00000080 /* VSYNC* Pin Disable */ +#define FFBDAC_CFG_DACCTRL_SPB 0x00000100 /* Sync Polarity Bit + * 0 = VSYNC* and CSYNC* active low + * 1 = VSYNC* and CSYNC* active high + */ + +/* Timing Generator Control Register */ +#define FFBDAC_CFG_TGEN_VIDE 0x00000001 /* Video Enable */ +#define FFBDAC_CFG_TGEN_TGE 0x00000002 /* Timing Generator Enable */ +#define FFBDAC_CFG_TGEN_HSD 0x00000004 /* HSYNC* Disabled */ +#define FFBDAC_CFG_TGEN_VSD 0x00000008 /* VSYNC* Disabled */ +#define FFBDAC_CFG_TGEN_EQD 0x00000010 /* Equalization Disabled */ +#define FFBDAC_CFG_TGEN_MM 0x00000020 /* 0 = Slave, 1 = Master */ +#define FFBDAC_CFG_TGEN_IM 0x00000040 /* 1 = Interlaced Mode */ + +/* Device Identification Register, should be 0xA236E1AD for FFB bt497/bt498 */ +#define FFBDAC_CFG_DID_ONE 0x00000001 /* Always set */ +#define FFBDAC_CFG_DID_MANUF 0x00000ffe /* Manufacturer ID */ +#define FFBDAC_CFG_DID_PNUM 0x0ffff000 /* Device Part Number */ +#define FFBDAC_CFG_DID_REV 0xf0000000 /* Device Revision */ + +/* Monitor Port Data Register */ +#define FFBDAC_CFG_MPDATA_SCL 0x00000001 /* SCL Data */ +#define FFBDAC_CFG_MPDATA_SDA 0x00000002 /* SDA Data */ + +/* Monitor Port Sense Register */ +#define FFBDAC_CFG_MPSENSE_SCL 0x00000001 /* SCL Sense */ +#define FFBDAC_CFG_MPSENSE_SDA 0x00000002 /* SDA Sense */ + +/* DAC register access shorthands. */ +#define DACCUR_READ(DAC, ADDR) ((DAC)->cur = (ADDR), (DAC)->curdata) +#define DACCUR_WRITE(DAC, ADDR, VAL) ((DAC)->cur = (ADDR), (DAC)->curdata = (VAL)) +#define DACCFG_READ(DAC, ADDR) ((DAC)->cfg = (ADDR), (DAC)->cfgdata) +#define DACCFG_WRITE(DAC, ADDR, VAL) ((DAC)->cfg = (ADDR), (DAC)->cfgdata = (VAL)) + +typedef struct ffb_dac_hwstate { + unsigned int ppllctrl; + unsigned int gpllctrl; + unsigned int pfctrl; + unsigned int uctrl; + unsigned int clut[256 * 4]; /* One 256 entry clut on PAC1, 4 on PAC2 */ + unsigned int ovluts[4]; /* Overlay WLUTS, PAC2 only */ + unsigned int wtctrl; + unsigned int tmctrl; + unsigned int tcolorkey; + unsigned int wamask; + unsigned int pwluts[64]; + unsigned int dacctrl; + unsigned int tgen; + unsigned int vbnp; + unsigned int vbap; + unsigned int vsnp; + unsigned int vsap; + unsigned int hsnp; + unsigned int hbnp; + unsigned int hbap; + unsigned int hsyncnp; + unsigned int hsyncap; + unsigned int hscennp; + unsigned int hscenap; + unsigned int epnp; + unsigned int einp; + unsigned int eiap; +} ffb_dac_hwstate_t; + +typedef struct { + Bool InUse; + + /* The following fields are undefined unless InUse is TRUE. */ + int refcount; + Bool canshare; + unsigned int wlut_regval; + int buffer; /* 0 = Buffer A, 1 = Buffer B */ + int depth; /* 8 or 32 bpp */ + int greyscale; /* 1 = greyscale, 0 = color */ + int linear; /* 1 = linear, 0 = non-linear */ + int direct; /* 1 = 24bpp directcolor */ + int channel; /* 0 = X, 1 = R, 2 = G, 3 = B */ + int palette; /* Only PAC2 has multiple CLUTs */ +} ffb_wid_info_t; + +#define FFB_MAX_PWIDS 64 +typedef struct { + int num_wids; + int wid_shift; /* To get X channel value */ + ffb_wid_info_t wid_pool[FFB_MAX_PWIDS]; +} ffb_wid_pool_t; + +typedef struct ffb_dac_info { + unsigned int flags; +#define FFB_DAC_PAC1 0x00000001 /* Pacifica1 DAC, BT9068 */ +#define FFB_DAC_PAC2 0x00000002 /* Pacifica2 DAC, BT498 */ +#define FFB_DAC_ICURCTL 0x00000004 /* Inverted CUR_CTRL bits */ + + unsigned int kernel_wid; + + /* These registers need to be modified when changing DAC + * timing state, so at init time we capture their values. + */ + unsigned int ffbcfg0; + unsigned int ffbcfg2; + unsigned int ffb_passin_ctrl; /* FFB2+/AFB only */ + + ffb_dac_hwstate_t kern_dac_state; + ffb_dac_hwstate_t x_dac_state; + + ffb_wid_pool_t wid_table; +} ffb_dac_info_t; + +#endif /* _FFB_DAC_H */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_drishare.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_drishare.h new file mode 100644 index 000000000..baf2f0d0a --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_drishare.h @@ -0,0 +1,48 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_drishare.h,v 1.2 2000/06/21 00:47:37 dawes Exp $ */ + +#ifndef _FFB_DRISHARE_H +#define _FFB_DRISHARE_H + +typedef struct ffb_dri_state { + int flags; +#define FFB_DRI_FFB2 0x00000001 +#define FFB_DRI_FFB2PLUS 0x00000002 +#define FFB_DRI_PAC1 0x00000004 +#define FFB_DRI_PAC2 0x00000008 + + /* Indexed by DRI drawable id. */ +#define FFB_DRI_NWIDS 64 + unsigned int wid_table[FFB_DRI_NWIDS]; +} ffb_dri_state_t; + +#define FFB_DRISHARE(SAREA) \ + ((ffb_dri_state_t *) (((char *)(SAREA)) + sizeof(drm_sarea_t))) + +typedef struct { + drm_handle_t hFbcRegs; + drmSize sFbcRegs; + + drm_handle_t hDacRegs; + drmSize sDacRegs; + + drm_handle_t hSfb8r; + drmSize sSfb8r; + + drm_handle_t hSfb32; + drmSize sSfb32; + + drm_handle_t hSfb64; + drmSize sSfb64; + + /* Fastfill/Pagefill parameters. */ + unsigned char disable_pagefill; + int fastfill_small_area; + int pagefill_small_area; + int fastfill_height; + int fastfill_width; + int pagefill_height; + int pagefill_width; + short Pf_AlignTab[0x800]; +} FFBDRIRec, *FFBDRIPtr; + +#endif /* !(_FFB_DRISHARE_H) */ diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_regs.h b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_regs.h new file mode 100644 index 000000000..7f383d38d --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_regs.h @@ -0,0 +1,509 @@ +/* + * Acceleration for the Creator and Creator3D framebuffer - register layout. + * + * Copyright (C) 1998,1999,2000 Jakub Jelinek (jakub@redhat.com) + * Copyright (C) 1998 Michal Rehacek (majkl@iname.com) + * Copyright (C) 1999 David S. Miller (davem@redhat.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * JAKUB JELINEK, MICHAL REHACEK, OR DAVID MILLER BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_regs.h,v 1.1 2000/05/18 23:21:37 dawes Exp $ */ + +#ifndef FFBREGS_H +#define FFBREGS_H + +/* Auxilliary clips. */ +typedef struct { + volatile unsigned int min; + volatile unsigned int max; +} ffb_auxclip, *ffb_auxclipPtr; + +/* FFB register set. */ +typedef struct _ffb_fbc { + /* Next vertex registers, on the right we list which drawops + * use said register and the logical name the register has in + * that context. + */ /* DESCRIPTION DRAWOP(NAME) */ +/*0x00*/unsigned int pad1[3]; /* Reserved */ +/*0x0c*/volatile unsigned int alpha; /* ALPHA Transparency */ +/*0x10*/volatile unsigned int red; /* RED */ +/*0x14*/volatile unsigned int green; /* GREEN */ +/*0x18*/volatile unsigned int blue; /* BLUE */ +/*0x1c*/volatile unsigned int z; /* DEPTH */ +/*0x20*/volatile unsigned int y; /* Y triangle(DOYF) */ + /* aadot(DYF) */ + /* ddline(DYF) */ + /* aaline(DYF) */ +/*0x24*/volatile unsigned int x; /* X triangle(DOXF) */ + /* aadot(DXF) */ + /* ddline(DXF) */ + /* aaline(DXF) */ +/*0x28*/unsigned int pad2[2]; /* Reserved */ +/*0x30*/volatile unsigned int ryf; /* Y (alias to DOYF) ddline(RYF) */ + /* aaline(RYF) */ + /* triangle(RYF) */ +/*0x34*/volatile unsigned int rxf; /* X ddline(RXF) */ + /* aaline(RXF) */ + /* triangle(RXF) */ +/*0x38*/unsigned int pad3[2]; /* Reserved */ +/*0x40*/volatile unsigned int dmyf; /* Y (alias to DOYF) triangle(DMYF) */ +/*0x44*/volatile unsigned int dmxf; /* X triangle(DMXF) */ +/*0x48*/unsigned int pad4[2]; /* Reserved */ +/*0x50*/volatile unsigned int ebyi; /* Y (alias to RYI) polygon(EBYI) */ +/*0x54*/volatile unsigned int ebxi; /* X polygon(EBXI) */ +/*0x58*/unsigned int pad5[2]; /* Reserved */ +/*0x60*/volatile unsigned int by; /* Y brline(RYI) */ + /* fastfill(OP) */ + /* polygon(YI) */ + /* rectangle(YI) */ + /* bcopy(SRCY) */ + /* vscroll(SRCY) */ +/*0x64*/volatile unsigned int bx; /* X brline(RXI) */ + /* polygon(XI) */ + /* rectangle(XI) */ + /* bcopy(SRCX) */ + /* vscroll(SRCX) */ + /* fastfill(GO) */ +/*0x68*/volatile unsigned int dy; /* destination Y fastfill(DSTY) */ + /* bcopy(DSRY) */ + /* vscroll(DSRY) */ +/*0x6c*/volatile unsigned int dx; /* destination X fastfill(DSTX) */ + /* bcopy(DSTX) */ + /* vscroll(DSTX) */ +/*0x70*/volatile unsigned int bh; /* Y (alias to RYI) brline(DYI) */ + /* dot(DYI) */ + /* polygon(ETYI) */ + /* Height fastfill(H) */ + /* bcopy(H) */ + /* vscroll(H) */ + /* Y count fastfill(NY) */ +/*0x74*/volatile unsigned int bw; /* X dot(DXI) */ + /* brline(DXI) */ + /* polygon(ETXI) */ + /* fastfill(W) */ + /* bcopy(W) */ + /* vscroll(W) */ + /* fastfill(NX) */ +/*0x78*/unsigned int pad6[2]; /* Reserved */ +/*0x80*/unsigned int pad7[32]; /* Reserved */ + + /* Setup Unit's vertex state register */ +/*100*/ volatile unsigned int suvtx; +/*104*/ unsigned int pad8[63]; /* Reserved */ + + /* Frame Buffer Control Registers */ +/*200*/ volatile unsigned int ppc; /* Pixel Processor Control */ +/*204*/ volatile unsigned int wid; /* Current WID */ +/*208*/ volatile unsigned int fg; /* FG data */ +/*20c*/ volatile unsigned int bg; /* BG data */ +/*210*/ volatile unsigned int consty; /* Constant Y */ +/*214*/ volatile unsigned int constz; /* Constant Z */ +/*218*/ volatile unsigned int xclip; /* X Clip */ +/*21c*/ volatile unsigned int dcss; /* Depth Cue Scale Slope */ +/*220*/ volatile unsigned int vclipmin; /* Viewclip XY Min Bounds */ +/*224*/ volatile unsigned int vclipmax; /* Viewclip XY Max Bounds */ +/*228*/ volatile unsigned int vclipzmin; /* Viewclip Z Min Bounds */ +/*22c*/ volatile unsigned int vclipzmax; /* Viewclip Z Max Bounds */ +/*230*/ volatile unsigned int dcsf; /* Depth Cue Scale Front Bound */ +/*234*/ volatile unsigned int dcsb; /* Depth Cue Scale Back Bound */ +/*238*/ volatile unsigned int dczf; /* Depth Cue Z Front */ +/*23c*/ volatile unsigned int dczb; /* Depth Cue Z Back */ +/*240*/ unsigned int pad9; /* Reserved */ +/*244*/ volatile unsigned int blendc; /* Alpha Blend Control */ +/*248*/ volatile unsigned int blendc1; /* Alpha Blend Color 1 */ +/*24c*/ volatile unsigned int blendc2; /* Alpha Blend Color 2 */ +/*250*/ volatile unsigned int fbramitc; /* FB RAM Interleave Test Control */ +/*254*/ volatile unsigned int fbc; /* Frame Buffer Control */ +/*258*/ volatile unsigned int rop; /* Raster OPeration */ +/*25c*/ volatile unsigned int cmp; /* Frame Buffer Compare */ +/*260*/ volatile unsigned int matchab; /* Buffer AB Match Mask */ +/*264*/ volatile unsigned int matchc; /* Buffer C(YZ) Match Mask */ +/*268*/ volatile unsigned int magnab; /* Buffer AB Magnitude Mask */ +/*26c*/ volatile unsigned int magnc; /* Buffer C(YZ) Magnitude Mask */ +/*270*/ volatile unsigned int fbcfg0; /* Frame Buffer Config 0 */ +/*274*/ volatile unsigned int fbcfg1; /* Frame Buffer Config 1 */ +/*278*/ volatile unsigned int fbcfg2; /* Frame Buffer Config 2 */ +/*27c*/ volatile unsigned int fbcfg3; /* Frame Buffer Config 3 */ +/*280*/ volatile unsigned int ppcfg; /* Pixel Processor Config */ +/*284*/ volatile unsigned int pick; /* Picking Control */ +/*288*/ volatile unsigned int fillmode; /* FillMode */ +/*28c*/ volatile unsigned int fbramwac; /* FB RAM Write Address Control */ +/*290*/ volatile unsigned int pmask; /* RGB PlaneMask */ +/*294*/ volatile unsigned int xpmask; /* X PlaneMask */ +/*298*/ volatile unsigned int ypmask; /* Y PlaneMask */ +/*29c*/ volatile unsigned int zpmask; /* Z PlaneMask */ +/*2a0*/ ffb_auxclip auxclip[4]; /* Auxilliary Viewport Clip */ + + /* New 3dRAM III support regs */ +/*2c0*/ volatile unsigned int rawblend2; +/*2c4*/ volatile unsigned int rawpreblend; +/*2c8*/ volatile unsigned int rawstencil; +/*2cc*/ volatile unsigned int rawstencilctl; +/*2d0*/ volatile unsigned int threedram1; +/*2d4*/ volatile unsigned int threedram2; +/*2d8*/ volatile unsigned int passin; +/*2dc*/ volatile unsigned int rawclrdepth; +/*2e0*/ volatile unsigned int rawpmask; +/*2e4*/ volatile unsigned int rawcsrc; +/*2e8*/ volatile unsigned int rawmatch; +/*2ec*/ volatile unsigned int rawmagn; +/*2f0*/ volatile unsigned int rawropblend; +/*2f4*/ volatile unsigned int rawcmp; +/*2f8*/ volatile unsigned int rawwac; +/*2fc*/ volatile unsigned int fbramid; + +/*300*/ volatile unsigned int drawop; /* Draw OPeration */ +/*304*/ unsigned int pad10[2]; /* Reserved */ +/*30c*/ volatile unsigned int lpat; /* Line Pattern control */ +/*310*/ unsigned int pad11; /* Reserved */ +/*314*/ volatile unsigned int fontxy; /* XY Font coordinate */ +/*318*/ volatile unsigned int fontw; /* Font Width */ +/*31c*/ volatile unsigned int fontinc; /* Font Increment */ +/*320*/ volatile unsigned int font; /* Font bits */ +/*324*/ unsigned int pad12[3]; /* Reserved */ +/*330*/ volatile unsigned int blend2; +/*334*/ volatile unsigned int preblend; +/*338*/ volatile unsigned int stencil; +/*33c*/ volatile unsigned int stencilctl; + +/*340*/ unsigned int pad13[4]; /* Reserved */ +/*350*/ volatile unsigned int dcss1; /* Depth Cue Scale Slope 1 */ +/*354*/ volatile unsigned int dcss2; /* Depth Cue Scale Slope 2 */ +/*358*/ volatile unsigned int dcss3; /* Depth Cue Scale Slope 3 */ +/*35c*/ volatile unsigned int widpmask; +/*360*/ volatile unsigned int dcs2; +/*364*/ volatile unsigned int dcs3; +/*368*/ volatile unsigned int dcs4; +/*36c*/ unsigned int pad14; /* Reserved */ +/*370*/ volatile unsigned int dcd2; +/*374*/ volatile unsigned int dcd3; +/*378*/ volatile unsigned int dcd4; +/*37c*/ unsigned int pad15; /* Reserved */ +/*380*/ volatile unsigned int pattern[32]; /* area Pattern */ +/*400*/ unsigned int pad16[8]; /* Reserved */ +/*420*/ volatile unsigned int reset; /* chip RESET */ +/*424*/ unsigned int pad17[247]; /* Reserved */ +/*800*/ volatile unsigned int devid; /* Device ID */ +/*804*/ unsigned int pad18[63]; /* Reserved */ +/*900*/ volatile unsigned int ucsr; /* User Control & Status Register */ +/*904*/ unsigned int pad19[31]; /* Reserved */ +/*980*/ volatile unsigned int mer; /* Mode Enable Register */ +/*984*/ unsigned int pad20[1439]; /* Reserved */ +} ffb_fbc, *ffb_fbcPtr; + +/* Draw operations */ +#define FFB_DRAWOP_DOT 0x00 +#define FFB_DRAWOP_AADOT 0x01 +#define FFB_DRAWOP_BRLINECAP 0x02 +#define FFB_DRAWOP_BRLINEOPEN 0x03 +#define FFB_DRAWOP_DDLINE 0x04 +#define FFB_DRAWOP_AALINE 0x05 +#define FFB_DRAWOP_TRIANGLE 0x06 +#define FFB_DRAWOP_POLYGON 0x07 +#define FFB_DRAWOP_RECTANGLE 0x08 +#define FFB_DRAWOP_FASTFILL 0x09 +#define FFB_DRAWOP_BCOPY 0x0a /* Not implemented in any FFB, VIS is faster */ +#define FFB_DRAWOP_VSCROLL 0x0b /* Up to 12x faster than BCOPY, 3-4x faster than VIS */ + +/* FastFill operation codes. */ +#define FFB_FASTFILL_PAGE 0x01 +#define FFB_FASTFILL_BLOCK 0x02 +#define FFB_FASTFILL_COLOR_BLK 0x03 +#define FFB_FASTFILL_BLOCK_X 0x04 + +/* Spanfill Unit Line Pattern */ +#define FFB_LPAT_SCALEPTR 0xf0000000 +#define FFB_LPAT_SCALEPTR_SHIFT 28 +#define FFB_LPAT_PATPTR 0x0f000000 +#define FFB_LPAT_PATPTR_SHIFT 24 +#define FFB_LPAT_SCALEVAL 0x00f00000 +#define FFB_LPAT_SCALEVAL_SHIFT 20 +#define FFB_LPAT_PATLEN 0x000f0000 +#define FFB_LPAT_PATLEN_SHIFT 16 +#define FFB_LPAT_PATTERN 0x0000ffff +#define FFB_LPAT_PATTERN_SHIFT 0 + +/* Pixel processor control */ +/* Force WID */ +#define FFB_PPC_FW_DISABLE 0x800000 +#define FFB_PPC_FW_ENABLE 0xc00000 +#define FFB_PPC_FW_MASK 0xc00000 +/* Auxiliary clip */ +#define FFB_PPC_ACE_DISABLE 0x040000 +#define FFB_PPC_ACE_AUX_SUB 0x080000 +#define FFB_PPC_ACE_AUX_ADD 0x0c0000 +#define FFB_PPC_ACE_MASK 0x0c0000 +/* Depth cue */ +#define FFB_PPC_DCE_DISABLE 0x020000 +#define FFB_PPC_DCE_ENABLE 0x030000 +#define FFB_PPC_DCE_MASK 0x030000 +/* Alpha blend */ +#define FFB_PPC_ABE_DISABLE 0x008000 +#define FFB_PPC_ABE_ENABLE 0x00c000 +#define FFB_PPC_ABE_MASK 0x00c000 +/* View clip */ +#define FFB_PPC_VCE_DISABLE 0x001000 +#define FFB_PPC_VCE_2D 0x002000 +#define FFB_PPC_VCE_3D 0x003000 +#define FFB_PPC_VCE_MASK 0x003000 +/* Area pattern */ +#define FFB_PPC_APE_DISABLE 0x000800 +#define FFB_PPC_APE_ENABLE 0x000c00 +#define FFB_PPC_APE_MASK 0x000c00 +/* Transparent background */ +#define FFB_PPC_TBE_OPAQUE 0x000200 +#define FFB_PPC_TBE_TRANSPARENT 0x000300 +#define FFB_PPC_TBE_MASK 0x000300 +/* Z source */ +#define FFB_PPC_ZS_VAR 0x000080 +#define FFB_PPC_ZS_CONST 0x0000c0 +#define FFB_PPC_ZS_MASK 0x0000c0 +/* Y source */ +#define FFB_PPC_YS_VAR 0x000020 +#define FFB_PPC_YS_CONST 0x000030 +#define FFB_PPC_YS_MASK 0x000030 +/* X source */ +#define FFB_PPC_XS_WID 0x000004 +#define FFB_PPC_XS_VAR 0x000008 +#define FFB_PPC_XS_CONST 0x00000c +#define FFB_PPC_XS_MASK 0x00000c +/* Color (BGR) source */ +#define FFB_PPC_CS_VAR 0x000002 +#define FFB_PPC_CS_CONST 0x000003 +#define FFB_PPC_CS_MASK 0x000003 + +/* X Clip */ +#define FFB_XCLIP_XREF 0x000000ff +#define FFB_XCLIP_TEST_MASK 0x00070000 +#define FFB_XCLIP_TEST_ALWAYS 0x00000000 +#define FFB_XCLIP_TEST_GT 0x00010000 +#define FFB_XCLIP_TEST_EQ 0x00020000 +#define FFB_XCLIP_TEST_GE 0x00030000 +#define FFB_XCLIP_TEST_NEVER 0x00040000 +#define FFB_XCLIP_TEST_LE 0x00050000 +#define FFB_XCLIP_TEST_NE 0x00060000 +#define FFB_XCLIP_TEST_LT 0x00070000 + +/* FB Control register */ +/* Write buffer dest */ +#define FFB_FBC_WB_A 0x20000000 +#define FFB_FBC_WB_B 0x40000000 +#define FFB_FBC_WB_AB 0x60000000 +#define FFB_FBC_WB_C 0x80000000 +#define FFB_FBC_WB_AC 0xa0000000 +#define FFB_FBC_WB_BC 0xc0000000 +#define FFB_FBC_WB_ABC 0xe0000000 +#define FFB_FBC_WB_MASK 0xe0000000 +/* Write enable */ +#define FFB_FBC_WE_FORCEOFF 0x00100000 +#define FFB_FBC_WE_FORCEON 0x00200000 +#define FFB_FBC_WE_USE_WMASK 0x00300000 +#define FFB_FBC_WE_MASK 0x00300000 +/* Write group mode */ +#define FFB_FBC_WM_RSVD 0x00040000 +#define FFB_FBC_WM_COMBINED 0x00080000 +#define FFB_FBC_WM_SEPARATE 0x000c0000 +#define FFB_FBC_WM_MASK 0x000c0000 +/* Read buffer src */ +#define FFB_FBC_RB_A 0x00004000 +#define FFB_FBC_RB_B 0x00008000 +#define FFB_FBC_RB_C 0x0000c000 +#define FFB_FBC_RB_MASK 0x0000c000 +/* Stereo buf dest */ +#define FFB_FBC_SB_LEFT 0x00001000 +#define FFB_FBC_SB_RIGHT 0x00002000 +#define FFB_FBC_SB_BOTH 0x00003000 +#define FFB_FBC_SB_MASK 0x00003000 +/* Z plane group enable */ +#define FFB_FBC_ZE_OFF 0x00000400 +#define FFB_FBC_ZE_ON 0x00000800 +#define FFB_FBC_ZE_MASK 0x00000c00 +/* Y plane group enable */ +#define FFB_FBC_YE_OFF 0x00000100 +#define FFB_FBC_YE_ON 0x00000200 +#define FFB_FBC_YE_MASK 0x00000300 +/* X plane group enable */ +#define FFB_FBC_XE_OFF 0x00000040 +#define FFB_FBC_XE_ON 0x00000080 +#define FFB_FBC_XE_MASK 0x000000c0 +/* B plane group enable */ +#define FFB_FBC_BE_OFF 0x00000010 +#define FFB_FBC_BE_ON 0x00000020 +#define FFB_FBC_BE_MASK 0x00000030 +/* G plane group enable */ +#define FFB_FBC_GE_OFF 0x00000004 +#define FFB_FBC_GE_ON 0x00000008 +#define FFB_FBC_GE_MASK 0x0000000c +/* R plane group enable */ +#define FFB_FBC_RE_OFF 0x00000001 +#define FFB_FBC_RE_ON 0x00000002 +#define FFB_FBC_RE_MASK 0x00000003 +/* Combined */ +#define FFB_FBC_RGBE_OFF 0x00000015 +#define FFB_FBC_RGBE_ON 0x0000002a +#define FFB_FBC_RGBE_MASK 0x0000003f + +/* Raster OP */ +#define FFB_ROP_YZ_MASK 0x008f0000 +#define FFB_ROP_X_MASK 0x00008f00 +#define FFB_ROP_RGB_MASK 0x0000008f + +/* Now the rops themselves which get shifted into the + * above fields. + */ +#define FFB_ROP_EDIT_BIT 0x80 +#define FFB_ROP_ZERO 0x80 +#define FFB_ROP_NEW_AND_OLD 0x81 +#define FFB_ROP_NEW_AND_NOLD 0x82 +#define FFB_ROP_NEW 0x83 +#define FFB_ROP_NNEW_AND_OLD 0x84 +#define FFB_ROP_OLD 0x85 +#define FFB_ROP_NEW_XOR_OLD 0x86 +#define FFB_ROP_NEW_OR_OLD 0x87 +#define FFB_ROP_NNEW_AND_NOLD 0x88 +#define FFB_ROP_NNEW_XOR_NOLD 0x89 +#define FFB_ROP_NOLD 0x8a +#define FFB_ROP_NEW_OR_NOLD 0x8b +#define FFB_ROP_NNEW 0x8c +#define FFB_ROP_NNEW_OR_OLD 0x8d +#define FFB_ROP_NNEW_OR_NOLD 0x8e +#define FFB_ROP_ONES 0x8f + +/* FB Compare */ +#define FFB_CMP_MATCHC_MASK 0x8f000000 +#define FFB_CMP_MAGNC_MASK 0x00870000 +#define FFB_CMP_MATCHAB_MASK 0x0000ff00 +#define FFB_CMP_MAGNAB_MASK 0x000000ff + +/* Compare Match codes */ +#define FFB_CMP_MATCH_EDIT_BIT 0x80 +#define FFB_CMP_MATCH_ALWAYS 0x80 +#define FFB_CMP_MATCH_NEVER 0x81 +#define FFB_CMP_MATCH_EQ 0x82 +#define FFB_CMP_MATCH_NE 0x83 +#define FFB_CMP_MATCH_A_ALWAYS 0xc0 +#define FFB_CMP_MATCH_B_ALWAYS 0xa0 + +/* Compare Magnitude codes */ +#define FFB_CMP_MAGN_EDIT_BIT 0x80 +#define FFB_CMP_MAGN_ALWAYS 0x80 +#define FFB_CMP_MAGN_GT 0x81 +#define FFB_CMP_MAGN_EQ 0x82 +#define FFB_CMP_MAGN_GE 0x83 +#define FFB_CMP_MAGN_NEVER 0x84 +#define FFB_CMP_MAGN_LE 0x85 +#define FFB_CMP_MAGN_NE 0x86 +#define FFB_CMP_MAGN_LT 0x87 +#define FFB_CMP_MAGN_A_ALWAYS 0xc0 +#define FFB_CMP_MAGN_B_ALWAYS 0xa0 + +/* User Control and Status */ +#define FFB_UCSR_FIFO_MASK 0x00000fff +#define FFB_UCSR_PICK_NO_HIT 0x00020000 +#define FFB_UCSR_PICK_HIT 0x00030000 +#define FFB_UCSR_PICK_DISABLE 0x00080000 +#define FFB_UCSR_PICK_ENABLE 0x000c0000 +#define FFB_UCSR_FB_BUSY 0x01000000 +#define FFB_UCSR_RP_BUSY 0x02000000 +#define FFB_UCSR_ALL_BUSY (FFB_UCSR_RP_BUSY|FFB_UCSR_FB_BUSY) +#define FFB_UCSR_READ_ERR 0x40000000 +#define FFB_UCSR_FIFO_OVFL 0x80000000 +#define FFB_UCSR_ALL_ERRORS (FFB_UCSR_READ_ERR|FFB_UCSR_FIFO_OVFL) + +/* Mode Enable Register */ +#define FFB_MER_EIRA 0x00000080 /* Enable read-ahead, increasing */ +#define FFB_MER_EDRA 0x000000c0 /* Enable read-ahead, decreasing */ +#define FFB_MER_DRA 0x00000040 /* No read-ahead */ + +/* FBram Config 0 */ +#define FFB_FBCFG0_RFTIME 0xff800000 +#define FFB_FBCFG0_XMAX 0x007c0000 +#define FFB_FBCFG0_YMAX 0x0003ffc0 +#define FFB_FBCFG0_RES_MASK 0x00000030 +#define FFB_FBCFG0_RES_HIGH 0x00000030 /* 1920x1360 */ +#define FFB_FBCFG0_RES_STD 0x00000020 /* 1280x1024 */ +#define FFB_FBCFG0_RES_STEREO 0x00000010 /* 960x580 */ +#define FFB_FBCFG0_RES_PRTRAIT 0x00000000 /* 1280x2048 */ +#define FFB_FBCFG0_ITRLACE 0x00000000 +#define FFB_FBCFG0_SEQUENTIAL 0x00000008 +#define FFB_FBCFG0_DRENA 0x00000004 +#define FFB_FBCFG0_BPMODE 0x00000002 +#define FFB_FBCFG0_RFRSH_RST 0x00000001 + +typedef struct _ffb_dac { + volatile unsigned int cfg; + volatile unsigned int cfgdata; + volatile unsigned int cur; + volatile unsigned int curdata; +} ffb_dac, *ffb_dacPtr; + +/* Writing 2 32-bit registers at a time using 64-bit stores. -DaveM */ +#if defined(__GNUC__) && defined(USE_VIS) +/* 64-bit register writing support. + * Note: "lo" means "low address". + */ +#define FFB_WRITE64_COMMON(__regp, __lo32, __hi32, REG0, REG1) \ +do { __extension__ register unsigned int __r0 __asm__(""#REG0); \ + __extension__ register unsigned int __r1 __asm__(""#REG1); \ + __r0 = (__lo32); \ + __r1 = (__hi32); \ + __asm__ __volatile__ ("sllx\t%0, 32, %%g1\n\t" \ + "srl\t%1, 0, %1\n\t" \ + "or\t%%g1, %1, %%g1\n\t" \ + "stx\t%%g1, %2" \ + : : "r" (__r0), "r" (__r1), "m" (*(__regp)) : "g1"); \ +} while(0) + +#define FFB_WRITE64P(__regp, __srcp) \ +do { __asm__ __volatile__ ("ldx\t%0, %%g2;" \ + "stx\t%%g2, %1" \ + : : "m" (*(__srcp)), "m" (*(__regp)) \ + : "g2"); \ +} while(0) + +#define FFB_WRITE64(__regp, __lo32, __hi32) \ + FFB_WRITE64_COMMON(__regp, __lo32, __hi32, g2, g3) +#define FFB_WRITE64_2(__regp, __lo32, __hi32) \ + FFB_WRITE64_COMMON(__regp, __lo32, __hi32, g4, g5) +#define FFB_WRITE64_3(__regp, __lo32, __hi32) \ + FFB_WRITE64_COMMON(__regp, __lo32, __hi32, o4, o5) + +#else /* Do not use 64-bit writes. */ + +#define FFB_WRITE64(__regp, __lo32, __hi32) \ +do { volatile unsigned int *__p = (__regp); \ + *__p = (__lo32); \ + *(__p + 1) = (__hi32); \ +} while(0) + +#define FFB_WRITE64P(__regp, __srcp) \ +do { volatile unsigned int *__p = (__regp); \ + unsigned int *__q = (__srcp); \ + *__p = *__q; \ + *(__p + 1) = *(__q + 1); \ +} while(0) + +#define FFB_WRITE64_2(__regp, __lo32, __hi32) \ + FFB_WRITE64(__regp, __lo32, __hi32) +#define FFB_WRITE64_3(__regp, __lo32, __hi32) \ + FFB_WRITE64(__regp, __lo32, __hi32) +#endif + +#endif /* FFBREGS_H */ |