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(immediate){ \
 819                         r300->state.aos[count].element_size=4; \
 820                         r300->state.aos[count].stride=4; \
 821                         r300->state.aos[count].ncomponents=4; \
 822                         } else { \
 823                         r300->state.aos[count].element_size=v->size; \
 824                         r300->state.aos[count].stride=v->size; \
 825                         r300->state.aos[count].ncomponents=v->size; \
 826                         } \
 827                 r300->state.aos[count].offset=o; \
 828                 r300->state.aos[count].reg=reg; \
 829                 r300->state.aos[count].format=(f); \
 830                 r300->state.vap_reg.r=reg; \
 831                 count++; \
 832                 reg++; \
 833                 }
 834
 835                 /* All offsets are 0 - for use by immediate mode.
 836                 Should change later to handle vertex buffers */
 837         CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
 838         CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
 839         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 840                 if(ctx->Texture.Unit[i].Enabled)
 841                         CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
 842
 843         r300->state.aos_count=count;
 844
 845         if (RADEON_DEBUG & DEBUG_STATE)
 846                 fprintf(stderr, "aos_count=%d\n", count);
 847
 848         if(count>R300_MAX_AOS_ARRAYS){
 849                 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
 850                 exit(-1);
 851                 }
 852
 853         /* Implement AOS */
 854
 855         /* setup INPUT_ROUTE */
 856         R300_STATECHANGE(r300, vir[0]);
 857         for(i=0;i+1<count;i+=2){
 858                 dw=(r300->state.aos[i].ncomponents-1)
 859                 | ((r300->state.aos[i].reg)<<8)
 860                 | (r300->state.aos[i].format<<14)
 861                 | (((r300->state.aos[i+1].ncomponents-1)
 862                 | ((r300->state.aos[i+1].reg)<<8)
 863                 | (r300->state.aos[i+1].format<<14))<<16);
 864
 865                 if(i+2==count){
 866                         dw|=(1<<(13+16));
 867                         }
 868                 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
 869                 }
 870         if(count & 1){
 871                 dw=(r300->state.aos[count-1].ncomponents-1)
 872                 | (r300->state.aos[count-1].format<<14)
 873                 | ((r300->state.aos[count-1].reg)<<8)
 874                 | (1<<13);
 875                 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
 876                 //fprintf(stderr, "vir0 dw=%08x\n", dw);
 877                 }
 878         /* Set the rest of INPUT_ROUTE_0 to 0 */
 879         //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
 880         ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
 881
 882
 883         /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
 884         #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
 885                 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
 886                 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
 887                 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
 888
 889         #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
 890                 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
 891                 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
 892                 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
 893
 894         R300_STATECHANGE(r300, vir[1]);
 895
 896         for(i=0;i+1<count;i+=2){
 897                 /* do i first.. */
 898                 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
 899                 dw=(ALL_COMPONENTS & mask)
 900                 | (ALL_DEFAULT & ~mask)
 901                 | R300_INPUT_ROUTE_ENABLE;
 902
 903                 /* i+1 */
 904                 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
 905                 dw|=(
 906                 (ALL_COMPONENTS & mask)
 907                 | (ALL_DEFAULT & ~mask)
 908                 | R300_INPUT_ROUTE_ENABLE
 909                 )<<16;
 910
 911                 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
 912                 }
 913         if(count & 1){
 914                 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
 915                 dw=(ALL_COMPONENTS & mask)
 916                 | (ALL_DEFAULT & ~mask)
 917                 | R300_INPUT_ROUTE_ENABLE;
 918                 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
 919                 //fprintf(stderr, "vir1 dw=%08x\n", dw);
 920                 }
 921         /* Set the rest of INPUT_ROUTE_1 to 0 */
 922         //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
 923         ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
 924
 925         /* Set up input_cntl */
 926
 927         R300_STATECHANGE(r300, vic);
 928         r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555;  /* Hard coded value, no idea what it means */
 929
 930         r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
 931                                         | R300_INPUT_CNTL_COLOR;
 932
 933         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 934                 if(ctx->Texture.Unit[i].Enabled)
 935                         r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
 936
 937         /* Stage 3: VAP output */
 938         R300_STATECHANGE(r300, vof);
 939         r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
 940                                         | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
 941
 942         r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
 943         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 944                 if(ctx->Texture.Unit[i].Enabled)
 945                         r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
 946
 947 }
 948
 949 static r300TexObj default_tex_obj={
 950         filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
 951         pitch: 0x8000,
 952         size: (0xff << R300_TX_WIDTHMASK_SHIFT)
 953               | (0xff << R300_TX_HEIGHTMASK_SHIFT)
 954               | (0x8 << R300_TX_SIZE_SHIFT),
 955         format: 0x88a0c,
 956         offset: 0x0,
 957         unknown4: 0x0,
 958         unknown5: 0x0
 959         };
 960
 961         /* there is probably a system to these value, but, for now,
 962            we just try by hand */
 963
 964 static int inline translate_src(int src)
 965 {
 966         switch (src) {
 967         case GL_TEXTURE:
 968                 return 1;
 969                 break;
 970         case GL_CONSTANT:
 971                 return 2;
 972                 break;
 973         case GL_PRIMARY_COLOR:
 974                 return 3;
 975                 break;
 976         case GL_PREVIOUS:
 977                 return 4;
 978                 break;
 979         case GL_ZERO:
 980                 return 5;
 981                 break;
 982         case GL_ONE:
 983                 return 6;
 984                 break;
 985         default:
 986                 return 0;
 987         }
 988 }
 989
 990 /* I think 357 and 457 are prime numbers.. wiggle them if you get coincidences */
 991 #define FORMAT_HASH(opRGB, srcRGB, modeRGB, opA, srcA, modeA, format, intFormat)        ( \
 992         (\
 993         ((opRGB)<<30) | ((opA)<<28) | \
 994         ((srcRGB)<< 25) | ((srcA)<<22) | \
 995         ((modeRGB)) \
 996         ) \
 997         ^ ((modeA)*357) \
 998         ^ (((format)) *457) \
 999         ^ ((intFormat) * 7) \
