git.oblomov.eu Git - nouveau/blob - src/nv10_exa.c

   1 #ifdef HAVE_CONFIG_H
   2 #include "config.h"
   3 #endif
   4
   5 #include "nv_include.h"
   6
   7 typedef struct nv10_exa_state {
   8         Bool have_mask;
   9
  10         struct {
  11                 PictTransformPtr transform;
  12                 float width;
  13                 float height;
  14         } unit[2];
  15 } nv10_exa_state_t;
  16 static nv10_exa_state_t state;
  17
  18 static int NV10TexFormat(int ExaFormat)
  19 {
  20         struct {int exa;int hw;} tex_format[] =
  21         {
  22                 {PICT_a8r8g8b8, NV10_TCL_PRIMITIVE_3D_TX_FORMAT_FORMAT_R8G8B8A8},
  23                 {PICT_a1r5g5b5, NV10_TCL_PRIMITIVE_3D_TX_FORMAT_FORMAT_R5G5B5A1},
  24                 {PICT_a4r4g4b4, NV10_TCL_PRIMITIVE_3D_TX_FORMAT_FORMAT_R4G4B4A4},
  25                 {PICT_a8,       NV10_TCL_PRIMITIVE_3D_TX_FORMAT_FORMAT_A8_RECT}
  26                 // FIXME other formats
  27         };
  28
  29         int i;
  30         for(i=0;i<sizeof(tex_format)/sizeof(tex_format[0]);i++)
  31         {
  32                 if(tex_format[i].exa==ExaFormat)
  33                         return tex_format[i].hw;
  34         }
  35
  36         return 0;
  37 }
  38
  39 static int NV10DstFormat(int ExaFormat)
  40 {
  41         struct {int exa;int hw;} dst_format[] =
  42         {
  43                 {PICT_a8r8g8b8, 0x108},
  44                 {PICT_x8r8g8b8, 0x108}, // FIXME that one might need more
  45                 {PICT_r5g6b5,   0x103}
  46                 // FIXME other formats
  47         };
  48
  49         int i;
  50         for(i=0;i<sizeof(dst_format)/sizeof(dst_format[0]);i++)
  51         {
  52                 if(dst_format[i].exa==ExaFormat)
  53                         return dst_format[i].hw;
  54         }
  55
  56         return 0;
  57 }
  58
  59 static Bool NV10CheckTexture(PicturePtr Picture)
  60 {
  61         int w = Picture->pDrawable->width;
  62         int h = Picture->pDrawable->height;
  63
  64         if ((w > 2046) || (h>2046))
  65                 return FALSE;
  66         if (!NV10TexFormat(Picture->format))
  67                 return FALSE;
  68         if (Picture->filter != PictFilterNearest && Picture->filter != PictFilterBilinear)
  69                 return FALSE;
  70         if (Picture->repeat != RepeatNone)
  71                 return FALSE;
  72         return TRUE;
  73 }
  74
  75 static Bool NV10CheckBuffer(PicturePtr Picture)
  76 {
  77         int w = Picture->pDrawable->width;
  78         int h = Picture->pDrawable->height;
  79
  80         if ((w > 4096) || (h>4096))
  81                 return FALSE;
  82         if (!NV10DstFormat(Picture->format))
  83                 return FALSE;
  84         return TRUE;
  85 }
  86
  87 static Bool NV10CheckComposite(int      op,
  88                              PicturePtr pSrcPicture,
  89                              PicturePtr pMaskPicture,
  90                              PicturePtr pDstPicture)
  91 {
  92         // XXX A8 + A8 special case "TO BE DONE LATER"
  93 /*      if ((!pMaskPicture) &&
  94                         (pSrcPicture->format == PICT_a8) &&
  95                         (pDstPicture->format == PICT_a8) )
  96                 return TRUE;*/
  97
  98         if (!NV10CheckBuffer(pDstPicture))
  99                 return FALSE;
 100         if (!NV10CheckTexture(pSrcPicture))
 101                 return FALSE;
 102         if ((pMaskPicture)&&(!NV10CheckTexture(pMaskPicture)))
 103                 return FALSE;
 104
 105         return TRUE;
 106 }
 107
 108 static void NV10SetTexture(NVPtr pNv,int unit,PicturePtr Pict,PixmapPtr pixmap)
 109 {
 110         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_TX_OFFSET(unit), 1 );
 111         NVDmaNext (pNv, NVAccelGetPixmapOffset(pixmap));
 112
 113         int log2w = (int)log2(Pict->pDrawable->width);
 114         int log2h = (int)log2(Pict->pDrawable->height);
 115         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_TX_FORMAT(unit), 1 );
 116         NVDmaNext (pNv, (NV10_TCL_PRIMITIVE_3D_TX_FORMAT_WRAP_T_CLAMP_TO_EDGE<<28) |
 117                         (NV10_TCL_PRIMITIVE_3D_TX_FORMAT_WRAP_S_CLAMP_TO_EDGE<<24) |
 118                         (log2w<<20) |
 119                         (log2h<<16) |
 120                         (1<<12) | /* lod == 1 */
 121                         (1<<11) | /* enable NPOT */
 122                         (NV10TexFormat(Pict->format)<<7) |
 123                         0x51 /* UNK */
 124                         );
 125
 126         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_TX_ENABLE(unit), 1 );
 127         NVDmaNext (pNv, 1);
 128
 129         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_TX_NPOT_PITCH(unit), 1);
 130         NVDmaNext (pNv, exaGetPixmapPitch(pixmap) << 16);
 131
 132         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_TX_NPOT_SIZE(unit), 1);
 133         NVDmaNext (pNv, (Pict->pDrawable->width<<16) | Pict->pDrawable->height); /* FIXME alignment restrictions, should be even at least */
 134
 135         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_TX_FILTER(unit), 1);
 136         if (Pict->filter == PictFilterNearest)
 137                 NVDmaNext (pNv, (NV10_TCL_PRIMITIVE_3D_TX_FILTER_MAG_FILTER_NEAREST<<28) |
 138                                 (NV10_TCL_PRIMITIVE_3D_TX_FILTER_MIN_FILTER_NEAREST<<24));
 139         else
 140                 NVDmaNext (pNv, (NV10_TCL_PRIMITIVE_3D_TX_FILTER_MAG_FILTER_LINEAR<<28) |
 141                                 (NV10_TCL_PRIMITIVE_3D_TX_FILTER_MIN_FILTER_LINEAR<<24));
 142
 143         state.unit[unit].width          = (float)pixmap->drawable.width;
 144         state.unit[unit].height         = (float)pixmap->drawable.height;
 145         state.unit[unit].transform      = Pict->transform;
 146 }
 147
 148 static void NV10SetBuffer(NVPtr pNv,PicturePtr Pict,PixmapPtr pixmap)
 149 {
 150         int x = 0,y = 0,i;
 151         int w = Pict->pDrawable->width;
 152         int h = Pict->pDrawable->height;
 153         float projectionmatrix[16];
 154
 155         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_BUFFER_FORMAT, 4);
 156         NVDmaNext (pNv, NV10DstFormat(Pict->format));
 157         NVDmaNext (pNv, ((uint32_t)exaGetPixmapPitch(pixmap) << 16) |(uint32_t)exaGetPixmapPitch(pixmap));
 158         NVDmaNext (pNv, NVAccelGetPixmapOffset(pixmap));
 159         NVDmaNext (pNv, 0);
 160         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_HORIZ, 2);
 161         NVDmaNext (pNv, (w<<16)|x);
 162         NVDmaNext (pNv, (h<<16)|y);
 163         NVDmaStart(pNv, Nv3D, 0x2b4, 1); /* clip_mode */
 164         NVDmaNext (pNv, 0);
 165         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_CLIP_HORIZ(0), 1);
 166         NVDmaNext (pNv, ((w-1+x)<<16)|x|0x08000800);
 167         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_CLIP_VERT(0), 1);
 168         NVDmaNext (pNv, ((h-1+y)<<16)|y|0x08000800);
 169
 170         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_PROJECTION_MATRIX(0), 16);
 171         projectionmatrix[0*4+0] = w * 0.5;
 172         projectionmatrix[1*4+1] = h * -0.5;
 173 #if SCREEN_BPP == 32
 174         projectionmatrix[2*4+2] = 16777215.0 * 0.5;
 175 #else
 176         projectionmatrix[2*4+2] = 65535.0 * 0.5;
 177 #endif
 178         projectionmatrix[3*4+3] = 1.0;
 179         for (i=0;i<16;i++) {
 180                 NVDmaFloat (pNv, projectionmatrix[i]);
 181         }
 182         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_DEPTH_RANGE_NEAR, 2);
 183         NVDmaNext (pNv, 0);
 184 #if SCREEN_BPP == 32
 185         NVDmaFloat (pNv, 16777216.0);
 186 #else
 187         NVDmaFloat (pNv, 65536.0);
 188 #endif
 189         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_SCALE_X, 4);
 190         NVDmaFloat (pNv, (w * 0.5) - 2048.0);
 191         NVDmaFloat (pNv, (h * 0.5) - 2048.0);
 192 #if SCREEN_BPP == 32
 193         NVDmaFloat (pNv, 16777215.0 * 0.5);
 194 #else
 195         NVDmaFloat (pNv, 65535.0 * 0.5);
 196 #endif
 197         NVDmaNext (pNv, 0);
 198 }
 199
 200 static void NV10SetPictOp(NVPtr pNv,int op)
 201 {
 202         struct {int src;int dst;} pictops[] =
 203         {
 204                 {0x0000,0x0000}, // PictOpClear
 205                 {0x0001,0x0000}, // PictOpSrc
 206                 {0x0000,0x0001}, // PictOpDst
 207                 {0x0001,0x0303}, // PictOpOver
 208                 {0x0305,0x0001}, // PictOpOverReverse
 209                 {0x0304,0x0000}, // PictOpIn
 210                 {0x0000,0x0302}, // PictOpInReverse
 211                 {0x0305,0x0000}, // PictOpOut
 212                 {0x0000,0x0303}, // PictOpOutReverse
 213                 {0x0304,0x0303}, // PictOpAtop
 214                 {0x0305,0x0302}, // PictOpAtopReverse
 215                 {0x0305,0x0303}, // PictOpXor
 216                 {0x0001,0x0001}, // PictOpAdd
 217         };
 218
 219         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_BLEND_FUNC_SRC, 2);
 220         NVDmaNext (pNv, pictops[op].src);
 221         NVDmaNext (pNv, pictops[op].dst);
 222 }
 223
 224 static Bool NV10PrepareComposite(int      op,
 225                                PicturePtr pSrcPicture,
 226                                PicturePtr pMaskPicture,
 227                                PicturePtr pDstPicture,
 228                                PixmapPtr  pSrc,
 229                                PixmapPtr  pMask,
 230                                PixmapPtr  pDst)
 231 {
 232         ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
 233         NVPtr pNv = NVPTR(pScrn);
 234
 235         /* Set dst format */
 236         NV10SetBuffer(pNv,pDstPicture,pDst);
 237
 238         /* Set src format */
 239         NV10SetTexture(pNv,0,pSrcPicture,pSrc);
 240
 241         /* Set mask format */
 242         if (pMaskPicture)
 243                 NV10SetTexture(pNv,1,pMaskPicture,pMask);
 244
 245         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_BEGIN_END, 1);
 246         NVDmaNext (pNv, 8); /* GL_QUADS + 1 */
 247
 248         /* Set PictOp */
 249         NV10SetPictOp(pNv, op);
 250
 251         state.have_mask=(pMaskPicture!=NULL);
 252         return TRUE;
 253 }
 254
 255 static inline void NV10Vertex(NVPtr pNv,float vx,float vy,float tx,float ty)
 256 {
 257         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_TX0_2F_S, 2);
 258         NVDmaFloat(pNv, tx);
 259         NVDmaFloat(pNv, ty);
 260         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_POS_3F_X, 3);
 261         NVDmaFloat(pNv, vx);
 262         NVDmaFloat(pNv, vy);
 263         NVDmaFloat(pNv, 0.f);
 264 }
 265
 266 static inline void NV10MVertex(NVPtr pNv,float vx,float vy,float t0x,float t0y,float t1x,float t1y)
 267 {
 268         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_TX0_2F_S, 2);
 269         NVDmaFloat(pNv, t0x);
 270         NVDmaFloat(pNv, t0y);
 271         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_TX1_2F_S, 2);
 272         NVDmaFloat(pNv, t1x);
 273         NVDmaFloat(pNv, t1y);
 274         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_POS_3F_X, 3);
 275         NVDmaFloat(pNv, vx);
 276         NVDmaFloat(pNv, vy);
 277         NVDmaFloat(pNv, 0.f);
 278 }
 279
 280 #define xFixedToFloat(v) \
 281         ((float)xFixedToInt((v)) + ((float)xFixedFrac(v) / 65536.0))
 282
 283 static void
 284 NV10EXATransformCoord(PictTransformPtr t, int x, int y, float sx, float sy,
 285                                           float *x_ret, float *y_ret)
 286 {
 287         PictVector v;
 288
 289         if (t) {
 290                 v.vector[0] = IntToxFixed(x);
 291                 v.vector[1] = IntToxFixed(y);
 292                 v.vector[2] = xFixed1;
 293                 PictureTransformPoint(t, &v);
 294                 *x_ret = xFixedToFloat(v.vector[0]) / sx;
 295                 *y_ret = xFixedToFloat(v.vector[1]) / sy;
 296         } else {
 297                 *x_ret = (float)x / sx;
 298                 *y_ret = (float)y / sy;
 299         }
 300 }
 301
 302
 303 static void NV10Composite(PixmapPtr pDst,
 304                         int       srcX,
 305                         int       srcY,
 306                         int       maskX,
 307                         int       maskY,
 308                         int       dstX,
 309                         int       dstY,
 310                         int       width,
 311                         int       height)
 312 {
 313         ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
 314         NVPtr pNv = NVPTR(pScrn);
 315         float sX0, sX1, sY0, sY1;
 316         float mX0, mX1, mY0, mY1;
 317
 318         NV10EXATransformCoord(state.unit[0].transform, srcX, srcY,
 319                               state.unit[0].width,
 320                               state.unit[0].height, &sX0, &sY0);
 321         NV10EXATransformCoord(state.unit[0].transform,
 322                               srcX + width, srcY + height,
 323                               state.unit[0].width,
 324                               state.unit[0].height, &sX1, &sY1);
 325
 326         if (state.have_mask) {
 327                 NV10EXATransformCoord(state.unit[1].transform, maskX, maskY,
 328                                       state.unit[1].width,
 329                                       state.unit[1].height, &mX0, &mY0);
 330                 NV10EXATransformCoord(state.unit[1].transform,
 331                                       maskX + width, maskY + height,
 332                                       state.unit[1].width,
 333                                       state.unit[1].height, &mX1, &mY1);
 334                 NV10MVertex(pNv , dstX         ,          dstY,sX0 , sY0 , mX0 , mY0);
 335                 NV10MVertex(pNv , dstX + width ,          dstY,sX1 , sY0 , mX1 , mY0);
 336                 NV10MVertex(pNv , dstX + width , dstY + height,sX1 , sY1 , mX1 , mY1);
 337                 NV10MVertex(pNv , dstX         , dstY + height,sX0 , sY1 , mX0 , mY1);
 338         } else {
 339                 NV10Vertex(pNv , dstX         ,          dstY , sX0 , sY0);
 340                 NV10Vertex(pNv , dstX + width ,          dstY , sX1 , sY0);
 341                 NV10Vertex(pNv , dstX + width , dstY + height , sX1 , sY1);
 342                 NV10Vertex(pNv , dstX         , dstY + height , sX0 , sY1);
 343         }
 344
 345         NVDmaKickoff(pNv);
 346 }
 347
 348 static void NV10DoneComposite (PixmapPtr pDst)
 349 {
 350         ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
 351         NVPtr pNv = NVPTR(pScrn);
 352
 353         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_BEGIN_END, 1);
 354         NVDmaNext (pNv, 0); /* STOP */
 355
 356         exaMarkSync(pDst->drawable.pScreen);
 357 }
 358
 359
 360 Bool
 361 NVAccelInitNV10TCL(ScrnInfoPtr pScrn)
 362 {
 363         NVPtr pNv = NVPTR(pScrn);
 364         static int have_object = FALSE;
 365         uint32_t class = 0, chipset;
 366         int i;
 367
 368         chipset = (nvReadMC(pNv, 0) >> 20) & 0xff;
 369         if (    ((chipset & 0xf0) != NV_ARCH_10) &&
 370                 ((chipset & 0xf0) != NV_ARCH_20) )
 371                 return FALSE;
 372
 373         if (chipset>=0x20)
 374                 class = NV11_TCL_PRIMITIVE_3D;
 375         else if (chipset>=0x17)
 376                 class = NV17_TCL_PRIMITIVE_3D;
 377         else if (chipset>=0x11)
 378                 class = NV11_TCL_PRIMITIVE_3D;
 379         else
 380                 class = NV10_TCL_PRIMITIVE_3D;
 381
 382         if (!have_object) {
 383                 if (!NVDmaCreateContextObject(pNv, Nv3D, class))
 384                         return FALSE;
 385                 have_object = TRUE;
 386         }
 387
 388         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_SET_DMA_NOTIFY, 1);
 389         NVDmaNext (pNv, NvNullObject);
 390
 391         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_SET_DMA_IN_MEMORY0, 2);
 392         NVDmaNext (pNv, NvDmaFB);
 393         NVDmaNext (pNv, NvDmaTT);
 394
 395         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_SET_DMA_IN_MEMORY2, 2);
 396         NVDmaNext (pNv, NvDmaFB);
 397         NVDmaNext (pNv, NvDmaFB);
 398
 399         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_NOP, 1);
 400         NVDmaNext (pNv, 0);
 401
 402         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_HORIZ, 2);
 403         NVDmaNext (pNv, 0);
 404         NVDmaNext (pNv, 0);
 405
 406         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_CLIP_HORIZ(0), 1);
 407         NVDmaNext (pNv, (0x7ff<<16)|0x800);
 408         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_CLIP_VERT(0), 1);
 409         NVDmaNext (pNv, (0x7ff<<16)|0x800);
 410
 411         for (i=1;i<8;i++) {
 412                 NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_CLIP_HORIZ(i), 1);
 413                 NVDmaNext (pNv, 0);
 414                 NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEWPORT_CLIP_VERT(i), 1);
 415                 NVDmaNext (pNv, 0);
 416         }
 417
 418         NVDmaStart(pNv, Nv3D, 0x290, 1);
 419         NVDmaNext (pNv, (0x10<<16)|1);
 420         NVDmaStart(pNv, Nv3D, 0x3f4, 1);
 421         NVDmaNext (pNv, 0);
 422
 423 //      NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_NOTIFY, 1);
 424 //      NVDmaNext (pNv, 0);
 425         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_NOP, 1);
 426         NVDmaNext (pNv, 0);
 427
 428 #if IS_NV11
 429         NVDmaStart(pNv, Nv3D, 0x120, 3);
 430         NVDmaNext (pNv, 0);
 431         NVDmaNext (pNv, 1);
 432         NVDmaNext (pNv, 2);
 433
 434         NVDmaStart(pNv, NvImageBlit, 0x120, 3);
 435         NVDmaNext (pNv, 0);
 436         NVDmaNext (pNv, 1);
 437         NVDmaNext (pNv, 2);
 438
 439         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_NOP, 1);
 440         NVDmaNext (pNv, 0);
 441 #endif
 442
 443         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_NOP, 1);
 444         NVDmaNext (pNv, 0);
 445
 446         /* Set state */
 447         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_FOG_ENABLE, 1);
 448         NVDmaNext (pNv, 0);
 449         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_ALPHA_FUNC_ENABLE, 1);
 450         NVDmaNext (pNv, 0);
 451         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_ALPHA_FUNC_FUNC, 2);
 452         NVDmaNext (pNv, 0x207);
 453         NVDmaNext (pNv, 0);
 454         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_TX_ENABLE(0), 2);
 455         NVDmaNext (pNv, 0);
 456         NVDmaNext (pNv, 0);
 457         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_RC_IN_ALPHA(0), 12);
 458         NVDmaNext (pNv, 0x30141010);
 459         NVDmaNext (pNv, 0);
 460         NVDmaNext (pNv, 0x20040000);
 461         NVDmaNext (pNv, 0);
 462         NVDmaNext (pNv, 0);
 463         NVDmaNext (pNv, 0);
 464         NVDmaNext (pNv, 0x00000c00);
 465         NVDmaNext (pNv, 0);
 466         NVDmaNext (pNv, 0x00000c00);
 467         NVDmaNext (pNv, 0x18000000);
 468         NVDmaNext (pNv, 0x300e0300);
 469         NVDmaNext (pNv, 0x0c091c80);
 470         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_BLEND_FUNC_ENABLE, 1);
 471         NVDmaNext (pNv, 0);
 472         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_DITHER_ENABLE, 2);
 473         NVDmaNext (pNv, 1);
 474         NVDmaNext (pNv, 0);
 475         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_LINE_SMOOTH_ENABLE, 1);
 476         NVDmaNext (pNv, 0);
 477         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_WEIGHT_ENABLE, 2);
 478         NVDmaNext (pNv, 0);
 479         NVDmaNext (pNv, 0);
 480         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_BLEND_FUNC_SRC, 4);
 481         NVDmaNext (pNv, 1);
 482         NVDmaNext (pNv, 0);
 483         NVDmaNext (pNv, 0);
 484         NVDmaNext (pNv, 0x8006);
 485         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_STENCIL_MASK, 8);
 486         NVDmaNext (pNv, 0xff);
 487         NVDmaNext (pNv, 0x207);
 488         NVDmaNext (pNv, 0);
 489         NVDmaNext (pNv, 0xff);
 490         NVDmaNext (pNv, 0x1e00);
 491         NVDmaNext (pNv, 0x1e00);
 492         NVDmaNext (pNv, 0x1e00);
 493         NVDmaNext (pNv, 0x1d01);
 494         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_NORMALIZE_ENABLE, 1);
 495         NVDmaNext (pNv, 0);
 496         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_FOG_ENABLE, 2);
 497         NVDmaNext (pNv, 0);
 498         NVDmaNext (pNv, 0);
 499         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_LIGHT_MODEL, 1);
 500         NVDmaNext (pNv, 0);
 501         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_COLOR_CONTROL, 1);
 502         NVDmaNext (pNv, 0);
 503         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_ENABLED_LIGHTS, 1);
 504         NVDmaNext (pNv, 0);
 505         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_POLYGON_OFFSET_POINT_ENABLE, 3);
 506         NVDmaNext (pNv, 0);
 507         NVDmaNext (pNv, 0);
 508         NVDmaNext (pNv, 0);
 509         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_DEPTH_FUNC, 1);
 510         NVDmaNext (pNv, 0x201);
 511         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_DEPTH_WRITE_ENABLE, 1);
 512         NVDmaNext (pNv, 0);
 513         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_DEPTH_TEST_ENABLE, 1);
 514         NVDmaNext (pNv, 0);
 515         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_POLYGON_OFFSET_FACTOR, 2);
 516         NVDmaNext (pNv, 0);
 517         NVDmaNext (pNv, 0);
 518         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_POINT_SIZE, 1);
 519         NVDmaNext (pNv, 8);
 520         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_POINT_PARAMETERS_ENABLE, 2);
 521         NVDmaNext (pNv, 0);
 522         NVDmaNext (pNv, 0);
 523         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_LINE_WIDTH, 1);
 524         NVDmaNext (pNv, 8);
 525         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_LINE_SMOOTH_ENABLE, 1);
 526         NVDmaNext (pNv, 0);
 527         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_POLYGON_MODE_FRONT, 2);
 528         NVDmaNext (pNv, 0x1b02);
 529         NVDmaNext (pNv, 0x1b02);
 530         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_CULL_FACE, 2);
 531         NVDmaNext (pNv, 0x405);
 532         NVDmaNext (pNv, 0x901);
 533         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_POLYGON_SMOOTH_ENABLE, 1);
 534         NVDmaNext (pNv, 0);
 535         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_CULL_FACE_ENABLE, 1);
 536         NVDmaNext (pNv, 0);
 537         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_CLIP_PLANE_ENABLE(0), 8);
 538         for (i=0;i<8;i++) {
 539                 NVDmaNext (pNv, 0);
 540         }
 541         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_FOG_EQUATION_CONSTANT, 3);
 542         NVDmaNext (pNv, 0x3fc00000);    /* -1.50 */
 543         NVDmaNext (pNv, 0xbdb8aa0a);    /* -0.09 */
 544         NVDmaNext (pNv, 0);             /*  0.00 */
 545
 546         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_NOP, 1);
 547         NVDmaNext (pNv, 0);
 548
 549         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_FOG_MODE, 2);
 550         NVDmaNext (pNv, 0x802);
 551         NVDmaNext (pNv, 2);
 552         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VIEW_MATRIX_ENABLE, 1);
 553         NVDmaNext (pNv, 4);
 554         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_COLOR_MASK, 1);
 555         NVDmaNext (pNv, 0x01010101);
 556
 557         /* Set vertex component */
 558         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_COL_4F_R, 4);
 559         NVDmaFloat (pNv, 0.6);
 560         NVDmaFloat (pNv, 0.4);
 561         NVDmaFloat (pNv, 0.2);
 562         NVDmaFloat (pNv, 1.0);
 563         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_COL2_3F_R, 3);
 564         NVDmaNext (pNv, 0);
 565         NVDmaNext (pNv, 0);
 566         NVDmaNext (pNv, 0);
 567         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_NOR_3F_X, 3);
 568         NVDmaNext (pNv, 0);
 569         NVDmaNext (pNv, 0);
 570         NVDmaFloat (pNv, 1.0);
 571         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_TX0_4F_S, 4);
 572         NVDmaFloat (pNv, 0.0);
 573         NVDmaFloat (pNv, 0.0);
 574         NVDmaFloat (pNv, 0.0);
 575         NVDmaFloat (pNv, 1.0);
 576         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_TX1_4F_S, 4);
 577         NVDmaFloat (pNv, 0.0);
 578         NVDmaFloat (pNv, 0.0);
 579         NVDmaFloat (pNv, 0.0);
 580         NVDmaFloat (pNv, 1.0);
 581         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_VERTEX_FOG_1F, 1);
 582         NVDmaFloat (pNv, 0.0);
 583         NVDmaStart(pNv, Nv3D, NV10_TCL_PRIMITIVE_3D_EDGEFLAG_ENABLE, 1);
 584         NVDmaNext (pNv, 1);
 585
 586         return TRUE;
 587 }
 588
 589
 590
 591