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