aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
commitf4092abdf94af6a99aff944d6264bc1284e8bdd4 (patch)
tree2ac1c9cc16ceb93edb2c4382c088dac5aeafdf0f /nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb
parenta840692edc9c6d19cd7c057f68e39c7d95eb767d (diff)
downloadnx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.gz
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.bz2
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.zip
Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1
Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository
Diffstat (limited to 'nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb')
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/Makefile36
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_bitmap.c159
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_bitmap.h8
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_clear.c354
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_clear.h9
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_context.h306
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_dd.c119
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_dd.h36
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_depth.c245
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_depth.h8
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_fifo.h28
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_fog.c73
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lines.c111
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lines.h18
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_linetmp.h81
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_lock.h37
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_points.c93
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_points.h15
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_pointtmp.h55
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_rendertmp.h646
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_span.c135
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_span.h10
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_state.c1223
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_state.h13
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_stencil.c226
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_stencil.h8
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tex.c53
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tex.h34
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tris.c945
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tris.h26
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_tritmp.h239
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vb.c209
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vb.h45
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vbtmp.h151
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vtxfmt.c427
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_vtxfmt.h8
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_xmesa.c753
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/ffb_xmesa.h26
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_dac.h367
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_drishare.h48
-rw-r--r--nx-X11/extras/Mesa/src/mesa/drivers/dri/ffb/server/ffb_regs.h509
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 */