src/mesa/drivers/dri/r300/r300_state.c

   1 /*
   2 Copyright (C) The Weather Channel, Inc.  2002.
   3 Copyright (C) 2004 Nicolai Haehnle.
   4 All Rights Reserved.
   5
   6 The Weather Channel (TM) funded Tungsten Graphics to develop the
   7 initial release of the Radeon 8500 driver under the XFree86 license.
   8 This notice must be preserved.
   9
  10 Permission is hereby granted, free of charge, to any person obtaining
  11 a copy of this software and associated documentation files (the
  12 "Software"), to deal in the Software without restriction, including
  13 without limitation the rights to use, copy, modify, merge, publish,
  14 distribute, sublicense, and/or sell copies of the Software, and to
  15 permit persons to whom the Software is furnished to do so, subject to
  16 the following conditions:
  17
  18 The above copyright notice and this permission notice (including the
  19 next paragraph) shall be included in all copies or substantial
  20 portions of the Software.
  21
  22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  26 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29
  30 **************************************************************************/
  31
  32 /*
  33  * Authors:
  34  *   Nicolai Haehnle <prefect_@gmx.net>
  35  */
  36
  37 #include "glheader.h"
  38 #include "state.h"
  39 #include "imports.h"
  40 #include "enums.h"
  41 #include "macros.h"
  42 #include "context.h"
  43 #include "dd.h"
  44 #include "simple_list.h"
  45
  46 #include "api_arrayelt.h"
  47 #include "swrast/swrast.h"
  48 #include "swrast_setup/swrast_setup.h"
  49 #include "array_cache/acache.h"
  50 #include "tnl/tnl.h"
  51
  52 #include "radeon_ioctl.h"
  53 #include "radeon_state.h"
  54 #include "r300_context.h"
  55 #include "r300_ioctl.h"
  56 #include "r300_state.h"
  57 #include "r300_reg.h"
  58 #include "r300_program.h"
  59 #include "r300_emit.h"
  60 #include "r300_fixed_pipelines.h"
  61
  62 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
  63 {
  64         r300ContextPtr rmesa = R300_CONTEXT(ctx);
  65         int pp_misc = rmesa->hw.at.cmd[R300_AT_ALPHA_TEST];
  66         GLubyte refByte;
  67
  68         CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
  69
  70         R300_STATECHANGE(rmesa, at);
  71
  72         pp_misc &= ~(R300_ALPHA_TEST_OP_MASK | R300_REF_ALPHA_MASK);
  73         pp_misc |= (refByte & R300_REF_ALPHA_MASK);
  74
  75         switch (func) {
  76         case GL_NEVER:
  77                 pp_misc |= R300_ALPHA_TEST_FAIL;
  78                 break;
  79         case GL_LESS:
  80                 pp_misc |= R300_ALPHA_TEST_LESS;
  81                 break;
  82         case GL_EQUAL:
  83                 pp_misc |= R300_ALPHA_TEST_EQUAL;
  84                 break;
  85         case GL_LEQUAL:
  86                 pp_misc |= R300_ALPHA_TEST_LEQUAL;
  87                 break;
  88         case GL_GREATER:
  89                 pp_misc |= R300_ALPHA_TEST_GREATER;
  90                 break;
  91         case GL_NOTEQUAL:
  92                 pp_misc |= R300_ALPHA_TEST_NEQUAL;
  93                 break;
  94         case GL_GEQUAL:
  95                 pp_misc |= R300_ALPHA_TEST_GEQUAL;
  96                 break;
  97         case GL_ALWAYS:
  98                 pp_misc |= R300_ALPHA_TEST_PASS;
  99                 break;
 100         }
 101
 102         rmesa->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
 103 }
 104
 105 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
 106 {
 107         GLubyte color[4];
 108         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 109         fprintf(stderr, "%s:%s is not implemented yet. Fixme !\n", __FILE__, __FUNCTION__);
 110         #if 0
 111         R200_STATECHANGE(rmesa, ctx);
 112         CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
 113         CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
 114         CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
 115         CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
 116         if (rmesa->radeon.radeonScreen->drmSupportsBlendColor)
 117                 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCOLOR] =
 118                     radeonPackColor(4, color[0], color[1], color[2], color[3]);
 119         #endif
 120 }
 121
 122 /**
 123  * Calculate the hardware blend factor setting.  This same function is used
 124  * for source and destination of both alpha and RGB.
 125  *
 126  * \returns
 127  * The hardware register value for the specified blend factor.  This value
 128  * will need to be shifted into the correct position for either source or
 129  * destination factor.
 130  *
 131  * \todo
 132  * Since the two cases where source and destination are handled differently
 133  * are essentially error cases, they should never happen.  Determine if these
 134  * cases can be removed.
 135  */
 136 static int blend_factor(GLenum factor, GLboolean is_src)
 137 {
 138         int func;
 139
 140         switch (factor) {
 141         case GL_ZERO:
 142                 func = R200_BLEND_GL_ZERO;
 143                 break;
 144         case GL_ONE:
 145                 func = R200_BLEND_GL_ONE;
 146                 break;
 147         case GL_DST_COLOR:
 148                 func = R200_BLEND_GL_DST_COLOR;
 149                 break;
 150         case GL_ONE_MINUS_DST_COLOR:
 151                 func = R200_BLEND_GL_ONE_MINUS_DST_COLOR;
 152                 break;
 153         case GL_SRC_COLOR:
 154                 func = R200_BLEND_GL_SRC_COLOR;
 155                 break;
 156         case GL_ONE_MINUS_SRC_COLOR:
 157                 func = R200_BLEND_GL_ONE_MINUS_SRC_COLOR;
 158                 break;
 159         case GL_SRC_ALPHA:
 160                 func = R200_BLEND_GL_SRC_ALPHA;
 161                 break;
 162         case GL_ONE_MINUS_SRC_ALPHA:
 163                 func = R200_BLEND_GL_ONE_MINUS_SRC_ALPHA;
 164                 break;
 165         case GL_DST_ALPHA:
 166                 func = R200_BLEND_GL_DST_ALPHA;
 167                 break;
 168         case GL_ONE_MINUS_DST_ALPHA:
 169                 func = R200_BLEND_GL_ONE_MINUS_DST_ALPHA;
 170                 break;
 171         case GL_SRC_ALPHA_SATURATE:
 172                 func =
 173                     (is_src) ? R200_BLEND_GL_SRC_ALPHA_SATURATE :
 174                     R200_BLEND_GL_ZERO;
 175                 break;
 176         case GL_CONSTANT_COLOR:
 177                 func = R200_BLEND_GL_CONST_COLOR;
 178                 break;
 179         case GL_ONE_MINUS_CONSTANT_COLOR:
 180                 func = R200_BLEND_GL_ONE_MINUS_CONST_COLOR;
 181                 break;
 182         case GL_CONSTANT_ALPHA:
 183                 func = R200_BLEND_GL_CONST_ALPHA;
 184                 break;
 185         case GL_ONE_MINUS_CONSTANT_ALPHA:
 186                 func = R200_BLEND_GL_ONE_MINUS_CONST_ALPHA;
 187                 break;
 188         default:
 189                 func = (is_src) ? R200_BLEND_GL_ONE : R200_BLEND_GL_ZERO;
 190         }
 191         return func;
 192 }
 193
 194 /**
 195  * Sets both the blend equation and the blend function.
 196  * This is done in a single
 197  * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
 198  * change the interpretation of the blend function.
 199  * Also, make sure that blend function and blend equation are set to their default
 200  * value if color blending is not enabled, since at least blend equations GL_MIN
 201  * and GL_FUNC_REVERSE_SUBTRACT will cause wrong results otherwise for
 202  * unknown reasons.
 203  */
 204 static void r300_set_blend_state(GLcontext * ctx)
 205 {
 206         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 207         #if 0
 208         GLuint cntl = rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &
 209             ~(R300_ROP_ENABLE | R300_ALPHA_BLEND_ENABLE |
 210               R300_SEPARATE_ALPHA_ENABLE);
 211         #endif
 212
 213         int func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 214             (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
 215         int eqn = R200_COMB_FCN_ADD_CLAMP;
 216         int funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 217             (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
 218         int eqnA = R200_COMB_FCN_ADD_CLAMP;
 219
 220         R300_STATECHANGE(rmesa, bld);
 221
 222         if (rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
 223                 if (ctx->Color._LogicOpEnabled) {
 224                         #if 0
 225                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
 226                             cntl | R300_ROP_ENABLE;
 227                         #endif
 228                         rmesa->hw.bld.cmd[R300_BLD_ABLEND] = eqn | func;
 229                         rmesa->hw.bld.cmd[R300_BLD_CBLEND] = eqn | func;
 230                         return;
 231                 } else if (ctx->Color.BlendEnabled) {
 232                         #if 0
 233                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
 234                             cntl | R300_ALPHA_BLEND_ENABLE |
 235                             R300_SEPARATE_ALPHA_ENABLE;
 236                         #endif
 237                 } else {
 238                         #if 0
 239                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
 240                         #endif
 241                         rmesa->hw.bld.cmd[R300_BLD_ABLEND] = eqn | func;
 242                         rmesa->hw.bld.cmd[R300_BLD_CBLEND] = eqn | func;
 243                         return;
 244                 }
 245         } else {
 246                 if (ctx->Color._LogicOpEnabled) {
 247                         #if 0
 248                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
 249                             cntl | R300_ROP_ENABLE;
 250                         rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
 251                         #endif
 252                         return;
 253                 } else if (ctx->Color.BlendEnabled) {
 254                         #if 0
 255                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
 256                             cntl | R300_ALPHA_BLEND_ENABLE;
 257                         #endif
 258                 } else {
 259                         #if 0
 260                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
 261                         rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
 262                         #endif
 263                         return;
 264                 }
 265         }
 266
 267         func =
 268             (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
 269              R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
 270                                                    GL_FALSE) <<
 271                                       R200_DST_BLEND_SHIFT);
 272
 273         switch (ctx->Color.BlendEquationRGB) {
 274         case GL_FUNC_ADD:
 275                 eqn = R300_COMB_FCN_ADD_CLAMP;
 276                 break;
 277
 278         case GL_FUNC_SUBTRACT:
 279                 eqn = R300_COMB_FCN_SUB_CLAMP;
 280                 break;
 281
 282         case GL_FUNC_REVERSE_SUBTRACT:
 283                 eqn = R200_COMB_FCN_RSUB_CLAMP;
 284                 break;
 285
 286         case GL_MIN:
 287                 eqn = R200_COMB_FCN_MIN;
 288                 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 289                     (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
 290                 break;
 291
 292         case GL_MAX:
 293                 eqn = R200_COMB_FCN_MAX;
 294                 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 295                     (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
 296                 break;
 297
 298         default:
 299                 fprintf(stderr,
 300                         "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
 301                         __func__, __LINE__, ctx->Color.BlendEquationRGB);
 302                 return;
 303         }
 304
 305         if (!rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
 306                 #if 0
 307                 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
 308                 #endif
 309                 return;
 310         }
 311
 312         funcA =
 313             (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
 314              R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
 315                                                    GL_FALSE) <<
 316                                       R200_DST_BLEND_SHIFT);
 317
 318         switch (ctx->Color.BlendEquationA) {
 319         case GL_FUNC_ADD:
 320                 eqnA = R300_COMB_FCN_ADD_CLAMP;
 321                 break;
 322
 323         case GL_FUNC_SUBTRACT:
 324                 eqnA = R300_COMB_FCN_SUB_CLAMP;
 325                 break;
 326
 327         case GL_FUNC_REVERSE_SUBTRACT:
 328                 eqnA = R200_COMB_FCN_RSUB_CLAMP;
 329                 break;
 330
 331         case GL_MIN:
 332                 eqnA = R200_COMB_FCN_MIN;
 333                 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 334                     (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
 335                 break;
 336
 337         case GL_MAX:
 338                 eqnA = R200_COMB_FCN_MAX;
 339                 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 340                     (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
 341                 break;
 342
 343         default:
 344                 fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n",
 345                         __func__, __LINE__, ctx->Color.BlendEquationA);
 346                 return;
 347         }
 348
 349         rmesa->hw.bld.cmd[R300_BLD_ABLEND] = eqnA | funcA;
 350         rmesa->hw.bld.cmd[R300_BLD_CBLEND] = eqn | func ;
 351         if(rmesa->hw.bld.cmd[R300_BLD_ABLEND] == rmesa->hw.bld.cmd[R300_BLD_CBLEND]){
 352                 rmesa->hw.bld.cmd[R300_BLD_CBLEND] |= R300_BLEND_UNKNOWN | R300_BLEND_ENABLE | R300_BLEND_NO_SEPARATE;
 353                 } else {
 354                 rmesa->hw.bld.cmd[R300_BLD_CBLEND] |= R300_BLEND_UNKNOWN | R300_BLEND_ENABLE;
 355                 }
 356
 357 }
 358
 359 static void r300BlendEquationSeparate(GLcontext * ctx,
 360                                       GLenum modeRGB, GLenum modeA)
 361 {
 362         r300_set_blend_state(ctx);
 363 }
 364
 365 static void r300BlendFuncSeparate(GLcontext * ctx,
 366                                   GLenum sfactorRGB, GLenum dfactorRGB,
 367                                   GLenum sfactorA, GLenum dfactorA)
 368 {
 369         r300_set_blend_state(ctx);
 370 }
 371
 372 /**
 373  * Update our tracked culling state based on Mesa's state.
 374  */
 375 static void r300UpdateCulling(GLcontext* ctx)
 376 {
 377         r300ContextPtr r300 = R300_CONTEXT(ctx);
 378         uint32_t val = 0;
 379
 380         R300_STATECHANGE(r300, cul);
 381         if (ctx->Polygon.CullFlag) {
 382                 if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
 383                         val = R300_CULL_FRONT|R300_CULL_BACK;
 384                 else if (ctx->Polygon.CullFaceMode == GL_FRONT)
 385                         val = R300_CULL_FRONT;
 386                 else
 387                         val = R300_CULL_BACK;
 388
 389                 if (ctx->Polygon.FrontFace == GL_CW)
 390                         val |= R300_FRONT_FACE_CW;
 391                 else
 392                         val |= R300_FRONT_FACE_CCW;
 393         }
 394
 395         r300->hw.cul.cmd[R300_CUL_CULL] = val;
 396 }
 397
 398
 399 /**
 400  * Handle glEnable()/glDisable().
 401  *
 402  * \note Mesa already filters redundant calls to glEnable/glDisable.
 403  */
 404 static void r300Enable(GLcontext* ctx, GLenum cap, GLboolean state)
 405 {
 406         r300ContextPtr r300 = R300_CONTEXT(ctx);
 407         uint32_t newval;
 408
 409         if (RADEON_DEBUG & DEBUG_STATE)
 410                 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
 411                         _mesa_lookup_enum_by_nr(cap),
 412                         state ? "GL_TRUE" : "GL_FALSE");
 413
 414         switch (cap) {
 415         case GL_DEPTH_TEST:
 416                 R300_STATECHANGE(r300, zc);
 417
 418                 if (state) {
 419                         if (ctx->Depth.Mask)
 420                                 newval = R300_RB3D_Z_TEST_AND_WRITE;
 421                         else
 422                                 newval = R300_RB3D_Z_TEST;
 423                 } else
 424                         newval = 0;
 425
 426                 r300->hw.zc.cmd[R300_ZC_CNTL_0] = newval;
 427                 break;
 428
 429         case GL_CULL_FACE:
 430                 r300UpdateCulling(ctx);
 431                 break;
 432
 433         default:
 434                 radeonEnable(ctx, cap, state);
 435                 return;
 436         }
 437 }
 438
 439
 440 /**
 441  * Change the culling mode.
 442  *
 443  * \note Mesa already filters redundant calls to this function.
 444  */
 445 static void r300CullFace(GLcontext* ctx, GLenum mode)
 446 {
 447         (void)mode;
 448
 449         r300UpdateCulling(ctx);
 450 }
 451
 452
 453 /**
 454  * Change the polygon orientation.
 455  *
 456  * \note Mesa already filters redundant calls to this function.
 457  */
 458 static void r300FrontFace(GLcontext* ctx, GLenum mode)
 459 {
 460         (void)mode;
 461
 462         r300UpdateCulling(ctx);
 463 }
 464
 465
 466 /**
 467  * Change the depth testing function.
 468  *
 469  * \note Mesa already filters redundant calls to this function.
 470  */
 471 static void r300DepthFunc(GLcontext* ctx, GLenum func)
 472 {
 473         r300ContextPtr r300 = R300_CONTEXT(ctx);
 474
 475         R300_STATECHANGE(r300, zc);
 476
 477         switch(func) {
 478         case GL_NEVER:
 479                 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_NEVER;
 480                 break;
 481         case GL_LESS:
 482                 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_LESS;
 483                 break;
 484         case GL_EQUAL:
 485                 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_EQUAL;
 486                 break;
 487         case GL_LEQUAL:
 488                 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_LEQUAL;
 489                 break;
 490         case GL_GREATER:
 491                 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_GREATER;
 492                 break;
 493         case GL_NOTEQUAL:
 494                 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_NEQUAL;
 495                 break;
 496         case GL_GEQUAL:
 497                 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_GEQUAL;
 498                 break;
 499         case GL_ALWAYS:
 500                 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_ALWAYS;
 501                 break;
 502         }
 503 }
 504
 505
 506 /**
 507  * Enable/Disable depth writing.
 508  *
 509  * \note Mesa already filters redundant calls to this function.
 510  */
 511 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
 512 {
 513         r300ContextPtr r300 = R300_CONTEXT(ctx);
 514
 515         if (!ctx->Depth.Test)
 516                 return;
 517
 518         R300_STATECHANGE(r300, zc);
 519         r300->hw.zc.cmd[R300_ZC_CNTL_0] = mask
 520                 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
 521 }
 522
 523
 524 /**
 525  * Handle glColorMask()
 526  */
 527 static void r300ColorMask(GLcontext* ctx,
 528                           GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 529 {
 530         r300ContextPtr r300 = R300_CONTEXT(ctx);
 531         int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
 532
 533         if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
 534                 R300_STATECHANGE(r300, cmk);
 535                 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
 536         }
 537 }
 538
 539 /* =============================================================
 540  * Point state
 541  */
 542 static void r300PointSize(GLcontext * ctx, GLfloat size)
 543 {
 544         r300ContextPtr r300 = R300_CONTEXT(ctx);
 545
 546         /* This might need fixing later */
 547         R300_STATECHANGE(r300, vps);
 548         r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
 549 }
 550
 551 /* =============================================================
 552  * Window position and viewport transformation
 553  */
 554
 555 /*
 556  * To correctly position primitives:
 557  */
 558 #define SUBPIXEL_X 0.125
 559 #define SUBPIXEL_Y 0.125
 560
 561 void r300UpdateWindow(GLcontext * ctx)
 562 {
 563         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 564         __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
 565         GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
 566         GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
 567         const GLfloat *v = ctx->Viewport._WindowMap.m;
 568
 569         GLfloat sx = v[MAT_SX];
 570         GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
 571         GLfloat sy = -v[MAT_SY];
 572         GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
 573         GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
 574         GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
 575
 576         R300_FIREVERTICES(rmesa);
 577         R300_STATECHANGE(rmesa, vpt);
 578
 579         rmesa->hw.vpt.cmd[R300_VPT_XSCALE]  = r300PackFloat32(sx);
 580         rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
 581         rmesa->hw.vpt.cmd[R300_VPT_YSCALE]  = r300PackFloat32(sy);
 582         rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
 583         rmesa->hw.vpt.cmd[R300_VPT_ZSCALE]  = r300PackFloat32(sz);
 584         rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
 585 }
 586
 587 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
 588                          GLsizei width, GLsizei height)
 589 {
 590         /* Don't pipeline viewport changes, conflict with window offset
 591          * setting below.  Could apply deltas to rescue pipelined viewport
 592          * values, or keep the originals hanging around.
 593          */
 594         R200_FIREVERTICES(R200_CONTEXT(ctx));
 595         r300UpdateWindow(ctx);
 596 }
 597
 598 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
 599 {
 600         r300UpdateWindow(ctx);
 601 }
 602
 603 /* Routing and texture-related */
 604
 605 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
 606 {
 607         int i, count=0,reg=0;
 608         GLuint dw, mask;
 609         TNLcontext *tnl = TNL_CONTEXT(ctx);
 610         struct vertex_buffer *VB = &tnl->vb;
 611         r300ContextPtr r300 = R300_CONTEXT(ctx);
 612
 613
 614         /* Stage 1 - input to VAP */
 615
 616         /* Assign register number automatically, retaining it in rmesa->state.reg */
 617
 618         /* Note: immediate vertex data includes all coordinates.
 619         To save bandwidth use either VBUF or state-based vertex generation */
 620
 621         #define CONFIGURE_AOS(v, o, r, f) \
 622                 {\
 623                 if(immediate){ \
 624                         r300->state.aos[count].element_size=4; \
 625                         r300->state.aos[count].stride=4; \
 626                         r300->state.aos[count].ncomponents=4; \
 627                         } else { \
 628                         r300->state.aos[count].element_size=v->size; \
 629                         r300->state.aos[count].stride=v->size; \
 630                         r300->state.aos[count].ncomponents=v->size; \
 631                         } \
 632                 r300->state.aos[count].offset=o; \
 633                 r300->state.aos[count].reg=reg; \
 634                 r300->state.aos[count].format=(f); \
 635                 r300->state.vap_reg.r=reg; \
 636                 count++; \
 637                 reg++; \
 638                 }
 639
 640                 /* All offsets are 0 - for use by immediate mode.
 641                 Should change later to handle vertex buffers */
 642         CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
 643         CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
 644         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 645                 if(ctx->Texture.Unit[i].Enabled)
 646                         CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
 647
 648         r300->state.aos_count=count;
 649
 650         if (RADEON_DEBUG & DEBUG_STATE)
 651                 fprintf(stderr, "aos_count=%d\n", count);
 652
 653         if(count>R300_MAX_AOS_ARRAYS){
 654                 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
 655                 exit(-1);
 656                 }
 657
 658         /* Implement AOS */
 659
 660         /* setup INPUT_ROUTE */
 661         R300_STATECHANGE(r300, vir[0]);
 662         for(i=0;i+1<count;i+=2){
 663                 dw=(r300->state.aos[i].ncomponents-1)
 664                 | ((r300->state.aos[i].reg)<<8)
 665                 | (r300->state.aos[i].format<<14)
 666                 | (((r300->state.aos[i+1].ncomponents-1)
 667                 | ((r300->state.aos[i+1].reg)<<8)
 668                 | (r300->state.aos[i+1].format<<14))<<16);
 669
 670                 if(i+2==count){
 671                         dw|=(1<<(13+16));
 672                         }
 673                 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
 674                 }
 675         if(count & 1){
 676                 dw=(r300->state.aos[count-1].ncomponents-1)
 677                 | (r300->state.aos[count-1].format<<14)
 678                 | ((r300->state.aos[count-1].reg)<<8)
 679                 | (1<<13);
 680                 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
 681                 //fprintf(stderr, "vir0 dw=%08x\n", dw);
 682                 }
 683         /* Set the rest of INPUT_ROUTE_0 to 0 */
 684         //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
 685         ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
 686
 687
 688         /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
 689         #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
 690                 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
 691                 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
 692                 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
 693
 694         #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
 695                 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
 696                 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
 697                 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
 698
 699         R300_STATECHANGE(r300, vir[1]);
 700
 701         for(i=0;i+1<count;i+=2){
 702                 /* do i first.. */
 703                 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
 704                 dw=(ALL_COMPONENTS & mask)
 705                 | (ALL_DEFAULT & ~mask)
 706                 | R300_INPUT_ROUTE_ENABLE;
 707
 708                 /* i+1 */
 709                 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
 710                 dw|=(
 711                 (ALL_COMPONENTS & mask)
 712                 | (ALL_DEFAULT & ~mask)
 713                 | R300_INPUT_ROUTE_ENABLE
 714                 )<<16;
 715
 716                 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
 717                 }
 718         if(count & 1){
 719                 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
 720                 dw=(ALL_COMPONENTS & mask)
 721                 | (ALL_DEFAULT & ~mask)
 722                 | R300_INPUT_ROUTE_ENABLE;
 723                 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
 724                 //fprintf(stderr, "vir1 dw=%08x\n", dw);
 725                 }
 726         /* Set the rest of INPUT_ROUTE_1 to 0 */
 727         //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
 728         ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
 729
 730         /* Set up input_cntl */
 731
 732         R300_STATECHANGE(r300, vic);
 733         r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555;  /* Hard coded value, no idea what it means */
 734
 735         r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
 736                                         | R300_INPUT_CNTL_COLOR;
 737
 738         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 739                 if(ctx->Texture.Unit[i].Enabled)
 740                         r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
 741
 742         /* Stage 3: VAP output */
 743         R300_STATECHANGE(r300, vof);
 744         r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
 745                                         | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
 746
 747         r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
 748         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 749                 if(ctx->Texture.Unit[i].Enabled)
 750                         r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
 751
 752 }
 753
 754 static r300TexObj default_tex_obj={
 755         filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
 756         pitch: 0x8000,
 757         size: (0xff << R300_TX_WIDTHMASK_SHIFT)
 758               | (0xff << R300_TX_HEIGHTMASK_SHIFT)
 759               | (0x8 << R300_TX_SIZE_SHIFT),
 760         format: 0x88a0c,
 761         offset: 0x0,
 762         unknown4: 0x0,
 763         unknown5: 0x0
 764         };
 765
 766         /* there is probably a system to these value, but, for now,
 767            we just try by hand */
 768
 769 static int inline translate_src(int src)
 770 {
 771         switch (src) {
 772         case GL_TEXTURE:
 773                 return 1;
 774                 break;
 775         case GL_CONSTANT:
 776                 return 2;
 777                 break;
 778         case GL_PRIMARY_COLOR:
 779                 return 3;
 780                 break;
 781         case GL_PREVIOUS:
 782                 return 4;
 783                 break;
 784         case GL_ZERO:
 785                 return 5;
 786                 break;
 787         case GL_ONE:
 788                 return 6;
 789                 break;
 790         default:
 791                 return 0;
 792         }
 793 }
 794
 795 /* I think 357 and 457 are prime numbers.. wiggle them if you get coincidences */
 796 #define FORMAT_HASH(opRGB, srcRGB, modeRGB, opA, srcA, modeA, format, intFormat)        ( \
 797         (\
 798         ((opRGB)<<30) | ((opA)<<28) | \
 799         ((srcRGB)<< 25) | ((srcA)<<22) | \
 800         ((modeRGB)) \
 801         ) \
 802         ^ ((modeA)*357) \
 803         ^ (((format)) *457) \
 804         ^ ((intFormat) * 7) \
 805         )
 806
 807
 808 static GLuint translate_texture_format(GLcontext *ctx, GLint tex_unit, GLuint format, GLint IntFormat)
 809 {
 810         const struct gl_texture_unit *texUnit= &ctx->Texture.Unit[tex_unit];
 811         int i=0; /* number of alpha args .. */
 812         GLuint fmt;
 813
 814         #if 0
 815         fprintf(stderr, "_ReallyEnabled=%d EnvMode=%s\n",
 816                 texUnit->_ReallyEnabled,
 817                 _mesa_lookup_enum_by_nr(texUnit->EnvMode));
 818         #endif
 819
 820         switch(IntFormat){
 821                 case 4:
 822                 case GL_RGBA:
 823                 case GL_RGBA8:
 824                         fmt=R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8);
 825                         break;
 826                 case 3:
 827                 case GL_RGB8:
 828                         fmt=R300_EASY_TX_FORMAT(Z, Y, X, ONE, W8Z8Y8X8);
 829                         break;
 830                 default:
 831                         return 0;
 832                 }
 833         #if 0
 834         //fmt &= 0x00fff;
 835         //fmt |= ((format) & 0xff00)<<4;
 836         fprintf(stderr, "NumArgsRGB=%d NumArgsA=%d\n",
 837                 texUnit->_CurrentCombine->_NumArgsRGB,
 838                 texUnit->_CurrentCombine->_NumArgsA);
 839
 840         fprintf(stderr, "fmt=%08x\n", fmt);
 841         #endif
 842         //return fmt;
 843         /* Size field in format specific first */
 844         switch(FORMAT_HASH(
 845                 texUnit->_CurrentCombine->OperandRGB[i] -GL_SRC_COLOR,
 846                 translate_src(texUnit->_CurrentCombine->SourceRGB[i]),
 847                 texUnit->_CurrentCombine->ModeRGB,
 848                 texUnit->_CurrentCombine->OperandA[i] -GL_SRC_ALPHA,
 849                 translate_src(texUnit->_CurrentCombine->SourceA[i]),
 850                 texUnit->_CurrentCombine->ModeA,
 851                 format,
 852                 IntFormat
 853                 )){
 854         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA):
 855                 /* tested with:
 856                         kfiresaver.kss
 857                         */
 858                 return R300_EASY_TX_FORMAT(X, X, CUT_W, W, W8Z8Y8X8);
 859         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA8):
 860                 /* tested with:
 861                         Quake3demo
 862                         */
 863                 /* Quake3demo -small font on the bottom */
 864                 return fmt;
 865         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, GL_RGBA8):
 866                 /* Quake3demo - mouse cursor*/
 867                 return fmt;
 868         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, 4):
 869                 /* tested with:
 870                         kfiresaver.kss
 871                         */
 872                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
 873         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, 4):
 874                 /* tested with:
 875                         kfiresaver.kss
 876                         kfountain.kss
 877                         */
 878                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
 879         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008847, 3):
 880                 /* tested with
 881                         lesson 06
 882                         lesson 07
 883                         */
 884         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, 0x00000003):
 885                 /* Tested with NeHe lesson 08 */
 886         //case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x0005547, 0):
 887                 /* Can't remember what I tested this with..
 888                    try putting return 0 of you see broken textures which
 889                    are not being complained about */
 890         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00009947, GL_RGB8):
 891         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, GL_RGB8):
 892         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00003347, GL_RGB8):
 893         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, 3):
 894                 /* Tested with:
 895                         Quake3demo
 896                         */
 897                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
 898         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007847, GL_RGBA8):
 899         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006747, GL_RGBA8):
 900         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006647, GL_RGBA8):
 901         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, GL_RGBA8):
 902                 /* Tested with:
 903                         Quake3demo
 904                         */
 905                 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
 906         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, GL_RGBA8):
 907                 return R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) ;
 908         case  FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008845, 0x00008056):
 909                 //return 0;
 910                 fprintf(stderr, "***\n");
 911                 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
 912         }
 913
 914
 915         {
 916                 static int warn_once=1;
 917                 if(warn_once){
 918                         fprintf(stderr, "%s:%s Do not know how to translate texture format - help me !\n",
 919                                 __FILE__, __FUNCTION__);
 920                         warn_once=0;
 921                         }
 922         }
 923                 return 0;
 924 }
 925
 926 void r300_setup_textures(GLcontext *ctx)
 927 {
 928         int i, mtu;
 929         struct r300_tex_obj *t;
 930         r300ContextPtr r300 = R300_CONTEXT(ctx);
 931         int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
 932         struct gl_texture_unit *texUnit;
 933
 934         R300_STATECHANGE(r300, txe);
 935         R300_STATECHANGE(r300, tex.filter);
 936         R300_STATECHANGE(r300, tex.unknown1);
 937         R300_STATECHANGE(r300, tex.size);
 938         R300_STATECHANGE(r300, tex.format);
 939         R300_STATECHANGE(r300, tex.offset);
 940         R300_STATECHANGE(r300, tex.unknown4);
 941         R300_STATECHANGE(r300, tex.unknown5);
 942
 943         r300->state.texture.tc_count=0;
 944
 945         r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
 946
 947         mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
 948         if (RADEON_DEBUG & DEBUG_STATE)
 949                 fprintf(stderr, "mtu=%d\n", mtu);
 950
 951         if(mtu>R300_MAX_TEXTURE_UNITS){
 952                 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
 953                         mtu, R300_MAX_TEXTURE_UNITS);
 954                 exit(-1);
 955                 }
 956         for(i=0;i<mtu;i++){
 957                 if(ctx->Texture.Unit[i].Enabled){
 958                         t=r300->state.texture.unit[i].texobj;
 959                         r300->state.texture.tc_count++;
 960                         if(t==NULL){
 961                                 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
 962                                 //exit(-1);
 963                                 t=&default_tex_obj;
 964                                 }
 965                         if (RADEON_DEBUG & DEBUG_STATE)
 966                                 fprintf(stderr, "Activating texture unit %d\n", i);
 967                         max_texture_unit=i;
 968                         r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
 969
 970                         r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=t->filter;
 971
 972                         /* Turn off rest of the bits that are wrong */
 973                         t->filter &= R300_TX_MIN_FILTER_MASK | R300_TX_MAG_FILTER_MASK;
 974
 975                         /* No idea why linear filtered textures shake when puting random data */
 976                         /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
 977                         r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
 978                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
 979                         r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
 980                         r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
 981                         r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
 982
 983                         /* We don't know how to set this yet */
 984                         //value from r300_lib.c for RGB24
 985                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x88a0c;
 986                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=translate_texture_format(ctx, i, t->format,
 987                                 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->IntFormat:3);
 988
 989
 990                         #if 0
 991                         fprintf(stderr, "Format=%s IntFormat=%08x MesaFormat=%08x BaseFormat=%s IsCompressed=%d Target=%s\n",
 992                                 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->Format),
 993                                 t->base.tObj->Image[0][0]->IntFormat,
 994                                 t->base.tObj->Image[0][0]->TexFormat->MesaFormat,
 995                                 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->TexFormat->BaseFormat),
 996                                 t->base.tObj->Image[0][0]->IsCompressed,
 997                                 _mesa_lookup_enum_by_nr(t->base.tObj->Target));
 998
 999                         fprintf(stderr, "pitch=%08x filter=%08x format=%08x\n", t->pitch, t->filter, r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]);
