src/gallium/drivers/r300/r300_state_inlines.h

   1 /*
   2  * Copyright 2009 Joakim Sindholt <opensource@zhasha.com>
   3  *                Corbin Simpson <MostAwesomeDude@gmail.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  23
  24 #ifndef R300_STATE_INLINES_H
  25 #define R300_STATE_INLINES_H
  26
  27 #include "draw/draw_vertex.h"
  28
  29 #include "pipe/p_format.h"
  30
  31 #include "r300_reg.h"
  32
  33 /* Some maths. These should probably find their way to u_math, if needed. */
  34
  35 static INLINE int pack_float_16_6x(float f) {
  36     return ((int)(f * 6.0) & 0xffff);
  37 }
  38
  39 /* Blend state. */
  40
  41 static INLINE uint32_t r300_translate_blend_function(int blend_func)
  42 {
  43     switch (blend_func) {
  44         case PIPE_BLEND_ADD:
  45             return R300_COMB_FCN_ADD_CLAMP;
  46         case PIPE_BLEND_SUBTRACT:
  47             return R300_COMB_FCN_SUB_CLAMP;
  48         case PIPE_BLEND_REVERSE_SUBTRACT:
  49             return R300_COMB_FCN_RSUB_CLAMP;
  50         case PIPE_BLEND_MIN:
  51             return R300_COMB_FCN_MIN;
  52         case PIPE_BLEND_MAX:
  53             return R300_COMB_FCN_MAX;
  54         default:
  55             debug_printf("r300: Unknown blend function %d\n", blend_func);
  56             assert(0);
  57             break;
  58     }
  59     return 0;
  60 }
  61
  62 /* XXX we can also offer the D3D versions of some of these... */
  63 static INLINE uint32_t r300_translate_blend_factor(int blend_fact)
  64 {
  65     switch (blend_fact) {
  66         case PIPE_BLENDFACTOR_ONE:
  67             return R300_BLEND_GL_ONE;
  68         case PIPE_BLENDFACTOR_SRC_COLOR:
  69             return R300_BLEND_GL_SRC_COLOR;
  70         case PIPE_BLENDFACTOR_SRC_ALPHA:
  71             return R300_BLEND_GL_SRC_ALPHA;
  72         case PIPE_BLENDFACTOR_DST_ALPHA:
  73             return R300_BLEND_GL_DST_ALPHA;
  74         case PIPE_BLENDFACTOR_DST_COLOR:
  75             return R300_BLEND_GL_DST_COLOR;
  76         case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
  77             return R300_BLEND_GL_SRC_ALPHA_SATURATE;
  78         case PIPE_BLENDFACTOR_CONST_COLOR:
  79             return R300_BLEND_GL_CONST_COLOR;
  80         case PIPE_BLENDFACTOR_CONST_ALPHA:
  81             return R300_BLEND_GL_CONST_ALPHA;
  82         /* XXX WTF are these?
  83         case PIPE_BLENDFACTOR_SRC1_COLOR:
  84         case PIPE_BLENDFACTOR_SRC1_ALPHA: */
  85         case PIPE_BLENDFACTOR_ZERO:
  86             return R300_BLEND_GL_ZERO;
  87         case PIPE_BLENDFACTOR_INV_SRC_COLOR:
  88             return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
  89         case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
  90             return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
  91         case PIPE_BLENDFACTOR_INV_DST_ALPHA:
  92             return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
  93         case PIPE_BLENDFACTOR_INV_DST_COLOR:
  94             return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
  95         case PIPE_BLENDFACTOR_INV_CONST_COLOR:
  96             return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
  97         case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
  98             return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
  99         /* XXX see above
 100         case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
 101         case PIPE_BLENDFACTOR_INV_SRC1_ALPHA: */
 102         default:
 103             debug_printf("r300: Unknown blend factor %d\n", blend_fact);
 104             assert(0);
 105             break;
 106     }
 107     return 0;
 108 }
 109
 110 /* DSA state. */
 111
 112 static INLINE uint32_t r300_translate_depth_stencil_function(int zs_func)
 113 {
 114     switch (zs_func) {
 115         case PIPE_FUNC_NEVER:
 116             return R300_ZS_NEVER;
 117         case PIPE_FUNC_LESS:
 118             return R300_ZS_LESS;
 119         case PIPE_FUNC_EQUAL:
 120             return R300_ZS_EQUAL;
 121         case PIPE_FUNC_LEQUAL:
 122             return R300_ZS_LEQUAL;
 123         case PIPE_FUNC_GREATER:
 124             return R300_ZS_GREATER;
 125         case PIPE_FUNC_NOTEQUAL:
 126             return R300_ZS_NOTEQUAL;
 127         case PIPE_FUNC_GEQUAL:
 128             return R300_ZS_GEQUAL;
 129         case PIPE_FUNC_ALWAYS:
 130             return R300_ZS_ALWAYS;
 131         default:
 132             debug_printf("r300: Unknown depth/stencil function %d\n",
 133                 zs_func);
 134             assert(0);
 135             break;
 136     }
 137     return 0;
 138 }
 139
 140 static INLINE uint32_t r300_translate_stencil_op(int s_op)
 141 {
 142     switch (s_op) {
 143         case PIPE_STENCIL_OP_KEEP:
 144             return R300_ZS_KEEP;
 145         case PIPE_STENCIL_OP_ZERO:
 146             return R300_ZS_ZERO;
 147         case PIPE_STENCIL_OP_REPLACE:
 148             return R300_ZS_REPLACE;
 149         case PIPE_STENCIL_OP_INCR:
 150             return R300_ZS_INCR;
 151         case PIPE_STENCIL_OP_DECR:
 152             return R300_ZS_DECR;
 153         case PIPE_STENCIL_OP_INCR_WRAP:
 154             return R300_ZS_INCR_WRAP;
 155         case PIPE_STENCIL_OP_DECR_WRAP:
 156             return R300_ZS_DECR_WRAP;
 157         case PIPE_STENCIL_OP_INVERT:
 158             return R300_ZS_INVERT;
 159         default:
 160             debug_printf("r300: Unknown stencil op %d", s_op);
 161             assert(0);
 162             break;
 163     }
 164     return 0;
 165 }
 166
 167 static INLINE uint32_t r300_translate_alpha_function(int alpha_func)
 168 {
 169     switch (alpha_func) {
 170         case PIPE_FUNC_NEVER:
 171             return R300_FG_ALPHA_FUNC_NEVER;
 172         case PIPE_FUNC_LESS:
 173             return R300_FG_ALPHA_FUNC_LESS;
 174         case PIPE_FUNC_EQUAL:
 175             return R300_FG_ALPHA_FUNC_EQUAL;
 176         case PIPE_FUNC_LEQUAL:
 177             return R300_FG_ALPHA_FUNC_LE;
 178         case PIPE_FUNC_GREATER:
 179             return R300_FG_ALPHA_FUNC_GREATER;
 180         case PIPE_FUNC_NOTEQUAL:
 181             return R300_FG_ALPHA_FUNC_NOTEQUAL;
 182         case PIPE_FUNC_GEQUAL:
 183             return R300_FG_ALPHA_FUNC_GE;
 184         case PIPE_FUNC_ALWAYS:
 185             return R300_FG_ALPHA_FUNC_ALWAYS;
 186         default:
 187             debug_printf("r300: Unknown alpha function %d", alpha_func);
 188             assert(0);
 189             break;
 190     }
 191     return 0;
 192 }
 193
 194 /* Texture sampler state. */
 195
 196 static INLINE uint32_t r300_translate_wrap(int wrap)
 197 {
 198     switch (wrap) {
 199         case PIPE_TEX_WRAP_REPEAT:
 200             return R300_TX_REPEAT;
 201         case PIPE_TEX_WRAP_CLAMP:
 202             return R300_TX_CLAMP;
 203         case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
 204             return R300_TX_CLAMP_TO_EDGE;
 205         case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
 206             return R300_TX_CLAMP_TO_BORDER;
 207         case PIPE_TEX_WRAP_MIRROR_REPEAT:
 208             return R300_TX_REPEAT | R300_TX_MIRRORED;
 209         case PIPE_TEX_WRAP_MIRROR_CLAMP:
 210             return R300_TX_CLAMP | R300_TX_MIRRORED;
 211         case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
 212             return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
 213         case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
 214             return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
 215         default:
 216             debug_printf("r300: Unknown texture wrap %d", wrap);
 217             assert(0);
 218             return 0;
 219     }
 220 }
 221
 222 static INLINE uint32_t r300_translate_tex_filters(int min, int mag, int mip)
 223 {
 224     uint32_t retval = 0;
 225     switch (min) {
 226         case PIPE_TEX_FILTER_NEAREST:
 227             retval |= R300_TX_MIN_FILTER_NEAREST;
 228             break;
 229         case PIPE_TEX_FILTER_LINEAR:
 230             retval |= R300_TX_MIN_FILTER_LINEAR;
 231             break;
 232         case PIPE_TEX_FILTER_ANISO:
 233             retval |= R300_TX_MIN_FILTER_ANISO;
 234             break;
 235         default:
 236             debug_printf("r300: Unknown texture filter %d\n", min);
 237             assert(0);
 238             break;
 239     }
 240     switch (mag) {
 241         case PIPE_TEX_FILTER_NEAREST:
 242             retval |= R300_TX_MAG_FILTER_NEAREST;
 243             break;
 244         case PIPE_TEX_FILTER_LINEAR:
 245             retval |= R300_TX_MAG_FILTER_LINEAR;
 246             break;
 247         case PIPE_TEX_FILTER_ANISO:
 248             retval |= R300_TX_MAG_FILTER_ANISO;
 249             break;
 250         default:
 251             debug_printf("r300: Unknown texture filter %d\n", mag);
 252             assert(0);
 253             break;
 254     }
 255     switch (mip) {
 256         case PIPE_TEX_MIPFILTER_NONE:
 257             retval |= R300_TX_MIN_FILTER_MIP_NONE;
 258             break;
 259         case PIPE_TEX_MIPFILTER_NEAREST:
 260             retval |= R300_TX_MIN_FILTER_MIP_NEAREST;
 261             break;
 262         case PIPE_TEX_MIPFILTER_LINEAR:
 263             retval |= R300_TX_MIN_FILTER_MIP_LINEAR;
 264             break;
 265         default:
 266             debug_printf("r300: Unknown texture filter %d\n", mip);
 267             assert(0);
 268             break;
 269     }
 270
 271     return retval;
 272 }
 273
 274 static INLINE uint32_t r300_anisotropy(float max_aniso)
 275 {
 276     if (max_aniso >= 16.0f) {
 277         return R300_TX_MAX_ANISO_16_TO_1;
 278     } else if (max_aniso >= 8.0f) {
 279         return R300_TX_MAX_ANISO_8_TO_1;
 280     } else if (max_aniso >= 4.0f) {
 281         return R300_TX_MAX_ANISO_4_TO_1;
 282     } else if (max_aniso >= 2.0f) {
 283         return R300_TX_MAX_ANISO_2_TO_1;
 284     } else {
 285         return R300_TX_MAX_ANISO_1_TO_1;
 286     }
 287 }
 288
 289 /* Buffer formats. */
 290
 291 /* Colorbuffer formats. This is the unswizzled format of the RB3D block's
 292  * output. For the swizzling of the targets, check the shader's format. */
 293 static INLINE uint32_t r300_translate_colorformat(enum pipe_format format)
 294 {
 295     switch (format) {
 296         /* 8-bit buffers */
 297         case PIPE_FORMAT_I8_UNORM:
 298             return R300_COLOR_FORMAT_I8;
 299         /* 16-bit buffers */
 300         case PIPE_FORMAT_R5G6B5_UNORM:
 301             return R300_COLOR_FORMAT_RGB565;
 302         case PIPE_FORMAT_A1R5G5B5_UNORM:
 303             return R300_COLOR_FORMAT_ARGB1555;
 304         case PIPE_FORMAT_A4R4G4B4_UNORM:
 305             return R300_COLOR_FORMAT_ARGB4444;
 306         /* 32-bit buffers */
 307         case PIPE_FORMAT_A8R8G8B8_UNORM:
 308         case PIPE_FORMAT_X8R8G8B8_UNORM:
 309         case PIPE_FORMAT_R8G8B8A8_UNORM:
 310         case PIPE_FORMAT_R8G8B8X8_UNORM:
 311             return R300_COLOR_FORMAT_ARGB8888;
 312         /* XXX Not in pipe_format
 313         case PIPE_FORMAT_A32R32G32B32:
 314             return R300_COLOR_FORMAT_ARGB32323232;
 315         case PIPE_FORMAT_A16R16G16B16:
 316             return R300_COLOR_FORMAT_ARGB16161616;
 317         case PIPE_FORMAT_A10R10G10B10_UNORM:
 318             return R500_COLOR_FORMAT_ARGB10101010;
 319         case PIPE_FORMAT_A2R10G10B10_UNORM:
 320             return R500_COLOR_FORMAT_ARGB2101010;
 321         case PIPE_FORMAT_I10_UNORM:
 322             return R500_COLOR_FORMAT_I10; */
 323         default:
 324             debug_printf("r300: Implementation error: "
 325                 "Got unsupported color format %s in %s\n",
 326                 pf_name(format), __FUNCTION__);
 327             assert(0);
 328             break;
 329     }
 330     return 0;
 331 }
 332
 333 /* Depthbuffer and stencilbuffer. Thankfully, we only support two flavors. */
 334 static INLINE uint32_t r300_translate_zsformat(enum pipe_format format)
 335 {
 336     switch (format) {
 337         /* 16-bit depth, no stencil */
 338         case PIPE_FORMAT_Z16_UNORM:
 339             return R300_DEPTHFORMAT_16BIT_INT_Z;
 340         /* 24-bit depth, ignored stencil */
 341         case PIPE_FORMAT_Z24X8_UNORM:
 342         /* 24-bit depth, 8-bit stencil */
 343         case PIPE_FORMAT_Z24S8_UNORM:
 344             return R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL;
 345         default:
 346             debug_printf("r300: Implementation error: "
 347                 "Got unsupported ZS format %s in %s\n",
 348                 pf_name(format), __FUNCTION__);
 349             assert(0);
 350             break;
 351     }
 352     return 0;
 353 }
 354
 355 /* Shader output formats. This is essentially the swizzle from the shader
 356  * to the RB3D block.
 357  *
 358  * Note that formats are stored from C3 to C0. */
 359 static INLINE uint32_t r300_translate_out_fmt(enum pipe_format format)
 360 {
 361     switch (format) {
 362         case PIPE_FORMAT_A8R8G8B8_UNORM:
 363         case PIPE_FORMAT_X8R8G8B8_UNORM:
 364         /* XXX */
 365         case PIPE_FORMAT_Z24S8_UNORM:
 366             return R300_US_OUT_FMT_C4_8 |
 367                 R300_C0_SEL_B | R300_C1_SEL_G |
 368                 R300_C2_SEL_R | R300_C3_SEL_A;
 369         case PIPE_FORMAT_R8G8B8A8_UNORM:
 370         case PIPE_FORMAT_R8G8B8X8_UNORM:
 371             return R300_US_OUT_FMT_C4_8 |
 372                 R300_C0_SEL_A | R300_C1_SEL_B |
 373                 R300_C2_SEL_G | R300_C3_SEL_R;
 374         default:
 375             debug_printf("r300: Implementation error: "
 376                 "Got unsupported output format %s in %s\n",
 377                 pf_name(format), __FUNCTION__);
 378             assert(0);
 379             return R300_US_OUT_FMT_UNUSED;
 380     }
 381     return 0;
 382 }
 383
 384 /* Non-CSO state. (For now.) */
 385
 386 static INLINE uint32_t r300_translate_gb_pipes(int pipe_count)
 387 {
 388     switch (pipe_count) {
 389         case 1:
 390             return R300_GB_TILE_PIPE_COUNT_RV300;
 391             break;
 392         case 2:
 393             return R300_GB_TILE_PIPE_COUNT_R300;
 394             break;
 395         case 3:
 396             return R300_GB_TILE_PIPE_COUNT_R420_3P;
 397             break;
 398         case 4:
 399             return R300_GB_TILE_PIPE_COUNT_R420;
 400             break;
 401     }
 402     return 0;
 403 }
 404
 405 /* Utility function to count the number of components in RGBAZS formats.
 406  * XXX should go to util or p_format.h */
 407 static INLINE unsigned pf_component_count(enum pipe_format format) {
 408     unsigned count = 0;
 409
 410     if (pf_layout(format) != PIPE_FORMAT_LAYOUT_RGBAZS) {
 411         return count;
 412     }
 413
 414     if (pf_size_x(format)) {
 415         count++;
 416     }
 417     if (pf_size_y(format)) {
 418         count++;
 419     }
 420     if (pf_size_z(format)) {
 421         count++;
 422     }
 423     if (pf_size_w(format)) {
 424         count++;
 425     }
 426
 427     return count;
 428 }
 429
 430 /* Translate pipe_formats into PSC vertex types. */
 431 static INLINE uint16_t
 432 r300_translate_vertex_data_type(enum pipe_format format) {
 433     uint32_t result = 0;
 434     unsigned components = pf_component_count(format);
 435
 436     if (pf_layout(format) != PIPE_FORMAT_LAYOUT_RGBAZS) {
 437         debug_printf("r300: Bad format %s in %s:%d\n", pf_name(format),
 438             __FUNCTION__, __LINE__);
 439         return 0;
 440     }
 441
 442     switch (pf_type(format)) {
 443         /* Half-floats, floats, doubles */
 444         case PIPE_FORMAT_TYPE_FLOAT:
 445             switch (pf_size_x(format)) {
 446                 case 4:
 447                     result = R300_DATA_TYPE_FLOAT_1 + (components - 1);
 448                     break;
 449                 default:
 450                     debug_printf("r300: Bad format %s in %s:%d\n",
 451                         pf_name(format), __FUNCTION__, __LINE__);
 452                     assert(0);
 453             }
 454             break;
 455         /* Normalized unsigned ints */
 456         case PIPE_FORMAT_TYPE_UNORM:
 457         /* Normalized signed ints */
 458         case PIPE_FORMAT_TYPE_SNORM:
 459         /* Non-normalized unsigned ints */
 460         case PIPE_FORMAT_TYPE_USCALED:
 461         /* Non-normalized signed ints */
 462         case PIPE_FORMAT_TYPE_SSCALED:
 463             switch (pf_size_x(format)) {
 464                 case 1:
 465                     result = R300_DATA_TYPE_BYTE;
 466                     break;
 467                 case 2:
 468                     if (components > 2) {
 469                         result = R300_DATA_TYPE_SHORT_4;
 470                     } else {
 471                         result = R300_DATA_TYPE_SHORT_2;
 472                     }
 473                     break;
 474                 default:
 475                     debug_printf("r300: Bad format %s in %s:%d\n",
 476                         pf_name(format), __FUNCTION__, __LINE__);
 477                     debug_printf("r300: pf_size_x(format) == %d\n",
 478                         pf_size_x(format));
 479                     assert(0);
 480             }
 481             break;
 482         default:
 483             debug_printf("r300: Bad format %s in %s:%d\n",
 484                 pf_name(format), __FUNCTION__, __LINE__);
 485             assert(0);
 486     }
 487
 488     if (pf_type(format) == PIPE_FORMAT_TYPE_SSCALED) {
 489         result |= R300_SIGNED;
 490     } else if (pf_type(format) == PIPE_FORMAT_TYPE_UNORM) {
 491         result |= R300_NORMALIZE;
 492     } else if (pf_type(format) == PIPE_FORMAT_TYPE_SNORM) {
 493         result |= (R300_SIGNED | R300_NORMALIZE);
 494     }
 495
 496     return result;
 497 }
 498
 499 static INLINE uint16_t
 500 r300_translate_vertex_data_swizzle(enum pipe_format format) {
 501
 502     if (pf_layout(format) != PIPE_FORMAT_LAYOUT_RGBAZS) {
 503         debug_printf("r300: Bad format %s in %s:%d\n",
 504             pf_name(format), __FUNCTION__, __LINE__);
 505         return 0;
 506     }
 507
 508     return ((pf_swizzle_x(format) << R300_SWIZZLE_SELECT_X_SHIFT) |
 509         (pf_swizzle_y(format) << R300_SWIZZLE_SELECT_Y_SHIFT) |
 510         (pf_swizzle_z(format) << R300_SWIZZLE_SELECT_Z_SHIFT) |
 511         (pf_swizzle_w(format) << R300_SWIZZLE_SELECT_W_SHIFT) |
 512         (0xf << R300_WRITE_ENA_SHIFT));
 513 }
 514
 515 static INLINE uint32_t
 516 r300_translate_polygon_mode_front(unsigned mode) {
 517     switch (mode)
 518     {
 519         case PIPE_POLYGON_MODE_FILL:
 520             return R300_GA_POLY_MODE_FRONT_PTYPE_TRI;
 521         case PIPE_POLYGON_MODE_LINE:
 522             return R300_GA_POLY_MODE_FRONT_PTYPE_LINE;
 523         case PIPE_POLYGON_MODE_POINT:
 524             return R300_GA_POLY_MODE_FRONT_PTYPE_POINT;
 525
 526         default:
 527             debug_printf("r300: Bad polygon mode %i in %s\n", mode,
 528                 __FUNCTION__);
 529             return R300_GA_POLY_MODE_FRONT_PTYPE_TRI;
 530     }
 531 }
 532
 533 static INLINE uint32_t
 534 r300_translate_polygon_mode_back(unsigned mode) {
 535     switch (mode)
 536     {
 537         case PIPE_POLYGON_MODE_FILL:
 538             return R300_GA_POLY_MODE_BACK_PTYPE_TRI;
 539         case PIPE_POLYGON_MODE_LINE:
 540             return R300_GA_POLY_MODE_BACK_PTYPE_LINE;
 541         case PIPE_POLYGON_MODE_POINT:
 542             return R300_GA_POLY_MODE_BACK_PTYPE_POINT;
 543
 544         default:
 545             debug_printf("r300: Bad polygon mode %i in %s\n", mode,
 546                 __FUNCTION__);
 547             return R300_GA_POLY_MODE_BACK_PTYPE_TRI;
 548     }
 549 }
 550
 551 #endif /* R300_STATE_INLINES_H */