1000         )
1001
1002
1003 static GLuint translate_texture_format(GLcontext *ctx, GLint tex_unit, GLuint format, GLint IntFormat,
1004         struct gl_texture_format *tex_format)
1005 {
1006         const struct gl_texture_unit *texUnit= &ctx->Texture.Unit[tex_unit];
1007         int i=0; /* number of alpha args .. */
1008         GLuint fmt;
1009
1010         #if 0
1011         fprintf(stderr, "_ReallyEnabled=%d EnvMode=%s\n",
1012                 texUnit->_ReallyEnabled,
1013                 _mesa_lookup_enum_by_nr(texUnit->EnvMode));
1014         #endif
1015
1016         if(tex_format==NULL){
1017                 fprintf(stderr, "Aeiii ! tex_format==NULL !!\n");
1018                 return 0;
1019                 }
1020
1021         switch(tex_format->MesaFormat){
1022                 case MESA_FORMAT_RGBA8888:
1023                         return R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8);
1024                 default:
1025                         fprintf(stderr, "Do not know format %s\n", _mesa_lookup_enum_by_nr(tex_format->MesaFormat));
1026                         return 0;
1027                 }
1028
1029         switch(IntFormat){
1030                 case 4:
1031                 case GL_RGBA:
1032                 case GL_RGBA8:
1033                         break;
1034                 case 3:
1035                 case GL_RGB8:
1036                         fmt=R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1037                         break;
1038                 default:
1039                         return 0;
1040                 }
1041         #if 1
1042         //fmt &= 0x00fff;
1043         //fmt |= ((format) & 0xff00)<<4;
1044         fprintf(stderr, "NumArgsRGB=%d NumArgsA=%d\n",
1045                 texUnit->_CurrentCombine->_NumArgsRGB,
1046                 texUnit->_CurrentCombine->_NumArgsA);
1047
1048         fprintf(stderr, "fmt=%08x\n", fmt);
1049         #endif
1050         return fmt;
1051         /* Size field in format specific first */
1052         switch(FORMAT_HASH(
1053                 texUnit->_CurrentCombine->OperandRGB[i] -GL_SRC_COLOR,
1054                 translate_src(texUnit->_CurrentCombine->SourceRGB[i]),
1055                 texUnit->_CurrentCombine->ModeRGB,
1056                 texUnit->_CurrentCombine->OperandA[i] -GL_SRC_ALPHA,
1057                 translate_src(texUnit->_CurrentCombine->SourceA[i]),
1058                 texUnit->_CurrentCombine->ModeA,
1059                 format,
1060                 IntFormat
1061                 )){
1062         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA):
1063                 /* tested with:
1064                         kfiresaver.kss
1065                         */
1066                 return R300_EASY_TX_FORMAT(X, X, CUT_W, W, W8Z8Y8X8);
1067         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA8):
1068                 /* tested with:
1069                         Quake3demo
1070                         */
1071                 /* Quake3demo -small font on the bottom */
1072                 return fmt;
1073         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, GL_RGBA8):
1074                 /* Quake3demo - mouse cursor*/
1075                 return fmt;
1076         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, 4):
1077                 /* tested with:
1078                         kfiresaver.kss
1079                         */
1080                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1081         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, 4):
1082                 /* tested with:
1083                         kfiresaver.kss
1084                         kfountain.kss
1085                         */
1086                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1087         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008847, 3):
1088                 /* tested with
1089                         lesson 06
1090                         lesson 07
1091                         */
1092         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, 0x00000003):
1093                 /* Tested with NeHe lesson 08 */
1094         //case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x0005547, 0):
1095                 /* Can't remember what I tested this with..
1096                    try putting return 0 of you see broken textures which
1097                    are not being complained about */
1098         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00009947, GL_RGB8):
1099         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, GL_RGB8):
1100         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00003347, GL_RGB8):
1101         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, 3):
1102                 /* Tested with:
1103                         Quake3demo
1104                         */
1105                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1106         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007847, GL_RGBA8):
1107         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006747, GL_RGBA8):
1108         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006647, GL_RGBA8):
1109         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, GL_RGBA8):
1110                 /* Tested with:
1111                         Quake3demo
1112                         */
1113                 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
1114         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, GL_RGBA8):
1115                 return R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) ;
1116         case  FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008845, 0x00008056):
1117                 //return 0;
1118                 fprintf(stderr, "***\n");
1119                 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
1120         }
1121
1122
1123         {
1124                 static int warn_once=1;
1125                 if(warn_once){
1126                         fprintf(stderr, "%s:%s Do not know how to translate texture format - help me !\n",
1127                                 __FILE__, __FUNCTION__);
1128                         warn_once=0;
1129                         }
1130         }
1131                 return 0;
1132 }
1133
1134 void r300_setup_textures(GLcontext *ctx)
1135 {
1136         int i, mtu;
1137         struct r300_tex_obj *t;
1138         r300ContextPtr r300 = R300_CONTEXT(ctx);
1139         int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
1140         struct gl_texture_unit *texUnit;
1141
1142         R300_STATECHANGE(r300, txe);
1143         R300_STATECHANGE(r300, tex.filter);
1144         R300_STATECHANGE(r300, tex.unknown1);
1145         R300_STATECHANGE(r300, tex.size);
1146         R300_STATECHANGE(r300, tex.format);
1147         R300_STATECHANGE(r300, tex.offset);
1148         R300_STATECHANGE(r300, tex.unknown4);
1149         R300_STATECHANGE(r300, tex.unknown5);
1150         R300_STATECHANGE(r300, tex.border_color);
1151
1152         r300->state.texture.tc_count=0;
1153
1154         r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
1155
1156         mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1157         if (RADEON_DEBUG & DEBUG_STATE)
1158                 fprintf(stderr, "mtu=%d\n", mtu);
1159
1160         if(mtu>R300_MAX_TEXTURE_UNITS){
1161                 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1162                         mtu, R300_MAX_TEXTURE_UNITS);
1163                 exit(-1);
1164                 }
1165         for(i=0;i<mtu;i++){
1166                 if(ctx->Texture.Unit[i].Enabled){
1167                         t=r300->state.texture.unit[i].texobj;
1168                         fprintf(stderr, "format=%08x\n", r300->state.texture.unit[i].format);
1169                         r300->state.texture.tc_count++;
1170                         if(t==NULL){
1171                                 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1172                                 //exit(-1);
1173                                 t=&default_tex_obj;
1174                                 }
1175                         if (RADEON_DEBUG & DEBUG_STATE)
1176                                 fprintf(stderr, "Activating texture unit %d\n", i);
1177                         max_texture_unit=i;
1178                         r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1179
1180                         r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=t->filter;
1181
1182                         /* No idea why linear filtered textures shake when puting random data */
1183                         /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1184                         r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1185                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1186                         //fprintf(stderr, "t->format=%08x\n", t->format);
1187                         r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
1188                         r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1189                         r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
1190                         r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0+i]=t->pp_border_color;
1191
1192                         /* We don't know how to set this yet */
1193                         //value from r300_lib.c for RGB24
1194                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x88a0c;
1195                         #if 0
1196                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=translate_texture_format(ctx, i, t->format,
1197                                 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->IntFormat:3,
1198                                 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->TexFormat:NULL);
1199                         #endif
1200
1201                         #if 0
1202                         fprintf(stderr, "Format=%s IntFormat=%08x MesaFormat=%08x BaseFormat=%s IsCompressed=%d Target=%s\n",
1203                                 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->Format),
1204                                 t->base.tObj->Image[0][0]->IntFormat,
1205                                 t->base.tObj->Image[0][0]->TexFormat->MesaFormat,
1206                                 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->TexFormat->BaseFormat),
1207                                 t->base.tObj->Image[0][0]->IsCompressed,
1208                                 _mesa_lookup_enum_by_nr(t->base.tObj->Target));
1209
1210                         fprintf(stderr, "pitch=%08x filter=%08x format=%08x\n", t->pitch, t->filter, r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]);
1211                         fprintf(stderr, "unknown1=%08x size=%08x\n", r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i],
1212                                 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]);
1213                         #endif
1214                         /* Use the code below to quickly find matching texture
1215                            formats. Requires an app that displays the same texture
1216                            repeatedly  */
1217                               #if 0
1218                                 if(r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]==0){
1219                                         static int fmt=0x0;
1220                                         static int k=0;
1221                                         k++;
1222                                         if(k>20){
1223                                                 k=0;
1224                                                 fmt++;
1225                                                 texUnit = &ctx->Texture.Unit[i];
1226                                                 fprintf(stderr, "Want to set FORMAT_HASH(%d, %d, 0x%04x, %d, %d, 0x%04x, 0x%08x, %s(%08x))\n",
1227                                                         texUnit->_CurrentCombine->OperandRGB[0] -GL_SRC_COLOR,
1228                                                         translate_src(texUnit->_CurrentCombine->SourceRGB[0]),
1229                                                         texUnit->_CurrentCombine->ModeRGB,
1230                                                         texUnit->_CurrentCombine->OperandA[0] -GL_SRC_ALPHA,
1231                                                         translate_src(texUnit->_CurrentCombine->SourceA[0]),
1232                                                         texUnit->_CurrentCombine->ModeA,
1233                                                         t->format,
1234                                                         _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->IntFormat),
1235                                                         t->base.tObj->Image[0][0]->IntFormat
1236                                                         );
1237                                                 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);
1238                                                 fprintf(stderr, "\t_ReallyEnabled=%08x EnvMode=%08x IntFormat=%08x\n", texUnit->_ReallyEnabled, texUnit->EnvMode,  t->base.tObj->Image[0][0]->IntFormat);
1239                                                 if(fmt>0xfff){
1240                                                         fmt=0;
1241                                                         }
1242                                                 //sleep(1);
1243                                                 fprintf(stderr, "Now trying format %08x\n",
1244                                                         fmt);
1245                                                 fprintf(stderr, "size=%08x\n", t->size);
1246                                                 }
1247                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=known_formats[fmt];
1248                                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=
1249                                                 R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)  | (fmt<<24);
1250                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x08a0c | (fmt<<16);
1251                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x58a00 | (fmt);
1252                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x53a0c | (fmt<<24);
1253                                         }
1254                               #endif
1255
1256                         }
1257
1258                 }
1259         ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1260         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1261         ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1262         ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1263         ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1264         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1265         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1266         ((drm_r300_cmd_header_t*)r300->hw.tex.border_color.cmd)->unchecked_state.count = max_texture_unit+1;
1267
1268         if (RADEON_DEBUG & DEBUG_STATE)
1269                 fprintf(stderr, "TX_ENABLE: %08x  max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1270 }
1271
1272 void r300_setup_rs_unit(GLcontext *ctx)
1273 {
1274         r300ContextPtr r300 = R300_CONTEXT(ctx);
1275         int i;
1276
1277         /* This needs to be rewritten - it is a hack at best */
1278
1279         R300_STATECHANGE(r300, ri);
1280         R300_STATECHANGE(r300, rc);
1281         R300_STATECHANGE(r300, rr);
1282
1283         for(i = 1; i <= 8; ++i)
1284                 r300->hw.ri.cmd[i] = 0x00d10000;
1285         r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1286         r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1287         r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1288
1289         #if 1
1290         for(i = 2; i <= 8; ++i)
1291                 r300->hw.ri.cmd[i] |= 4;
1292         #endif
1293
1294         for(i = 1; i <= 8; ++i)
1295                 r300->hw.rr.cmd[i] = 0;
1296         /* textures enabled ? */
1297         if(r300->state.texture.tc_count>0){
1298
1299                 /* This code only really works with one set of texture coordinates */
1300
1301                 /* The second constant is needed to get glxgears display anything .. */
1302                 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1303                                 | R300_RS_CNTL_0_UNKNOWN_18
1304                                 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1305                 r300->hw.rc.cmd[2] = 0xc0;
1306
1307
1308                 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1309                 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1310
1311                 } else {
1312
1313                 /* The second constant is needed to get glxgears display anything .. */
1314                 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1315                 r300->hw.rc.cmd[2] = 0;
1316
1317                 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1318                 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1319
1320                 }
1321 }
1322
1323 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1324
1325 #define bump_vpu_count(ptr, new_count)   do{\
1326         drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1327         int _nc=(new_count)/4; \
1328         if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1329         }while(0)
1330
1331 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1332 {
1333         int i;
1334
1335         if(vsf->length==0)return;
1336
1337         if(vsf->length & 0x3){
1338                 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1339                 exit(-1);
1340                 }
1341
1342         switch((dest>>8) & 0xf){
1343         case 0:
1344                 R300_STATECHANGE(r300, vpi);
1345                 for(i=0;i<vsf->length;i++)
1346                         r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1347                 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1348                 break;
1349
1350         case 2:
1351                 R300_STATECHANGE(r300, vpp);
1352                 for(i=0;i<vsf->length;i++)
1353                         r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1354                 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1355                 break;
1356         case 4:
1357                 R300_STATECHANGE(r300, vps);
1358                 for(i=0;i<vsf->length;i++)
1359                         r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1360                 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1361                 break;
1362         default:
1363                 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1364                 exit(-1);
1365         }
1366 }
1367
1368
1369 void r300SetupVertexShader(r300ContextPtr rmesa)
1370 {
1371         GLcontext* ctx = rmesa->radeon.glCtx;
1372
1373         /* Reset state, in case we don't use something */
1374         ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1375         ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1376         ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1377
1378
1379 /* This needs to be replaced by vertex shader generation code */
1380
1381
1382         /* textures enabled ? */
1383         if(rmesa->state.texture.tc_count>0){
1384                 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1385                 } else {
1386                 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1387                 }
1388
1389
1390         rmesa->state.vertex_shader.matrix[0].length=16;
1391         memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1392
1393         setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1394
1395         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1396         #if 0
1397         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1398         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1399
1400         setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1401         setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1402         #endif
1403
1404         #if 0
1405         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1406         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1407         #endif
1408
1409         R300_STATECHANGE(rmesa, pvs);
1410         rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1411                 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1412                 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1413         rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1414                 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1415         rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1416         | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1417
1418         /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1419         so I leave it as a reminder */
1420         #if 0
1421         reg_start(R300_VAP_PVS_WAITIDLE,0);
1422                 e32(0x00000000);
1423         #endif
1424 }
1425
1426 void r300SetupPixelShader(r300ContextPtr rmesa)
1427 {
1428 int i,k;
1429
1430         /* This needs to be replaced by pixel shader generation code */
1431
1432         /* textures enabled ? */
1433         if(rmesa->state.texture.tc_count>0){
1434                 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1435                 } else {
1436                 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1437                 }
1438
1439         R300_STATECHANGE(rmesa, fpt);
1440         for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1441                 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1442         rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1443
1444         #define OUTPUT_FIELD(st, reg, field)  \
1445                 R300_STATECHANGE(rmesa, st); \
1446                 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1447                         rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1448                 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1449
1450         OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1451         OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1452         OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1453         OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1454         #undef OUTPUT_FIELD
1455
1456         R300_STATECHANGE(rmesa, fp);
1457         for(i=0;i<4;i++){
1458                 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1459                 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1460                 | (rmesa->state.pixel_shader.program.node[i].alu_end  << R300_PFS_NODE_ALU_END_SHIFT)
1461                 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1462                 | (rmesa->state.pixel_shader.program.node[i].tex_end  << R300_PFS_NODE_TEX_END_SHIFT)
1463                 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1464                 }
1465
1466                 /*  PFS_CNTL_0 */
1467         rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1468                 (rmesa->state.pixel_shader.program.active_nodes-1)
1469                 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1470                 /* PFS_CNTL_1 */
1471         rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1472                 /* PFS_CNTL_2 */
1473         rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1474                 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1475                 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1476                 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1477                 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1478
1479         R300_STATECHANGE(rmesa, fpp);
1480         for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1481                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1482                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1483                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1484                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1485                 }
1486         rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1487
1488 }
1489
1490 /**
1491  * Called by Mesa after an internal state update.
1492  */
1493 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1494 {
1495         r300ContextPtr r300 = R300_CONTEXT(ctx);
1496
1497         _swrast_InvalidateState(ctx, new_state);
1498         _swsetup_InvalidateState(ctx, new_state);
1499         _ac_InvalidateState(ctx, new_state);
1500         _tnl_InvalidateState(ctx, new_state);
1501         _ae_invalidate_state(ctx, new_state);
1502
1503         /* Go inefficiency! */
1504         r300ResetHwState(r300);
1505 }
1506
1507
1508 /**
1509  * Completely recalculates hardware state based on the Mesa state.
1510  */
1511 void r300ResetHwState(r300ContextPtr r300)
1512 {
1513         GLcontext* ctx = r300->radeon.glCtx;
1514         int i;
1515
1516         if (RADEON_DEBUG & DEBUG_STATE)
1517                 fprintf(stderr, "%s\n", __FUNCTION__);
1518
1519                 /* This is a place to initialize registers which
1520                    have bitfields accessed by different functions
1521                    and not all bits are used */
1522         #if 0
1523         r300->hw.zs.cmd[R300_ZS_CNTL_0] = 0;
1524         r300->hw.zs.cmd[R300_ZS_CNTL_1] = 0;
1525         r300->hw.zs.cmd[R300_ZS_CNTL_2] = 0xffff00;
1526         #endif
1527
1528                 /* go and compute register values from GL state */
1529
1530         r300UpdateWindow(ctx);
1531
1532         r300ColorMask(ctx,
1533                 ctx->Color.ColorMask[RCOMP],
1534                 ctx->Color.ColorMask[GCOMP],
1535                 ctx->Color.ColorMask[BCOMP],
1536                 ctx->Color.ColorMask[ACOMP]);
1537
1538         r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1539         r300DepthMask(ctx, ctx->Depth.Mask);
1540         r300DepthFunc(ctx, ctx->Depth.Func);
1541
1542         r300UpdateCulling(ctx);
1543
1544         r300_setup_routing(ctx, GL_TRUE);
1545
1546         r300UpdateTextureState(ctx);
1547         r300_setup_textures(ctx);
1548         r300_setup_rs_unit(ctx);
1549
1550         r300SetupVertexShader(r300);
1551         r300SetupPixelShader(r300);
1552
1553         r300_set_blend_state(ctx);
1554         r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1555
1556                 /* Initialize magic registers
1557                  TODO : learn what they really do, or get rid of
1558                  those we don't have to touch */
1559         r300->hw.unk2080.cmd[1] = 0x0030045A;
1560
1561         r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1562                                 | R300_VPORT_X_OFFSET_ENA
1563                                 | R300_VPORT_Y_SCALE_ENA
1564                                 | R300_VPORT_Y_OFFSET_ENA
1565                                 | R300_VPORT_Z_SCALE_ENA
1566                                 | R300_VPORT_Z_OFFSET_ENA
1567                                 | R300_VTX_W0_FMT;
1568         r300->hw.vte.cmd[2] = 0x00000008;
1569
1570         r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1571         r300->hw.unk2134.cmd[2] = 0x00000000;
1572
1573         r300->hw.unk2140.cmd[1] = 0x00000000;
1574
1575         #if 0 /* Done in setup routing */
1576         ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1577         r300->hw.vir[0].cmd[1] = 0x21030003;
1578
1579         ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1580         r300->hw.vir[1].cmd[1] = 0xF688F688;
1581
1582         r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1583         r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1584         #endif
1585
1586         r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1587
1588         r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1589
1590         r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1591         r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1592         r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1593         r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1594
1595         if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1596                 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1597         else
1598                 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1599
1600         #if 0
1601         r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1602                                 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1603         r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1604
1605
1606         r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1607         r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1608         r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1609         #endif
1610
1611         r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1612                 | R300_GB_LINE_STUFF_ENABLE
1613                 | R300_GB_TRIANGLE_STUFF_ENABLE;
1614
1615         r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1616         r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1617         if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1618                 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1619                                                         | R300_GB_TILE_PIPE_COUNT_R300
1620                                                         | R300_GB_TILE_SIZE_16;
1621         else
1622                 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1623                                                         | R300_GB_TILE_PIPE_COUNT_RV300
1624                                                         | R300_GB_TILE_SIZE_16;
1625         r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1626         r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1627
1628         //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1629
1630         r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1631         r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1632         r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1633         r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1634
1635         r300->hw.unk4214.cmd[1] = 0x00050005;
1636
1637         r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1638                                              (6 << R300_POINTSIZE_Y_SHIFT);
1639
1640         r300->hw.unk4230.cmd[1] = 0x01800000;
1641         r300->hw.unk4230.cmd[2] = 0x00020006;
1642         r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1643
1644         r300->hw.unk4260.cmd[1] = 0;
1645         r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1646         r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1647
1648         r300->hw.unk4274.cmd[1] = 0x00000002;
1649         r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1650         r300->hw.unk4274.cmd[3] = 0x00000000;
1651         r300->hw.unk4274.cmd[4] = 0x00000000;
1652
1653         r300->hw.unk4288.cmd[1] = 0x00000000;
1654         r300->hw.unk4288.cmd[2] = 0x00000001;
1655         r300->hw.unk4288.cmd[3] = 0x00000000;
1656         r300->hw.unk4288.cmd[4] = 0x00000000;
1657         r300->hw.unk4288.cmd[5] = 0x00000000;
1658
1659         r300->hw.unk42A0.cmd[1] = 0x00000000;
1660
1661         r300->hw.unk42B4.cmd[1] = 0x00000000;
1662
1663         r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1664         r300->hw.unk42C0.cmd[2] = 0x00000000;
1665
1666
1667         r300->hw.unk43A4.cmd[1] = 0x0000001C;
1668         r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1669
1670         r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1671
1672         #if 0
1673         r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1674         r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1675         r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1676         r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1677         r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1678         r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1679         r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1680         #endif
1681
1682         r300->hw.unk46A4.cmd[1] = 0x00001B01;
1683         r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1684         r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1685         r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1686         r300->hw.unk46A4.cmd[5] = 0x00000001;
1687
1688         #if 0
1689         for(i = 1; i <= 64; ++i) {
1690                 /* create NOP instructions */
1691                 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1692                 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1693                 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1694                 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1695         }
1696         #endif
1697
1698         r300->hw.unk4BC0.cmd[1] = 0;
1699
1700         r300->hw.unk4BC8.cmd[1] = 0;
1701         r300->hw.unk4BC8.cmd[2] = 0;
1702         r300->hw.unk4BC8.cmd[3] = 0;
1703
1704         #if 0
1705         r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1706         #endif
1707
1708         r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
1709         r300->hw.unk4BD8.cmd[1] = 0;
1710
1711         r300->hw.unk4E00.cmd[1] = 0;
1712
1713         #if 0
1714         r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1715         r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1716         #endif
1717
1718         r300->hw.unk4E10.cmd[1] = 0;
1719         r300->hw.unk4E10.cmd[2] = 0;
1720         r300->hw.unk4E10.cmd[3] = 0;
1721
1722         r300->hw.cb.cmd[R300_CB_OFFSET] =
1723                 r300->radeon.radeonScreen->backOffset +
1724                 r300->radeon.radeonScreen->fbLocation;
1725         r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1726                 | R300_COLOR_UNKNOWN_22_23;
1727
1728         r300->hw.unk4E50.cmd[1] = 0;
1729         r300->hw.unk4E50.cmd[2] = 0;
1730         r300->hw.unk4E50.cmd[3] = 0;
1731         r300->hw.unk4E50.cmd[4] = 0;
1732         r300->hw.unk4E50.cmd[5] = 0;
1733         r300->hw.unk4E50.cmd[6] = 0;
1734         r300->hw.unk4E50.cmd[7] = 0;
1735         r300->hw.unk4E50.cmd[8] = 0;
1736         r300->hw.unk4E50.cmd[9] = 0;
1737
1738         r300->hw.unk4E88.cmd[1] = 0;
1739
1740         r300->hw.unk4EA0.cmd[1] = 0x00000000;
1741         r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1742
1743         r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1744         r300->hw.unk4F10.cmd[2] = 0x00000000;
1745         r300->hw.unk4F10.cmd[3] = 0x00000003;
1746         r300->hw.unk4F10.cmd[4] = 0x00000000;
1747
1748         /* experiment a bit */
1749         r300->hw.unk4F10.cmd[2] = 0x00000001; // depthbuffer format?
1750
1751         r300->hw.zb.cmd[R300_ZB_OFFSET] =
1752                 r300->radeon.radeonScreen->depthOffset +
1753                 r300->radeon.radeonScreen->fbLocation;
1754         r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1755
1756         r300->hw.unk4F28.cmd[1] = 0;
1757
1758         r300->hw.unk4F30.cmd[1] = 0;
1759         r300->hw.unk4F30.cmd[2] = 0;
1760
1761         r300->hw.unk4F44.cmd[1] = 0;
1762
1763         r300->hw.unk4F54.cmd[1] = 0;
1764
1765         #if 0
1766         ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1767         for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1768                 /* MOV t0, t0 */
1769                 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1770                 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1771                 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1772                 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1773         }
1774
1775         ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1776         for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1777                 r300->hw.vpp.cmd[i] = 0;
1778         #endif
1779
1780         r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1781         r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1782         r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1783         r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1784
1785 //END: TODO
1786
1787         r300->hw.all_dirty = GL_TRUE;
1788 }
1789
1790
1791
1792 /**
1793  * Calculate initial hardware state and register state functions.
1794  * Assumes that the command buffer and state atoms have been
1795  * initialized already.
1796  */
1797 void r300InitState(r300ContextPtr r300)
1798 {
1799         GLcontext *ctx = r300->radeon.glCtx;
1800         GLuint depth_fmt;
1801
1802         radeonInitState(&r300->radeon);
1803
1804         switch (ctx->Visual.depthBits) {
1805         case 16:
1806                 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1807                 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1808                 //r300->state.stencil.clear = 0x00000000;
1809                 break;
1810         case 24:
1811                 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1812                 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1813                 //r300->state.stencil.clear = 0xff000000;
1814                 break;
1815         default:
1816                 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1817                         ctx->Visual.depthBits);
1818                 exit(-1);
1819         }
1820
1821         /* Only have hw stencil when depth buffer is 24 bits deep */
1822         r300->state.hw_stencil = (ctx->Visual.stencilBits > 0 &&
1823                                          ctx->Visual.depthBits == 24);
1824
1825         memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1826
1827         r300ResetHwState(r300);
1828 }
1829
1830
1831
1832 /**
1833  * Initialize driver's state callback functions
1834  */
1835 void r300InitStateFuncs(struct dd_function_table* functions)
1836 {
1837         radeonInitStateFuncs(functions);
1838
1839         functions->UpdateState = r300InvalidateState;
1840         functions->AlphaFunc = r300AlphaFunc;
1841         functions->BlendColor = r300BlendColor;
1842         functions->BlendEquationSeparate = r300BlendEquationSeparate;
1843         functions->BlendFuncSeparate = r300BlendFuncSeparate;
1844         functions->Enable = r300Enable;
1845         functions->ColorMask = r300ColorMask;
1846         functions->DepthFunc = r300DepthFunc;
1847         functions->DepthMask = r300DepthMask;
1848         functions->CullFace = r300CullFace;
1849         functions->FrontFace = r300FrontFace;
1850
1851         /* Stencil related */
1852         functions->ClearStencil = r300ClearStencil;
1853         functions->StencilFunc = r300StencilFunc;
1854         functions->StencilMask = r300StencilMask;
1855         functions->StencilOp = r300StencilOp;
1856
1857         /* Viewport related */
1858         functions->Viewport = r300Viewport;
1859         functions->DepthRange = r300DepthRange;
1860         functions->PointSize = r300PointSize;
1861 }
1862