1000                         fprintf(stderr, "unknown1=%08x size=%08x\n", r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i],
1001                                 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]);
1002                         #endif
1003                         /* Use the code below to quickly find matching texture
1004                            formats. Requires an app that displays the same texture
1005                            repeatedly  */
1006                               #if 1
1007                                 if(r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]==0){
1008                                         static int fmt=0x0;
1009                                         static int k=0;
1010                                         k++;
1011                                         if(k>20){
1012                                                 k=0;
1013                                                 fmt++;
1014                                                 texUnit = &ctx->Texture.Unit[i];
1015                                                 fprintf(stderr, "Want to set FORMAT_HASH(%d, %d, 0x%04x, %d, %d, 0x%04x, 0x%08x, %s(%08x))\n",
1016                                                         texUnit->_CurrentCombine->OperandRGB[0] -GL_SRC_COLOR,
1017                                                         translate_src(texUnit->_CurrentCombine->SourceRGB[0]),
1018                                                         texUnit->_CurrentCombine->ModeRGB,
1019                                                         texUnit->_CurrentCombine->OperandA[0] -GL_SRC_ALPHA,
1020                                                         translate_src(texUnit->_CurrentCombine->SourceA[0]),
1021                                                         texUnit->_CurrentCombine->ModeA,
1022                                                         t->format,
1023                                                         _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->IntFormat),
1024                                                         t->base.tObj->Image[0][0]->IntFormat
1025                                                         );
1026                                                 fprintf(stderr, "Also known: format_x=%08x border_color=%08x cubic_faces=%08x\n", t->format_x, t->pp_border_color, t->pp_cubic_faces);
1027                                                 fprintf(stderr, "\t_ReallyEnabled=%08x EnvMode=%08x IntFormat=%08x\n", texUnit->_ReallyEnabled, texUnit->EnvMode,  t->base.tObj->Image[0][0]->IntFormat);
1028                                                 if(fmt>0xfff){
1029                                                         fmt=0;
1030                                                         }
1031                                                 //sleep(1);
1032                                                 fprintf(stderr, "Now trying format %08x\n",
1033                                                         fmt);
1034                                                 fprintf(stderr, "size=%08x\n", t->size);
1035                                                 }
1036                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=known_formats[fmt];
1037                                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=
1038                                                 R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)  | (fmt<<24);
1039                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x08a0c | (fmt<<16);
1040                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x58a00 | (fmt);
1041                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x53a0c | (fmt<<24);
1042                                         }
1043                               #endif
1044
1045                         }
1046
1047                 }
1048         ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1049         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1050         ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1051         ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1052         ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1053         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1054         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1055
1056         if (RADEON_DEBUG & DEBUG_STATE)
1057                 fprintf(stderr, "TX_ENABLE: %08x  max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1058 }
1059
1060 void r300_setup_rs_unit(GLcontext *ctx)
1061 {
1062         r300ContextPtr r300 = R300_CONTEXT(ctx);
1063         int i;
1064
1065         /* This needs to be rewritten - it is a hack at best */
1066
1067         R300_STATECHANGE(r300, ri);
1068         R300_STATECHANGE(r300, rc);
1069         R300_STATECHANGE(r300, rr);
1070
1071         for(i = 1; i <= 8; ++i)
1072                 r300->hw.ri.cmd[i] = 0x00d10000;
1073         r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1074         r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1075         r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1076
1077         #if 1
1078         for(i = 2; i <= 8; ++i)
1079                 r300->hw.ri.cmd[i] |= 4;
1080         #endif
1081
1082         for(i = 1; i <= 8; ++i)
1083                 r300->hw.rr.cmd[i] = 0;
1084         /* textures enabled ? */
1085         if(r300->state.texture.tc_count>0){
1086
1087                 /* This code only really works with one set of texture coordinates */
1088
1089                 /* The second constant is needed to get glxgears display anything .. */
1090                 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1091                                 | R300_RS_CNTL_0_UNKNOWN_18
1092                                 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1093                 r300->hw.rc.cmd[2] = 0xc0;
1094
1095
1096                 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1097                 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1098
1099                 } else {
1100
1101                 /* The second constant is needed to get glxgears display anything .. */
1102                 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1103                 r300->hw.rc.cmd[2] = 0;
1104
1105                 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1106                 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1107
1108                 }
1109 }
1110
1111 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1112
1113 #define bump_vpu_count(ptr, new_count)   do{\
1114         drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1115         int _nc=(new_count)/4; \
1116         if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1117         }while(0)
1118
1119 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1120 {
1121         int i;
1122
1123         if(vsf->length==0)return;
1124
1125         if(vsf->length & 0x3){
1126                 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1127                 exit(-1);
1128                 }
1129
1130         switch((dest>>8) & 0xf){
1131         case 0:
1132                 R300_STATECHANGE(r300, vpi);
1133                 for(i=0;i<vsf->length;i++)
1134                         r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1135                 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1136                 break;
1137
1138         case 2:
1139                 R300_STATECHANGE(r300, vpp);
1140                 for(i=0;i<vsf->length;i++)
1141                         r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1142                 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1143                 break;
1144         case 4:
1145                 R300_STATECHANGE(r300, vps);
1146                 for(i=0;i<vsf->length;i++)
1147                         r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1148                 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1149                 break;
1150         default:
1151                 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1152                 exit(-1);
1153         }
1154 }
1155
1156
1157 void r300SetupVertexShader(r300ContextPtr rmesa)
1158 {
1159         GLcontext* ctx = rmesa->radeon.glCtx;
1160
1161         /* Reset state, in case we don't use something */
1162         ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1163         ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1164         ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1165
1166
1167 /* This needs to be replaced by vertex shader generation code */
1168
1169
1170         /* textures enabled ? */
1171         if(rmesa->state.texture.tc_count>0){
1172                 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1173                 } else {
1174                 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1175                 }
1176
1177
1178         rmesa->state.vertex_shader.matrix[0].length=16;
1179         memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1180
1181         setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1182
1183         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1184         #if 0
1185         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1186         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1187
1188         setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1189         setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1190         #endif
1191
1192         #if 0
1193         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1194         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1195         #endif
1196
1197         R300_STATECHANGE(rmesa, pvs);
1198         rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1199                 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1200                 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1201         rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1202                 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1203         rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1204         | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1205
1206         /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1207         so I leave it as a reminder */
1208         #if 0
1209         reg_start(R300_VAP_PVS_WAITIDLE,0);
1210                 e32(0x00000000);
1211         #endif
1212 }
1213
1214 void r300SetupPixelShader(r300ContextPtr rmesa)
1215 {
1216 int i,k;
1217
1218         /* This needs to be replaced by pixel shader generation code */
1219
1220         /* textures enabled ? */
1221         if(rmesa->state.texture.tc_count>0){
1222                 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1223                 } else {
1224                 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1225                 }
1226
1227         R300_STATECHANGE(rmesa, fpt);
1228         for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1229                 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1230         rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1231
1232         #define OUTPUT_FIELD(st, reg, field)  \
1233                 R300_STATECHANGE(rmesa, st); \
1234                 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1235                         rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1236                 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1237
1238         OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1239         OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1240         OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1241         OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1242         #undef OUTPUT_FIELD
1243
1244         R300_STATECHANGE(rmesa, fp);
1245         for(i=0;i<4;i++){
1246                 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1247                 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1248                 | (rmesa->state.pixel_shader.program.node[i].alu_end  << R300_PFS_NODE_ALU_END_SHIFT)
1249                 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1250                 | (rmesa->state.pixel_shader.program.node[i].tex_end  << R300_PFS_NODE_TEX_END_SHIFT)
1251                 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1252                 }
1253
1254                 /*  PFS_CNTL_0 */
1255         rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1256                 (rmesa->state.pixel_shader.program.active_nodes-1)
1257                 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1258                 /* PFS_CNTL_1 */
1259         rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1260                 /* PFS_CNTL_2 */
1261         rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1262                 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1263                 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1264                 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1265                 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1266
1267         R300_STATECHANGE(rmesa, fpp);
1268         for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1269                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1270                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1271                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1272                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1273                 }
1274         rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1275
1276 }
1277
1278 /**
1279  * Called by Mesa after an internal state update.
1280  */
1281 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1282 {
1283         r300ContextPtr r300 = R300_CONTEXT(ctx);
1284
1285         _swrast_InvalidateState(ctx, new_state);
1286         _swsetup_InvalidateState(ctx, new_state);
1287         _ac_InvalidateState(ctx, new_state);
1288         _tnl_InvalidateState(ctx, new_state);
1289         _ae_invalidate_state(ctx, new_state);
1290
1291         /* Go inefficiency! */
1292         r300ResetHwState(r300);
1293 }
1294
1295
1296 /**
1297  * Completely recalculates hardware state based on the Mesa state.
1298  */
1299 void r300ResetHwState(r300ContextPtr r300)
1300 {
1301         GLcontext* ctx = r300->radeon.glCtx;
1302         int i;
1303
1304         if (RADEON_DEBUG & DEBUG_STATE)
1305                 fprintf(stderr, "%s\n", __FUNCTION__);
1306
1307         r300UpdateWindow(ctx);
1308
1309         r300ColorMask(ctx,
1310                 ctx->Color.ColorMask[RCOMP],
1311                 ctx->Color.ColorMask[GCOMP],
1312                 ctx->Color.ColorMask[BCOMP],
1313                 ctx->Color.ColorMask[ACOMP]);
1314
1315         r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1316         r300DepthMask(ctx, ctx->Depth.Mask);
1317         r300DepthFunc(ctx, ctx->Depth.Func);
1318
1319         r300UpdateCulling(ctx);
1320
1321         r300_setup_routing(ctx, GL_TRUE);
1322
1323         r300UpdateTextureState(ctx);
1324         r300_setup_textures(ctx);
1325         r300_setup_rs_unit(ctx);
1326
1327         r300SetupVertexShader(r300);
1328         r300SetupPixelShader(r300);
1329
1330         r300_set_blend_state(ctx);
1331         r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1332
1333 //BEGIN: TODO
1334         r300->hw.unk2080.cmd[1] = 0x0030045A;
1335
1336         r300->hw.ovf.cmd[R300_OVF_FMT_0] = 0x00000003;
1337         r300->hw.ovf.cmd[R300_OVF_FMT_1] = 0x00000000;
1338
1339         r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1340                                 | R300_VPORT_X_OFFSET_ENA
1341                                 | R300_VPORT_Y_SCALE_ENA
1342                                 | R300_VPORT_Y_OFFSET_ENA
1343                                 | R300_VPORT_Z_SCALE_ENA
1344                                 | R300_VPORT_Z_OFFSET_ENA
1345                                 | R300_VTX_W0_FMT;
1346         r300->hw.vte.cmd[2] = 0x00000008;
1347
1348         r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1349         r300->hw.unk2134.cmd[2] = 0x00000000;
1350
1351         r300->hw.unk2140.cmd[1] = 0x00000000;
1352
1353         #if 0 /* Done in setup routing */
1354         ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1355         r300->hw.vir[0].cmd[1] = 0x21030003;
1356
1357         ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1358         r300->hw.vir[1].cmd[1] = 0xF688F688;
1359
1360         r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1361         r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1362         #endif
1363
1364         r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1365
1366         r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1367
1368         r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1369         r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1370         r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1371         r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1372
1373         if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1374                 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1375         else
1376                 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1377
1378         #if 0
1379         r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1380                                 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1381         r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1382
1383
1384         r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1385         r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1386         r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1387         #endif
1388
1389         r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1390                 | R300_GB_LINE_STUFF_ENABLE
1391                 | R300_GB_TRIANGLE_STUFF_ENABLE;
1392
1393         r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1394         r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1395         if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1396                 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1397                                                         | R300_GB_TILE_PIPE_COUNT_R300
1398                                                         | R300_GB_TILE_SIZE_16;
1399         else
1400                 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1401                                                         | R300_GB_TILE_PIPE_COUNT_RV300
1402                                                         | R300_GB_TILE_SIZE_16;
1403         r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1404         r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1405
1406         //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1407
1408         r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1409         r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1410         r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1411         r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1412
1413         r300->hw.unk4214.cmd[1] = 0x00050005;
1414
1415         r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1416                                              (6 << R300_POINTSIZE_Y_SHIFT);
1417
1418         r300->hw.unk4230.cmd[1] = 0x01800000;
1419         r300->hw.unk4230.cmd[2] = 0x00020006;
1420         r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1421
1422         r300->hw.unk4260.cmd[1] = 0;
1423         r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1424         r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1425
1426         r300->hw.unk4274.cmd[1] = 0x00000002;
1427         r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1428         r300->hw.unk4274.cmd[3] = 0x00000000;
1429         r300->hw.unk4274.cmd[4] = 0x00000000;
1430
1431         r300->hw.unk4288.cmd[1] = 0x00000000;
1432         r300->hw.unk4288.cmd[2] = 0x00000001;
1433         r300->hw.unk4288.cmd[3] = 0x00000000;
1434         r300->hw.unk4288.cmd[4] = 0x00000000;
1435         r300->hw.unk4288.cmd[5] = 0x00000000;
1436
1437         r300->hw.unk42A0.cmd[1] = 0x00000000;
1438
1439         r300->hw.unk42B4.cmd[1] = 0x00000000;
1440
1441         r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1442         r300->hw.unk42C0.cmd[2] = 0x00000000;
1443
1444
1445         r300->hw.unk43A4.cmd[1] = 0x0000001C;
1446         r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1447
1448         r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1449
1450         #if 0
1451         r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1452         r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1453         r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1454         r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1455         r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1456         r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1457         r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1458         #endif
1459
1460         r300->hw.unk46A4.cmd[1] = 0x00001B01;
1461         r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1462         r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1463         r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1464         r300->hw.unk46A4.cmd[5] = 0x00000001;
1465
1466         #if 0
1467         for(i = 1; i <= 64; ++i) {
1468                 /* create NOP instructions */
1469                 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1470                 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1471                 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1472                 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1473         }
1474         #endif
1475
1476         r300->hw.unk4BC0.cmd[1] = 0;
1477
1478         r300->hw.unk4BC8.cmd[1] = 0;
1479         r300->hw.unk4BC8.cmd[2] = 0;
1480         r300->hw.unk4BC8.cmd[3] = 0;
1481
1482         #if 0
1483         r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1484         #endif
1485
1486         r300->hw.unk4BD8.cmd[1] = 0;
1487
1488         r300->hw.unk4E00.cmd[1] = 0;
1489
1490         #if 0
1491         r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1492         r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1493         #endif
1494
1495         r300->hw.unk4E10.cmd[1] = 0;
1496         r300->hw.unk4E10.cmd[2] = 0;
1497         r300->hw.unk4E10.cmd[3] = 0;
1498
1499         r300->hw.cb.cmd[R300_CB_OFFSET] =
1500                 r300->radeon.radeonScreen->backOffset +
1501                 r300->radeon.radeonScreen->fbLocation;
1502         r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1503                 | R300_COLOR_UNKNOWN_22_23;
1504
1505         r300->hw.unk4E50.cmd[1] = 0;
1506         r300->hw.unk4E50.cmd[2] = 0;
1507         r300->hw.unk4E50.cmd[3] = 0;
1508         r300->hw.unk4E50.cmd[4] = 0;
1509         r300->hw.unk4E50.cmd[5] = 0;
1510         r300->hw.unk4E50.cmd[6] = 0;
1511         r300->hw.unk4E50.cmd[7] = 0;
1512         r300->hw.unk4E50.cmd[8] = 0;
1513         r300->hw.unk4E50.cmd[9] = 0;
1514
1515         r300->hw.unk4E88.cmd[1] = 0;
1516
1517         r300->hw.unk4EA0.cmd[1] = 0x00000000;
1518         r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1519
1520         r300->hw.unk4F08.cmd[1] = 0x00FFFF00;
1521
1522         r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1523         r300->hw.unk4F10.cmd[2] = 0x00000000;
1524         r300->hw.unk4F10.cmd[3] = 0x00000003;
1525         r300->hw.unk4F10.cmd[4] = 0x00000000;
1526
1527         r300->hw.zb.cmd[R300_ZB_OFFSET] =
1528                 r300->radeon.radeonScreen->depthOffset +
1529                 r300->radeon.radeonScreen->fbLocation;
1530         r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1531
1532         r300->hw.unk4F28.cmd[1] = 0;
1533
1534         r300->hw.unk4F30.cmd[1] = 0;
1535         r300->hw.unk4F30.cmd[2] = 0;
1536
1537         r300->hw.unk4F44.cmd[1] = 0;
1538
1539         r300->hw.unk4F54.cmd[1] = 0;
1540
1541         #if 0
1542         ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1543         for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1544                 /* MOV t0, t0 */
1545                 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1546                 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1547                 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1548                 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1549         }
1550
1551         ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1552         for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1553                 r300->hw.vpp.cmd[i] = 0;
1554         #endif
1555
1556         r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1557         r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1558         r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1559         r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1560
1561 //END: TODO
1562
1563         r300->hw.all_dirty = GL_TRUE;
1564 }
1565
1566
1567
1568 /**
1569  * Calculate initial hardware state and register state functions.
1570  * Assumes that the command buffer and state atoms have been
1571  * initialized already.
1572  */
1573 void r300InitState(r300ContextPtr r300)
1574 {
1575         GLcontext *ctx = r300->radeon.glCtx;
1576         GLuint depth_fmt;
1577
1578         radeonInitState(&r300->radeon);
1579
1580         switch (ctx->Visual.depthBits) {
1581         case 16:
1582                 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1583                 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1584                 //r300->state.stencil.clear = 0x00000000;
1585                 break;
1586         case 24:
1587                 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1588                 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1589                 //r300->state.stencil.clear = 0xff000000;
1590                 break;
1591         default:
1592                 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1593                         ctx->Visual.depthBits);
1594                 exit(-1);
1595         }
1596
1597         memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1598
1599         r300ResetHwState(r300);
1600 }
1601
1602
1603
1604 /**
1605  * Initialize driver's state callback functions
1606  */
1607 void r300InitStateFuncs(struct dd_function_table* functions)
1608 {
1609         radeonInitStateFuncs(functions);
1610
1611         functions->UpdateState = r300InvalidateState;
1612         //functions->AlphaFunc = r300AlphaFunc;
1613         functions->BlendColor = r300BlendColor;
1614         functions->BlendEquationSeparate = r300BlendEquationSeparate;
1615         functions->BlendFuncSeparate = r300BlendFuncSeparate;
1616         functions->Enable = r300Enable;
1617         functions->ColorMask = r300ColorMask;
1618         functions->DepthFunc = r300DepthFunc;
1619         functions->DepthMask = r300DepthMask;
1620         functions->CullFace = r300CullFace;
1621         functions->FrontFace = r300FrontFace;
1622
1623         /* Viewport related */
1624         functions->Viewport = r300Viewport;
1625         functions->DepthRange = r300DepthRange;
1626         functions->PointSize = r300PointSize;
1627 }
1628