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_CULL_FACE:
 475                 r300UpdateCulling(ctx);
 476                 break;
 477
 478         default:
 479                 radeonEnable(ctx, cap, state);
 480                 return;
 481         }
 482 }
 483
 484
 485 /**
 486  * Change the culling mode.
 487  *
 488  * \note Mesa already filters redundant calls to this function.
 489  */
 490 static void r300CullFace(GLcontext* ctx, GLenum mode)
 491 {
 492         (void)mode;
 493
 494         r300UpdateCulling(ctx);
 495 }
 496
 497
 498 /**
 499  * Change the polygon orientation.
 500  *
 501  * \note Mesa already filters redundant calls to this function.
 502  */
 503 static void r300FrontFace(GLcontext* ctx, GLenum mode)
 504 {
 505         (void)mode;
 506
 507         r300UpdateCulling(ctx);
 508 }
 509
 510
 511 /**
 512  * Change the depth testing function.
 513  *
 514  * \note Mesa already filters redundant calls to this function.
 515  */
 516 static void r300DepthFunc(GLcontext* ctx, GLenum func)
 517 {
 518         r300ContextPtr r300 = R300_CONTEXT(ctx);
 519
 520         R300_STATECHANGE(r300, zs);
 521
 522         r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
 523
 524         switch(func) {
 525         case GL_NEVER:
 526                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NEVER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 527                 break;
 528         case GL_LESS:
 529                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LESS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 530                 break;
 531         case GL_EQUAL:
 532                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_EQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 533                 break;
 534         case GL_LEQUAL:
 535                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 536                 break;
 537         case GL_GREATER:
 538                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GREATER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 539                 break;
 540         case GL_NOTEQUAL:
 541                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NOTEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 542                 break;
 543         case GL_GEQUAL:
 544                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 545                 break;
 546         case GL_ALWAYS:
 547                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_ALWAYS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 548                 break;
 549         }
 550
 551         fprintf(stderr, "ZS_CNTL_1=%08x\n", r300->hw.zs.cmd[R300_ZS_CNTL_1]);
 552 }
 553
 554
 555 /**
 556  * Enable/Disable depth writing.
 557  *
 558  * \note Mesa already filters redundant calls to this function.
 559  */
 560 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
 561 {
 562         r300ContextPtr r300 = R300_CONTEXT(ctx);
 563
 564         if (!ctx->Depth.Test)
 565                 return;
 566
 567         R300_STATECHANGE(r300, zs);
 568         r300->hw.zs.cmd[R300_ZS_CNTL_0] = mask
 569                 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
 570 }
 571
 572
 573 /**
 574  * Handle glColorMask()
 575  */
 576 static void r300ColorMask(GLcontext* ctx,
 577                           GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 578 {
 579         r300ContextPtr r300 = R300_CONTEXT(ctx);
 580         int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
 581
 582         if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
 583                 R300_STATECHANGE(r300, cmk);
 584                 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
 585         }
 586 }
 587
 588 /* =============================================================
 589  * Point state
 590  */
 591 static void r300PointSize(GLcontext * ctx, GLfloat size)
 592 {
 593         r300ContextPtr r300 = R300_CONTEXT(ctx);
 594
 595         /* This might need fixing later */
 596         R300_STATECHANGE(r300, vps);
 597         r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
 598 }
 599
 600 /* =============================================================
 601  * Window position and viewport transformation
 602  */
 603
 604 /*
 605  * To correctly position primitives:
 606  */
 607 #define SUBPIXEL_X 0.125
 608 #define SUBPIXEL_Y 0.125
 609
 610 void r300UpdateWindow(GLcontext * ctx)
 611 {
 612         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 613         __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
 614         GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
 615         GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
 616         const GLfloat *v = ctx->Viewport._WindowMap.m;
 617
 618         GLfloat sx = v[MAT_SX];
 619         GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
 620         GLfloat sy = -v[MAT_SY];
 621         GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
 622         GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
 623         GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
 624
 625         R300_FIREVERTICES(rmesa);
 626         R300_STATECHANGE(rmesa, vpt);
 627
 628         rmesa->hw.vpt.cmd[R300_VPT_XSCALE]  = r300PackFloat32(sx);
 629         rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
 630         rmesa->hw.vpt.cmd[R300_VPT_YSCALE]  = r300PackFloat32(sy);
 631         rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
 632         rmesa->hw.vpt.cmd[R300_VPT_ZSCALE]  = r300PackFloat32(sz);
 633         rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
 634 }
 635
 636 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
 637                          GLsizei width, GLsizei height)
 638 {
 639         /* Don't pipeline viewport changes, conflict with window offset
 640          * setting below.  Could apply deltas to rescue pipelined viewport
 641          * values, or keep the originals hanging around.
 642          */
 643         R200_FIREVERTICES(R200_CONTEXT(ctx));
 644         r300UpdateWindow(ctx);
 645 }
 646
 647 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
 648 {
 649         r300UpdateWindow(ctx);
 650 }
 651
 652 /* Routing and texture-related */
 653
 654 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
 655 {
 656         int i, count=0,reg=0;
 657         GLuint dw, mask;
 658         TNLcontext *tnl = TNL_CONTEXT(ctx);
 659         struct vertex_buffer *VB = &tnl->vb;
 660         r300ContextPtr r300 = R300_CONTEXT(ctx);
 661
 662
 663         /* Stage 1 - input to VAP */
 664
 665         /* Assign register number automatically, retaining it in rmesa->state.reg */
 666
 667         /* Note: immediate vertex data includes all coordinates.
 668         To save bandwidth use either VBUF or state-based vertex generation */
 669
 670         #define CONFIGURE_AOS(v, o, r, f) \
 671                 {\
 672                 if(immediate){ \
 673                         r300->state.aos[count].element_size=4; \
 674                         r300->state.aos[count].stride=4; \
 675                         r300->state.aos[count].ncomponents=4; \
 676                         } else { \
 677                         r300->state.aos[count].element_size=v->size; \
 678                         r300->state.aos[count].stride=v->size; \
 679                         r300->state.aos[count].ncomponents=v->size; \
 680                         } \
 681                 r300->state.aos[count].offset=o; \
 682                 r300->state.aos[count].reg=reg; \
 683                 r300->state.aos[count].format=(f); \
 684                 r300->state.vap_reg.r=reg; \
 685                 count++; \
 686                 reg++; \
 687                 }
 688
 689                 /* All offsets are 0 - for use by immediate mode.
 690                 Should change later to handle vertex buffers */
 691         CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
 692         CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
 693         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 694                 if(ctx->Texture.Unit[i].Enabled)
 695                         CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
 696
 697         r300->state.aos_count=count;
 698
 699         if (RADEON_DEBUG & DEBUG_STATE)
 700                 fprintf(stderr, "aos_count=%d\n", count);
 701
 702         if(count>R300_MAX_AOS_ARRAYS){
 703                 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
 704                 exit(-1);
 705                 }
 706
 707         /* Implement AOS */
 708
 709         /* setup INPUT_ROUTE */
 710         R300_STATECHANGE(r300, vir[0]);
 711         for(i=0;i+1<count;i+=2){
 712                 dw=(r300->state.aos[i].ncomponents-1)
 713                 | ((r300->state.aos[i].reg)<<8)
 714                 | (r300->state.aos[i].format<<14)
 715                 | (((r300->state.aos[i+1].ncomponents-1)
 716                 | ((r300->state.aos[i+1].reg)<<8)
 717                 | (r300->state.aos[i+1].format<<14))<<16);
 718
 719                 if(i+2==count){
 720                         dw|=(1<<(13+16));
 721                         }
 722                 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
 723                 }
 724         if(count & 1){
 725                 dw=(r300->state.aos[count-1].ncomponents-1)
 726                 | (r300->state.aos[count-1].format<<14)
 727                 | ((r300->state.aos[count-1].reg)<<8)
 728                 | (1<<13);
 729                 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
 730                 //fprintf(stderr, "vir0 dw=%08x\n", dw);
 731                 }
 732         /* Set the rest of INPUT_ROUTE_0 to 0 */
 733         //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
 734         ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
 735
 736
 737         /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
 738         #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
 739                 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
 740                 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
 741                 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
 742
 743         #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
 744                 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
 745                 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
 746                 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
 747
 748         R300_STATECHANGE(r300, vir[1]);
 749
 750         for(i=0;i+1<count;i+=2){
 751                 /* do i first.. */
 752                 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
 753                 dw=(ALL_COMPONENTS & mask)
 754                 | (ALL_DEFAULT & ~mask)
 755                 | R300_INPUT_ROUTE_ENABLE;
 756
 757                 /* i+1 */
 758                 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
 759                 dw|=(
 760                 (ALL_COMPONENTS & mask)
 761                 | (ALL_DEFAULT & ~mask)
 762                 | R300_INPUT_ROUTE_ENABLE
 763                 )<<16;
 764
 765                 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
 766                 }
 767         if(count & 1){
 768                 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
 769                 dw=(ALL_COMPONENTS & mask)
 770                 | (ALL_DEFAULT & ~mask)
 771                 | R300_INPUT_ROUTE_ENABLE;
 772                 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
 773                 //fprintf(stderr, "vir1 dw=%08x\n", dw);
 774                 }
 775         /* Set the rest of INPUT_ROUTE_1 to 0 */
 776         //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
 777         ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
 778
 779         /* Set up input_cntl */
 780
 781         R300_STATECHANGE(r300, vic);
 782         r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555;  /* Hard coded value, no idea what it means */
 783
 784         r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
 785                                         | R300_INPUT_CNTL_COLOR;
 786
 787         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 788                 if(ctx->Texture.Unit[i].Enabled)
 789                         r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
 790
 791         /* Stage 3: VAP output */
 792         R300_STATECHANGE(r300, vof);
 793         r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
 794                                         | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
 795
 796         r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
 797         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 798                 if(ctx->Texture.Unit[i].Enabled)
 799                         r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
 800
 801 }
 802
 803 static r300TexObj default_tex_obj={
 804         filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
 805         pitch: 0x8000,
 806         size: (0xff << R300_TX_WIDTHMASK_SHIFT)
 807               | (0xff << R300_TX_HEIGHTMASK_SHIFT)
 808               | (0x8 << R300_TX_SIZE_SHIFT),
 809         format: 0x88a0c,
 810         offset: 0x0,
 811         unknown4: 0x0,
 812         unknown5: 0x0
 813         };
 814
 815         /* there is probably a system to these value, but, for now,
 816            we just try by hand */
 817
 818 static int inline translate_src(int src)
 819 {
 820         switch (src) {
 821         case GL_TEXTURE:
 822                 return 1;
 823                 break;
 824         case GL_CONSTANT:
 825                 return 2;
 826                 break;
 827         case GL_PRIMARY_COLOR:
 828                 return 3;
 829                 break;
 830         case GL_PREVIOUS:
 831                 return 4;
 832                 break;
 833         case GL_ZERO:
 834                 return 5;
 835                 break;
 836         case GL_ONE:
 837                 return 6;
 838                 break;
 839         default:
 840                 return 0;
 841         }
 842 }
 843
 844 /* I think 357 and 457 are prime numbers.. wiggle them if you get coincidences */
 845 #define FORMAT_HASH(opRGB, srcRGB, modeRGB, opA, srcA, modeA, format, intFormat)        ( \
 846         (\
 847         ((opRGB)<<30) | ((opA)<<28) | \
 848         ((srcRGB)<< 25) | ((srcA)<<22) | \
 849         ((modeRGB)) \
 850         ) \
 851         ^ ((modeA)*357) \
 852         ^ (((format)) *457) \
 853         ^ ((intFormat) * 7) \
 854         )
 855
 856
 857 static GLuint translate_texture_format(GLcontext *ctx, GLint tex_unit, GLuint format, GLint IntFormat,
 858         struct gl_texture_format *tex_format)
 859 {
 860         const struct gl_texture_unit *texUnit= &ctx->Texture.Unit[tex_unit];
 861         int i=0; /* number of alpha args .. */
 862         GLuint fmt;
 863
 864         #if 0
 865         fprintf(stderr, "_ReallyEnabled=%d EnvMode=%s\n",
 866                 texUnit->_ReallyEnabled,
 867                 _mesa_lookup_enum_by_nr(texUnit->EnvMode));
 868         #endif
 869
 870         if(tex_format==NULL){
 871                 fprintf(stderr, "Aeiii ! tex_format==NULL !!\n");
 872                 return 0;
 873                 }
 874
 875         switch(tex_format->MesaFormat){
 876                 case MESA_FORMAT_RGBA8888:
 877                         return R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8);
 878                 default:
 879                         fprintf(stderr, "Do not know format %s\n", _mesa_lookup_enum_by_nr(tex_format->MesaFormat));
 880                         return 0;
 881                 }
 882
 883         switch(IntFormat){
 884                 case 4:
 885                 case GL_RGBA:
 886                 case GL_RGBA8:
 887                         break;
 888                 case 3:
 889                 case GL_RGB8:
 890                         fmt=R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
 891                         break;
 892                 default:
 893                         return 0;
 894                 }
 895         #if 1
 896         //fmt &= 0x00fff;
 897         //fmt |= ((format) & 0xff00)<<4;
 898         fprintf(stderr, "NumArgsRGB=%d NumArgsA=%d\n",
 899                 texUnit->_CurrentCombine->_NumArgsRGB,
 900                 texUnit->_CurrentCombine->_NumArgsA);
 901
 902         fprintf(stderr, "fmt=%08x\n", fmt);
 903         #endif
 904         return fmt;
 905         /* Size field in format specific first */
 906         switch(FORMAT_HASH(
 907                 texUnit->_CurrentCombine->OperandRGB[i] -GL_SRC_COLOR,
 908                 translate_src(texUnit->_CurrentCombine->SourceRGB[i]),
 909                 texUnit->_CurrentCombine->ModeRGB,
 910                 texUnit->_CurrentCombine->OperandA[i] -GL_SRC_ALPHA,
 911                 translate_src(texUnit->_CurrentCombine->SourceA[i]),
 912                 texUnit->_CurrentCombine->ModeA,
 913                 format,
 914                 IntFormat
 915                 )){
 916         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA):
 917                 /* tested with:
 918                         kfiresaver.kss
 919                         */
 920                 return R300_EASY_TX_FORMAT(X, X, CUT_W, W, W8Z8Y8X8);
 921         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA8):
 922                 /* tested with:
 923                         Quake3demo
 924                         */
 925                 /* Quake3demo -small font on the bottom */
 926                 return fmt;
 927         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, GL_RGBA8):
 928                 /* Quake3demo - mouse cursor*/
 929                 return fmt;
 930         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, 4):
 931                 /* tested with:
 932                         kfiresaver.kss
 933                         */
 934                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
 935         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, 4):
 936                 /* tested with:
 937                         kfiresaver.kss
 938                         kfountain.kss
 939                         */
 940                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
 941         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008847, 3):
 942                 /* tested with
 943                         lesson 06
 944                         lesson 07
 945                         */
 946         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, 0x00000003):
 947                 /* Tested with NeHe lesson 08 */
 948         //case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x0005547, 0):
 949                 /* Can't remember what I tested this with..
 950                    try putting return 0 of you see broken textures which
 951                    are not being complained about */
 952         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00009947, GL_RGB8):
 953         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, GL_RGB8):
 954         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00003347, GL_RGB8):
 955         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, 3):
 956                 /* Tested with:
 957                         Quake3demo
 958                         */
 959                 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
 960         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007847, GL_RGBA8):
 961         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006747, GL_RGBA8):
 962         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006647, GL_RGBA8):
 963         case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, GL_RGBA8):
 964                 /* Tested with:
 965                         Quake3demo
 966                         */
 967                 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
 968         case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, GL_RGBA8):
 969                 return R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) ;
 970         case  FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008845, 0x00008056):
 971                 //return 0;
 972                 fprintf(stderr, "***\n");
 973                 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
 974         }
 975
 976
 977         {
 978                 static int warn_once=1;
 979                 if(warn_once){
 980                         fprintf(stderr, "%s:%s Do not know how to translate texture format - help me !\n",
 981                                 __FILE__, __FUNCTION__);
 982                         warn_once=0;
 983                         }
 984         }
 985                 return 0;
 986 }
 987
 988 void r300_setup_textures(GLcontext *ctx)
 989 {
 990         int i, mtu;
 991         struct r300_tex_obj *t;
 992         r300ContextPtr r300 = R300_CONTEXT(ctx);
 993         int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
 994         struct gl_texture_unit *texUnit;
 995
 996         R300_STATECHANGE(r300, txe);
 997         R300_STATECHANGE(r300, tex.filter);
 998         R300_STATECHANGE(r300, tex.unknown1);
 999         R300_STATECHANGE(r300, tex.size);
1000         R300_STATECHANGE(r300, tex.format);
1001         R300_STATECHANGE(r300, tex.offset);
1002         R300_STATECHANGE(r300, tex.unknown4);
1003         R300_STATECHANGE(r300, tex.unknown5);
1004         R300_STATECHANGE(r300, tex.border_color);
1005
1006         r300->state.texture.tc_count=0;
1007
1008         r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
1009
1010         mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1011         if (RADEON_DEBUG & DEBUG_STATE)
1012                 fprintf(stderr, "mtu=%d\n", mtu);
1013
1014         if(mtu>R300_MAX_TEXTURE_UNITS){
1015                 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1016                         mtu, R300_MAX_TEXTURE_UNITS);
1017                 exit(-1);
1018                 }
1019         for(i=0;i<mtu;i++){
1020                 if(ctx->Texture.Unit[i].Enabled){
1021                         t=r300->state.texture.unit[i].texobj;
1022                         fprintf(stderr, "format=%08x\n", r300->state.texture.unit[i].format);
1023                         r300->state.texture.tc_count++;
1024                         if(t==NULL){
1025                                 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1026                                 //exit(-1);
1027                                 t=&default_tex_obj;
1028                                 }
1029                         if (RADEON_DEBUG & DEBUG_STATE)
1030                                 fprintf(stderr, "Activating texture unit %d\n", i);
1031                         max_texture_unit=i;
1032                         r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1033
1034                         /* Turn off rest of the bits that are wrong. Im going to get rid of this soon, dont worry :) */
1035                         t->filter &= R300_TX_MIN_FILTER_MASK | R300_TX_MAG_FILTER_MASK
1036                                         |R300_TX_WRAP_S_MASK | R300_TX_WRAP_T_MASK |
1037                                         R300_TX_WRAP_Q_MASK | R300_TX_MAX_ANISO_MASK;
1038
1039                         r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=t->filter;
1040
1041                         /* No idea why linear filtered textures shake when puting random data */
1042                         /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1043                         r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1044                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1045                         //fprintf(stderr, "t->format=%08x\n", t->format);
1046                         r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
1047                         r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1048                         r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
1049                         r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0+i]=t->pp_border_color;
1050
1051                         /* We don't know how to set this yet */
1052                         //value from r300_lib.c for RGB24
1053                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x88a0c;
1054                         #if 0
1055                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=translate_texture_format(ctx, i, t->format,
1056                                 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->IntFormat:3,
1057                                 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->TexFormat:NULL);
1058                         #endif
1059
1060                         #if 0
1061                         fprintf(stderr, "Format=%s IntFormat=%08x MesaFormat=%08x BaseFormat=%s IsCompressed=%d Target=%s\n",
1062                                 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->Format),
1063                                 t->base.tObj->Image[0][0]->IntFormat,
1064                                 t->base.tObj->Image[0][0]->TexFormat->MesaFormat,
1065                                 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->TexFormat->BaseFormat),
1066                                 t->base.tObj->Image[0][0]->IsCompressed,
1067                                 _mesa_lookup_enum_by_nr(t->base.tObj->Target));
1068
1069                         fprintf(stderr, "pitch=%08x filter=%08x format=%08x\n", t->pitch, t->filter, r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]);
1070                         fprintf(stderr, "unknown1=%08x size=%08x\n", r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i],
1071                                 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]);
1072                         #endif
1073                         /* Use the code below to quickly find matching texture
1074                            formats. Requires an app that displays the same texture
1075                            repeatedly  */
1076                               #if 0
1077                                 if(r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]==0){
1078                                         static int fmt=0x0;
1079                                         static int k=0;
1080                                         k++;
1081                                         if(k>20){
1082                                                 k=0;
1083                                                 fmt++;
1084                                                 texUnit = &ctx->Texture.Unit[i];
1085                                                 fprintf(stderr, "Want to set FORMAT_HASH(%d, %d, 0x%04x, %d, %d, 0x%04x, 0x%08x, %s(%08x))\n",
1086                                                         texUnit->_CurrentCombine->OperandRGB[0] -GL_SRC_COLOR,
1087                                                         translate_src(texUnit->_CurrentCombine->SourceRGB[0]),
1088                                                         texUnit->_CurrentCombine->ModeRGB,
1089                                                         texUnit->_CurrentCombine->OperandA[0] -GL_SRC_ALPHA,
1090                                                         translate_src(texUnit->_CurrentCombine->SourceA[0]),
1091                                                         texUnit->_CurrentCombine->ModeA,
1092                                                         t->format,
1093                                                         _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->IntFormat),
1094                                                         t->base.tObj->Image[0][0]->IntFormat
1095                                                         );
1096                                                 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);
1097                                                 fprintf(stderr, "\t_ReallyEnabled=%08x EnvMode=%08x IntFormat=%08x\n", texUnit->_ReallyEnabled, texUnit->EnvMode,  t->base.tObj->Image[0][0]->IntFormat);
1098                                                 if(fmt>0xfff){
1099                                                         fmt=0;
1100                                                         }
1101                                                 //sleep(1);
1102                                                 fprintf(stderr, "Now trying format %08x\n",
1103                                                         fmt);
1104                                                 fprintf(stderr, "size=%08x\n", t->size);
1105                                                 }
1106                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=known_formats[fmt];
1107                                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=
1108                                                 R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)  | (fmt<<24);
1109                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x08a0c | (fmt<<16);
1110                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x58a00 | (fmt);
1111                                         //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x53a0c | (fmt<<24);
1112                                         }
1113                               #endif
1114
1115                         }
1116
1117                 }
1118         ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1119         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1120         ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1121         ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1122         ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1123         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1124         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1125         ((drm_r300_cmd_header_t*)r300->hw.tex.border_color.cmd)->unchecked_state.count = max_texture_unit+1;
1126
1127         if (RADEON_DEBUG & DEBUG_STATE)
1128                 fprintf(stderr, "TX_ENABLE: %08x  max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1129 }
1130
1131 void r300_setup_rs_unit(GLcontext *ctx)
1132 {
1133         r300ContextPtr r300 = R300_CONTEXT(ctx);
1134         int i;
1135
1136         /* This needs to be rewritten - it is a hack at best */
1137
1138         R300_STATECHANGE(r300, ri);
1139         R300_STATECHANGE(r300, rc);
1140         R300_STATECHANGE(r300, rr);
1141
1142         for(i = 1; i <= 8; ++i)
1143                 r300->hw.ri.cmd[i] = 0x00d10000;
1144         r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1145         r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1146         r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1147
1148         #if 1
1149         for(i = 2; i <= 8; ++i)
1150                 r300->hw.ri.cmd[i] |= 4;
1151         #endif
1152
1153         for(i = 1; i <= 8; ++i)
1154                 r300->hw.rr.cmd[i] = 0;
1155         /* textures enabled ? */
1156         if(r300->state.texture.tc_count>0){
1157
1158                 /* This code only really works with one set of texture coordinates */
1159
1160                 /* The second constant is needed to get glxgears display anything .. */
1161                 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1162                                 | R300_RS_CNTL_0_UNKNOWN_18
1163                                 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1164                 r300->hw.rc.cmd[2] = 0xc0;
1165
1166
1167                 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1168                 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1169
1170                 } else {
1171
1172                 /* The second constant is needed to get glxgears display anything .. */
1173                 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1174                 r300->hw.rc.cmd[2] = 0;
1175
1176                 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1177                 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1178
1179                 }
1180 }
1181
1182 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1183
1184 #define bump_vpu_count(ptr, new_count)   do{\
1185         drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1186         int _nc=(new_count)/4; \
1187         if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1188         }while(0)
1189
1190 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1191 {
1192         int i;
1193
1194         if(vsf->length==0)return;
1195
1196         if(vsf->length & 0x3){
1197                 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1198                 exit(-1);
1199                 }
1200
1201         switch((dest>>8) & 0xf){
1202         case 0:
1203                 R300_STATECHANGE(r300, vpi);
1204                 for(i=0;i<vsf->length;i++)
1205                         r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1206                 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1207                 break;
1208
1209         case 2:
1210                 R300_STATECHANGE(r300, vpp);
1211                 for(i=0;i<vsf->length;i++)
1212                         r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1213                 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1214                 break;
1215         case 4:
1216                 R300_STATECHANGE(r300, vps);
1217                 for(i=0;i<vsf->length;i++)
1218                         r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1219                 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1220                 break;
1221         default:
1222                 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1223                 exit(-1);
1224         }
1225 }
1226
1227
1228 void r300SetupVertexShader(r300ContextPtr rmesa)
1229 {
1230         GLcontext* ctx = rmesa->radeon.glCtx;
1231
1232         /* Reset state, in case we don't use something */
1233         ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1234         ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1235         ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1236
1237
1238 /* This needs to be replaced by vertex shader generation code */
1239
1240
1241         /* textures enabled ? */
1242         if(rmesa->state.texture.tc_count>0){
1243                 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1244                 } else {
1245                 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1246                 }
1247
1248
1249         rmesa->state.vertex_shader.matrix[0].length=16;
1250         memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1251
1252         setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1253
1254         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1255         #if 0
1256         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1257         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1258
1259         setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1260         setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1261         #endif
1262
1263         #if 0
1264         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1265         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1266         #endif
1267
1268         R300_STATECHANGE(rmesa, pvs);
1269         rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1270                 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1271                 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1272         rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1273                 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1274         rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1275         | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1276
1277         /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1278         so I leave it as a reminder */
1279         #if 0
1280         reg_start(R300_VAP_PVS_WAITIDLE,0);
1281                 e32(0x00000000);
1282         #endif
1283 }
1284
1285 void r300SetupPixelShader(r300ContextPtr rmesa)
1286 {
1287 int i,k;
1288
1289         /* This needs to be replaced by pixel shader generation code */
1290
1291         /* textures enabled ? */
1292         if(rmesa->state.texture.tc_count>0){
1293                 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1294                 } else {
1295                 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1296                 }
1297
1298         R300_STATECHANGE(rmesa, fpt);
1299         for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1300                 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1301         rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1302
1303         #define OUTPUT_FIELD(st, reg, field)  \
1304                 R300_STATECHANGE(rmesa, st); \
1305                 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1306                         rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1307                 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1308
1309         OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1310         OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1311         OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1312         OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1313         #undef OUTPUT_FIELD
1314
1315         R300_STATECHANGE(rmesa, fp);
1316         for(i=0;i<4;i++){
1317                 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1318                 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1319                 | (rmesa->state.pixel_shader.program.node[i].alu_end  << R300_PFS_NODE_ALU_END_SHIFT)
1320                 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1321                 | (rmesa->state.pixel_shader.program.node[i].tex_end  << R300_PFS_NODE_TEX_END_SHIFT)
1322                 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1323                 }
1324
1325                 /*  PFS_CNTL_0 */
1326         rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1327                 (rmesa->state.pixel_shader.program.active_nodes-1)
1328                 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1329                 /* PFS_CNTL_1 */
1330         rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1331                 /* PFS_CNTL_2 */
1332         rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1333                 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1334                 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1335                 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1336                 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1337
1338         R300_STATECHANGE(rmesa, fpp);
1339         for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1340                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1341                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1342                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1343                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1344                 }
1345         rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1346
1347 }
1348
1349 /**
1350  * Called by Mesa after an internal state update.
1351  */
1352 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1353 {
1354         r300ContextPtr r300 = R300_CONTEXT(ctx);
1355
1356         _swrast_InvalidateState(ctx, new_state);
1357         _swsetup_InvalidateState(ctx, new_state);
1358         _ac_InvalidateState(ctx, new_state);
1359         _tnl_InvalidateState(ctx, new_state);
1360         _ae_invalidate_state(ctx, new_state);
1361
1362         /* Go inefficiency! */
1363         r300ResetHwState(r300);
1364 }
1365
1366
1367 /**
1368  * Completely recalculates hardware state based on the Mesa state.
1369  */
1370 void r300ResetHwState(r300ContextPtr r300)
1371 {
1372         GLcontext* ctx = r300->radeon.glCtx;
1373         int i;
1374
1375         if (RADEON_DEBUG & DEBUG_STATE)
1376                 fprintf(stderr, "%s\n", __FUNCTION__);
1377
1378                 /* This is a place to initialize registers which
1379                    have bitfields accessed by different functions
1380                    and not all bits are used */
1381         #if 0
1382         r300->hw.zs.cmd[R300_ZS_CNTL_0] = 0;
1383         r300->hw.zs.cmd[R300_ZS_CNTL_1] = 0;
1384         r300->hw.zs.cmd[R300_ZS_CNTL_2] = 0xffff00;
1385         #endif
1386
1387                 /* go and compute register values from GL state */
1388
1389         r300UpdateWindow(ctx);
1390
1391         r300ColorMask(ctx,
1392                 ctx->Color.ColorMask[RCOMP],
1393                 ctx->Color.ColorMask[GCOMP],
1394                 ctx->Color.ColorMask[BCOMP],
1395                 ctx->Color.ColorMask[ACOMP]);
1396
1397         r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1398         r300DepthMask(ctx, ctx->Depth.Mask);
1399         r300DepthFunc(ctx, ctx->Depth.Func);
1400
1401         r300UpdateCulling(ctx);
1402
1403         r300_setup_routing(ctx, GL_TRUE);
1404
1405         r300UpdateTextureState(ctx);
1406         r300_setup_textures(ctx);
1407         r300_setup_rs_unit(ctx);
1408
1409         r300SetupVertexShader(r300);
1410         r300SetupPixelShader(r300);
1411
1412         r300_set_blend_state(ctx);
1413         r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1414
1415                 /* Initialize magic registers
1416                  TODO : learn what they really do, or get rid of
1417                  those we don't have to touch */
1418         r300->hw.unk2080.cmd[1] = 0x0030045A;
1419
1420         r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1421                                 | R300_VPORT_X_OFFSET_ENA
1422                                 | R300_VPORT_Y_SCALE_ENA
1423                                 | R300_VPORT_Y_OFFSET_ENA
1424                                 | R300_VPORT_Z_SCALE_ENA
1425                                 | R300_VPORT_Z_OFFSET_ENA
1426                                 | R300_VTX_W0_FMT;
1427         r300->hw.vte.cmd[2] = 0x00000008;
1428
1429         r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1430         r300->hw.unk2134.cmd[2] = 0x00000000;
1431
1432         r300->hw.unk2140.cmd[1] = 0x00000000;
1433
1434         #if 0 /* Done in setup routing */
1435         ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1436         r300->hw.vir[0].cmd[1] = 0x21030003;
1437
1438         ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1439         r300->hw.vir[1].cmd[1] = 0xF688F688;
1440
1441         r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1442         r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1443         #endif
1444
1445         r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1446
1447         r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1448
1449         r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1450         r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1451         r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1452         r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1453
1454         if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1455                 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1456         else
1457                 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1458
1459         #if 0
1460         r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1461                                 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1462         r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1463
1464
1465         r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1466         r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1467         r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1468         #endif
1469
1470         r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1471                 | R300_GB_LINE_STUFF_ENABLE
1472                 | R300_GB_TRIANGLE_STUFF_ENABLE;
1473
1474         r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1475         r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1476         if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1477                 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1478                                                         | R300_GB_TILE_PIPE_COUNT_R300
1479                                                         | R300_GB_TILE_SIZE_16;
1480         else
1481                 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1482                                                         | R300_GB_TILE_PIPE_COUNT_RV300
1483                                                         | R300_GB_TILE_SIZE_16;
1484         r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1485         r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1486
1487         //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1488
1489         r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1490         r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1491         r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1492         r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1493
1494         r300->hw.unk4214.cmd[1] = 0x00050005;
1495
1496         r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1497                                              (6 << R300_POINTSIZE_Y_SHIFT);
1498
1499         r300->hw.unk4230.cmd[1] = 0x01800000;
1500         r300->hw.unk4230.cmd[2] = 0x00020006;
1501         r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1502
1503         r300->hw.unk4260.cmd[1] = 0;
1504         r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1505         r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1506
1507         r300->hw.unk4274.cmd[1] = 0x00000002;
1508         r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1509         r300->hw.unk4274.cmd[3] = 0x00000000;
1510         r300->hw.unk4274.cmd[4] = 0x00000000;
1511
1512         r300->hw.unk4288.cmd[1] = 0x00000000;
1513         r300->hw.unk4288.cmd[2] = 0x00000001;
1514         r300->hw.unk4288.cmd[3] = 0x00000000;
1515         r300->hw.unk4288.cmd[4] = 0x00000000;
1516         r300->hw.unk4288.cmd[5] = 0x00000000;
1517
1518         r300->hw.unk42A0.cmd[1] = 0x00000000;
1519
1520         r300->hw.unk42B4.cmd[1] = 0x00000000;
1521
1522         r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1523         r300->hw.unk42C0.cmd[2] = 0x00000000;
1524
1525
1526         r300->hw.unk43A4.cmd[1] = 0x0000001C;
1527         r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1528
1529         r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1530
1531         #if 0
1532         r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1533         r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1534         r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1535         r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1536         r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1537         r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1538         r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1539         #endif
1540
1541         r300->hw.unk46A4.cmd[1] = 0x00001B01;
1542         r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1543         r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1544         r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1545         r300->hw.unk46A4.cmd[5] = 0x00000001;
1546
1547         #if 0
1548         for(i = 1; i <= 64; ++i) {
1549                 /* create NOP instructions */
1550                 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1551                 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1552                 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1553                 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1554         }
1555         #endif
1556
1557         r300->hw.unk4BC0.cmd[1] = 0;
1558
1559         r300->hw.unk4BC8.cmd[1] = 0;
1560         r300->hw.unk4BC8.cmd[2] = 0;
1561         r300->hw.unk4BC8.cmd[3] = 0;
1562
1563         #if 0
1564         r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1565         #endif
1566
1567         r300->hw.unk4BD8.cmd[1] = 0;
1568
1569         r300->hw.unk4E00.cmd[1] = 0;
1570
1571         #if 0
1572         r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1573         r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1574         #endif
1575
1576         r300->hw.unk4E10.cmd[1] = 0;
1577         r300->hw.unk4E10.cmd[2] = 0;
1578         r300->hw.unk4E10.cmd[3] = 0;
1579
1580         r300->hw.cb.cmd[R300_CB_OFFSET] =
1581                 r300->radeon.radeonScreen->backOffset +
1582                 r300->radeon.radeonScreen->fbLocation;
1583         r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1584                 | R300_COLOR_UNKNOWN_22_23;
1585
1586         r300->hw.unk4E50.cmd[1] = 0;
1587         r300->hw.unk4E50.cmd[2] = 0;
1588         r300->hw.unk4E50.cmd[3] = 0;
1589         r300->hw.unk4E50.cmd[4] = 0;
1590         r300->hw.unk4E50.cmd[5] = 0;
1591         r300->hw.unk4E50.cmd[6] = 0;
1592         r300->hw.unk4E50.cmd[7] = 0;
1593         r300->hw.unk4E50.cmd[8] = 0;
1594         r300->hw.unk4E50.cmd[9] = 0;
1595
1596         r300->hw.unk4E88.cmd[1] = 0;
1597
1598         r300->hw.unk4EA0.cmd[1] = 0x00000000;
1599         r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1600
1601         r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1602         r300->hw.unk4F10.cmd[2] = 0x00000000;
1603         r300->hw.unk4F10.cmd[3] = 0x00000003;
1604         r300->hw.unk4F10.cmd[4] = 0x00000000;
1605
1606         r300->hw.zb.cmd[R300_ZB_OFFSET] =
1607                 r300->radeon.radeonScreen->depthOffset +
1608                 r300->radeon.radeonScreen->fbLocation;
1609         r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1610
1611         r300->hw.unk4F28.cmd[1] = 0;
1612
1613         r300->hw.unk4F30.cmd[1] = 0;
1614         r300->hw.unk4F30.cmd[2] = 0;
1615
1616         r300->hw.unk4F44.cmd[1] = 0;
1617
1618         r300->hw.unk4F54.cmd[1] = 0;
1619
1620         #if 0
1621         ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1622         for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1623                 /* MOV t0, t0 */
1624                 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1625                 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1626                 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1627                 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1628         }
1629
1630         ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1631         for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1632                 r300->hw.vpp.cmd[i] = 0;
1633         #endif
1634
1635         r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1636         r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1637         r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1638         r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1639
1640 //END: TODO
1641
1642         r300->hw.all_dirty = GL_TRUE;
1643 }
1644
1645
1646
1647 /**
1648  * Calculate initial hardware state and register state functions.
1649  * Assumes that the command buffer and state atoms have been
1650  * initialized already.
1651  */
1652 void r300InitState(r300ContextPtr r300)
1653 {
1654         GLcontext *ctx = r300->radeon.glCtx;
1655         GLuint depth_fmt;
1656
1657         radeonInitState(&r300->radeon);
1658
1659         switch (ctx->Visual.depthBits) {
1660         case 16:
1661                 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1662                 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1663                 //r300->state.stencil.clear = 0x00000000;
1664                 break;
1665         case 24:
1666                 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1667                 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1668                 //r300->state.stencil.clear = 0xff000000;
1669                 break;
1670         default:
1671                 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1672                         ctx->Visual.depthBits);
1673                 exit(-1);
1674         }
1675
1676         memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1677
1678         r300ResetHwState(r300);
1679 }
1680
1681
1682
1683 /**
1684  * Initialize driver's state callback functions
1685  */
1686 void r300InitStateFuncs(struct dd_function_table* functions)
1687 {
1688         radeonInitStateFuncs(functions);
1689
1690         functions->UpdateState = r300InvalidateState;
1691         functions->AlphaFunc = r300AlphaFunc;
1692         functions->BlendColor = r300BlendColor;
1693         functions->BlendEquationSeparate = r300BlendEquationSeparate;
1694         functions->BlendFuncSeparate = r300BlendFuncSeparate;
1695         functions->Enable = r300Enable;
1696         functions->ColorMask = r300ColorMask;
1697         functions->DepthFunc = r300DepthFunc;
1698         functions->DepthMask = r300DepthMask;
1699         functions->CullFace = r300CullFace;
1700         functions->FrontFace = r300FrontFace;
1701
1702         /* Viewport related */
1703         functions->Viewport = r300Viewport;
1704         functions->DepthRange = r300DepthRange;
1705         functions->PointSize = r300PointSize;
1706 }
1707