src/mesa/drivers/glide/fxglidew.c

   1 /* -*- mode: C; tab-width:8; c-basic-offset:2 -*- */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.3
   6  *
   7  * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  *
  27  * Original Mesa / 3Dfx device driver (C) 1999 David Bucciarelli, by the
  28  * terms stated above.
  29  *
  30  * Thank you for your contribution, David!
  31  *
  32  * Please make note of the above copyright/license statement.  If you
  33  * contributed code or bug fixes to this code under the previous (GNU
  34  * Library) license and object to the new license, your code will be
  35  * removed at your request.  Please see the Mesa docs/COPYRIGHT file
  36  * for more information.
  37  *
  38  * Additional Mesa/3Dfx driver developers:
  39  *   Daryll Strauss <daryll@precisioninsight.com>
  40  *   Keith Whitwell <keith@precisioninsight.com>
  41  *
  42  * See fxapi.h for more revision/author details.
  43  */
  44
  45
  46 #ifdef HAVE_CONFIG_H
  47 #include "conf.h"
  48 #endif
  49
  50 #if defined(FX)
  51 #include "glide.h"
  52 #include "fxglidew.h"
  53 #include "fxdrv.h"
  54
  55 #include <stdlib.h>
  56 #include <string.h>
  57
  58 FxI32 FX_grGetInteger_NoLock(FxU32 pname)
  59 {
  60 #if !defined(FX_GLIDE3)
  61   switch (pname)
  62   {
  63     case FX_FOG_TABLE_ENTRIES:
  64        return GR_FOG_TABLE_SIZE;
  65     case FX_GLIDE_STATE_SIZE:
  66        return sizeof(GrState);
  67     case FX_LFB_PIXEL_PIPE:
  68        return FXFALSE;
  69     case FX_PENDING_BUFFERSWAPS:
  70         return grBufferNumPending();
  71     case FX_TEXTURE_ALIGN:
  72         /* This is a guess from reading the glide3 docs */
  73         return 8;
  74     default:
  75        if (MESA_VERBOSE&VERBOSE_DRIVER) {
  76           fprintf(stderr,"Wrong parameter in FX_grGetInteger!\n");
  77        }
  78        return -1;
  79   }
  80 #else
  81   FxU32 grname;
  82   FxI32 result;
  83
  84   switch (pname)
  85   {
  86      case FX_FOG_TABLE_ENTRIES:
  87      case FX_GLIDE_STATE_SIZE:
  88      case FX_LFB_PIXEL_PIPE:
  89      case FX_PENDING_BUFFERSWAPS:
  90      case FX_TEXTURE_ALIGN:
  91        grname = pname;
  92        break;
  93      default:
  94        if (MESA_VERBOSE&VERBOSE_DRIVER) {
  95           fprintf(stderr,"Wrong parameter in FX_grGetInteger!\n");
  96        }
  97        return -1;
  98   }
  99
 100   grGet(grname,4,&result);
 101   return result;
 102 #endif
 103 }
 104
 105 FxI32 FX_grGetInteger(FxU32 pname)
 106 {
 107   int result;
 108
 109   BEGIN_BOARD_LOCK();
 110   result=FX_grGetInteger_NoLock(pname);
 111   END_BOARD_LOCK();
 112   return result;
 113 }
 114
 115
 116 FxBool FX_grLfbLock(GrLock_t type, GrBuffer_t buffer,
 117                     GrLfbWriteMode_t writeMode, GrOriginLocation_t origin,
 118                     FxBool pixelPipeline, GrLfbInfo_t *info ) {
 119   FxBool result;
 120
 121   BEGIN_BOARD_LOCK();
 122   result=grLfbLock(type, buffer, writeMode, origin, pixelPipeline, info);
 123   END_BOARD_LOCK();
 124   return result;
 125 }
 126
 127 FxU32 FX_grTexTextureMemRequired(FxU32 evenOdd, GrTexInfo *info) {
 128   FxU32 result;
 129
 130   BEGIN_BOARD_LOCK();
 131   result=grTexTextureMemRequired(evenOdd, info);
 132   END_BOARD_LOCK();
 133   return result;
 134 }
 135
 136 FxU32 FX_grTexMinAddress(GrChipID_t tmu) {
 137   FxU32 result;
 138
 139   BEGIN_BOARD_LOCK();
 140   result=grTexMinAddress(tmu);
 141   END_BOARD_LOCK();
 142   return result;
 143 }
 144
 145 extern FxU32 FX_grTexMaxAddress(GrChipID_t tmu) {
 146   FxU32 result;
 147
 148   BEGIN_BOARD_LOCK();
 149   result=grTexMaxAddress(tmu);
 150   END_BOARD_LOCK();
 151   return result;
 152 }
 153
 154 FxBool FX_grSstControl(FxU32 code)
 155 {
 156 #if defined(FX_GLIDE3)
 157   (void) code;
 158   return 1;  /* OK? */
 159 #else
 160   FxU32 result;
 161   BEGIN_BOARD_LOCK();
 162   result = grSstControl(code);
 163   END_BOARD_LOCK();
 164   return result;
 165 #endif
 166 }
 167
 168
 169 #if defined(FX_GLIDE3)
 170
 171 void FX_grGammaCorrectionValue(float val)
 172 {
 173   (void)val;
 174 /* ToDo */
 175 }
 176
 177 int FX_getFogTableSize(void)
 178 {
 179    int result;
 180    BEGIN_BOARD_LOCK();
 181    grGet(GR_FOG_TABLE_ENTRIES,sizeof(int),(void*)&result);
 182    END_BOARD_LOCK();
 183    return result;
 184 }
 185
 186 int FX_getGrStateSize(void)
 187 {
 188    int result;
 189    BEGIN_BOARD_LOCK();
 190    grGet(GR_GLIDE_STATE_SIZE,sizeof(int),(void*)&result);
 191    END_BOARD_LOCK();
 192
 193    return result;
 194
 195 }
 196
 197 int FX_grSstScreenWidth()
 198 {
 199    FxI32 result[4];
 200
 201    BEGIN_BOARD_LOCK();
 202    grGet(GR_VIEWPORT,sizeof(FxI32)*4,result);
 203    END_BOARD_LOCK();
 204
 205    return result[2];
 206 }
 207
 208 int FX_grSstScreenHeight()
 209 {
 210    FxI32 result[4];
 211
 212    BEGIN_BOARD_LOCK();
 213    grGet(GR_VIEWPORT,sizeof(FxI32)*4,result);
 214    END_BOARD_LOCK();
 215
 216    return result[3];
 217 }
 218
 219 void FX_grGlideGetVersion(char *buf)
 220 {
 221   BEGIN_BOARD_LOCK();
 222   strcpy(buf,grGetString(GR_VERSION));
 223   END_BOARD_LOCK();
 224 }
 225
 226 void FX_grSstPerfStats(GrSstPerfStats_t *st)
 227 {
 228   FxI32 n;
 229   grGet(GR_STATS_PIXELS_IN, 4, &n);              st->pixelsIn = n;
 230   grGet(GR_STATS_PIXELS_CHROMA_FAIL, 4, &n);     st->chromaFail = n;
 231   grGet(GR_STATS_PIXELS_DEPTHFUNC_FAIL, 4, &n);  st->zFuncFail = n;
 232   grGet(GR_STATS_PIXELS_AFUNC_FAIL, 4, &n);      st->aFuncFail = n;
 233   grGet(GR_STATS_PIXELS_OUT, 4, &n);             st->pixelsOut = n;
 234 }
 235
 236 void FX_grAADrawLine(GrVertex *a,GrVertex *b)
 237 {
 238    /* ToDo */
 239    BEGIN_CLIP_LOOP();
 240    grDrawLine(a,b);
 241    END_CLIP_LOOP();
 242 }
 243
 244 void FX_grAADrawPoint(GrVertex *a)
 245 {
 246   BEGIN_CLIP_LOOP();
 247   grDrawPoint(a);
 248   END_CLIP_LOOP();
 249 }
 250
 251 void FX_grDrawPolygonVertexList(int n, GrVertex *verts)
 252 {
 253   BEGIN_CLIP_LOOP();
 254   grDrawVertexArrayContiguous(GR_POLYGON, n, verts, sizeof(GrVertex));
 255   END_CLIP_LOOP();
 256 }
 257
 258 #if FX_USE_PARGB
 259 void FX_setupGrVertexLayout(void)
 260 {
 261   BEGIN_BOARD_LOCK();
 262   grReset(GR_VERTEX_PARAMETER);
 263
 264   grCoordinateSpace(GR_WINDOW_COORDS);
 265   grVertexLayout(GR_PARAM_XY, GR_VERTEX_X_OFFSET << 2, GR_PARAM_ENABLE);
 266   grVertexLayout(GR_PARAM_PARGB, GR_VERTEX_PARGB_OFFSET << 2, GR_PARAM_ENABLE);
 267   grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
 268   grVertexLayout(GR_PARAM_Z, GR_VERTEX_OOZ_OFFSET << 2, GR_PARAM_ENABLE);
 269   grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
 270   grVertexLayout(GR_PARAM_Q0, GR_VERTEX_OOW_TMU0_OFFSET << 2, GR_PARAM_DISABLE);
 271   grVertexLayout(GR_PARAM_ST1, GR_VERTEX_SOW_TMU1_OFFSET << 2, GR_PARAM_DISABLE);
 272   grVertexLayout(GR_PARAM_Q1, GR_VERTEX_OOW_TMU1_OFFSET << 2, GR_PARAM_DISABLE);
 273   END_BOARD_LOCK();
 274 }
 275 #else /* FX_USE_PARGB */
 276 void FX_setupGrVertexLayout(void)
 277 {
 278   BEGIN_BOARD_LOCK();
 279   grReset(GR_VERTEX_PARAMETER);
 280
 281   grCoordinateSpace(GR_WINDOW_COORDS);
 282   grVertexLayout(GR_PARAM_XY, GR_VERTEX_X_OFFSET << 2, GR_PARAM_ENABLE);
 283   grVertexLayout(GR_PARAM_RGB, GR_VERTEX_R_OFFSET << 2, GR_PARAM_ENABLE);
 284   grVertexLayout(GR_PARAM_A, GR_VERTEX_A_OFFSET << 2, GR_PARAM_ENABLE);
 285   grVertexLayout(GR_PARAM_Q, GR_VERTEX_OOW_OFFSET << 2, GR_PARAM_ENABLE);
 286   grVertexLayout(GR_PARAM_Z, GR_VERTEX_OOZ_OFFSET << 2, GR_PARAM_ENABLE);
 287   grVertexLayout(GR_PARAM_ST0, GR_VERTEX_SOW_TMU0_OFFSET << 2, GR_PARAM_ENABLE);
 288   grVertexLayout(GR_PARAM_Q0, GR_VERTEX_OOW_TMU0_OFFSET << 2, GR_PARAM_DISABLE);
 289   grVertexLayout(GR_PARAM_ST1, GR_VERTEX_SOW_TMU1_OFFSET << 2, GR_PARAM_DISABLE);
 290   grVertexLayout(GR_PARAM_Q1, GR_VERTEX_OOW_TMU1_OFFSET << 2, GR_PARAM_DISABLE);
 291   END_BOARD_LOCK();
 292 }
 293 #endif
 294
 295 void FX_grHints_NoLock(GrHint_t hintType, FxU32 hintMask)
 296 {
 297   switch(hintType) {
 298   case GR_HINT_STWHINT:
 299     {
 300       if (hintMask & GR_STWHINT_W_DIFF_TMU0)
 301         grVertexLayout(GR_PARAM_Q0, GR_VERTEX_OOW_TMU0_OFFSET << 2,     GR_PARAM_ENABLE);
 302       else
 303         grVertexLayout(GR_PARAM_Q0,GR_VERTEX_OOW_TMU0_OFFSET << 2,      GR_PARAM_DISABLE);
 304
 305       if (hintMask & GR_STWHINT_ST_DIFF_TMU1)
 306         grVertexLayout(GR_PARAM_ST1,GR_VERTEX_SOW_TMU1_OFFSET << 2, GR_PARAM_ENABLE);
 307       else
 308         grVertexLayout(GR_PARAM_ST1,GR_VERTEX_SOW_TMU1_OFFSET << 2, GR_PARAM_DISABLE);
 309
 310       if (hintMask & GR_STWHINT_W_DIFF_TMU1)
 311         grVertexLayout(GR_PARAM_Q1,GR_VERTEX_OOW_TMU1_OFFSET << 2,      GR_PARAM_ENABLE);
 312       else
 313         grVertexLayout(GR_PARAM_Q1,GR_VERTEX_OOW_TMU1_OFFSET << 2,      GR_PARAM_DISABLE);
 314
 315     }
 316   }
 317 }
 318
 319 void FX_grHints(GrHint_t hintType, FxU32 hintMask) {
 320   BEGIN_BOARD_LOCK();
 321   FX_grHints_NoLock(hintType, hintMask);
 322   END_BOARD_LOCK();
 323 }
 324
 325 int FX_grSstQueryHardware(GrHwConfiguration *config)
 326 {
 327    int i,j;
 328    int numFB;
 329
 330    BEGIN_BOARD_LOCK();
 331    grGet(GR_NUM_BOARDS,4,(void*)&(config->num_sst));
 332    if (config->num_sst == 0)
 333         return 0;
 334    for (i = 0; i< config->num_sst; i++)
 335    {
 336       config->SSTs[i].type = GR_SSTTYPE_VOODOO;
 337       grSstSelect(i);
 338       grGet(GR_MEMORY_FB,4,(void*)&(config->SSTs[i].sstBoard.VoodooConfig.fbRam));
 339       config->SSTs[i].sstBoard.VoodooConfig.fbRam/= 1024*1024;
 340
 341       grGet(GR_NUM_TMU,4,(void*)&(config->SSTs[i].sstBoard.VoodooConfig.nTexelfx));
 342
 343
 344       grGet(GR_NUM_FB,4,(void*)&numFB);
 345       if (numFB > 1)
 346          config->SSTs[i].sstBoard.VoodooConfig.sliDetect = FXTRUE;
 347       else
 348          config->SSTs[i].sstBoard.VoodooConfig.sliDetect = FXFALSE;
 349       for (j = 0; j < config->SSTs[i].sstBoard.VoodooConfig.nTexelfx; j++)
 350       {
 351          grGet(GR_MEMORY_TMU,4,(void*)&(config->SSTs[i].sstBoard.VoodooConfig.tmuConfig[j].tmuRam));
 352          config->SSTs[i].sstBoard.VoodooConfig.tmuConfig[j].tmuRam /= 1024*1024;
 353       }
 354    }
 355    END_BOARD_LOCK();
 356    return 1;
 357 }
 358
 359 #else
 360
 361 int FX_grSstScreenWidth()
 362 {
 363    int i;
 364    BEGIN_BOARD_LOCK();
 365    i = grSstScreenWidth();
 366    END_BOARD_LOCK();
 367    return i;
 368 }
 369
 370 int FX_grSstScreenHeight()
 371 {
 372    int i;
 373    BEGIN_BOARD_LOCK();
 374    i = grSstScreenHeight();
 375    END_BOARD_LOCK();
 376    return i;
 377 }
 378
 379 int FX_grSstQueryHardware(GrHwConfiguration *c)
 380 {
 381    int i;
 382    BEGIN_BOARD_LOCK();
 383    i = grSstQueryHardware(c);
 384    END_BOARD_LOCK();
 385    return i;
 386 }
 387
 388 FX_GrContext_t FX_grSstWinOpen( FxU32                hWnd,
 389                                 GrScreenResolution_t screen_resolution,
 390                                 GrScreenRefresh_t    refresh_rate,
 391                                 GrColorFormat_t      color_format,
 392                                 GrOriginLocation_t   origin_location,
 393                                 int                  nColBuffers,
 394                                 int                  nAuxBuffers)
 395 {
 396    FX_GrContext_t i;
 397    BEGIN_BOARD_LOCK();
 398    i = grSstWinOpen( hWnd,
 399                      screen_resolution,
 400                      refresh_rate,
 401                      color_format,
 402                      origin_location,
 403                      nColBuffers,
 404                      nAuxBuffers );
 405
 406    /*
 407    fprintf(stderr,
 408            "grSstWinOpen( win %d res %d ref %d fmt %d\n"
 409            "              org %d ncol %d naux %d )\n"
 410            " ==> %d\n",
 411            hWnd,
 412            screen_resolution,
 413            refresh_rate,
 414            color_format,
 415            origin_location,
 416            nColBuffers,
 417            nAuxBuffers,
 418            i);
 419    */
 420    END_BOARD_LOCK();
 421    return i;
 422 }
 423
 424
 425
 426 #endif
 427 #else
 428
 429 /*
 430  * Need this to provide at least one external definition.
 431  */
 432
 433 int gl_fx_dummy_function_glidew(void)
 434 {
 435   return 0;
 436 }
 437
 438 #endif /* FX */