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 "pipe/p_format.h"
  28
  29 #include "r300_reg.h"
  30
  31 /* Some maths. These should probably find their way to u_math, if needed. */
  32
  33 static INLINE int pack_float_16_6x(float f) {
  34     return ((int)(f * 6.0) & 0xffff);
  35 }
  36
  37 /* Blend state. */
  38
  39 static INLINE uint32_t r300_translate_blend_function(int blend_func)
  40 {
  41     switch (blend_func) {
  42         case PIPE_BLEND_ADD:
  43             return R300_COMB_FCN_ADD_CLAMP;
  44         case PIPE_BLEND_SUBTRACT:
  45             return R300_COMB_FCN_SUB_CLAMP;
  46         case PIPE_BLEND_REVERSE_SUBTRACT:
  47             return R300_COMB_FCN_RSUB_CLAMP;
  48         case PIPE_BLEND_MIN:
  49             return R300_COMB_FCN_MIN;
  50         case PIPE_BLEND_MAX:
  51             return R300_COMB_FCN_MAX;
  52         default:
  53             debug_printf("r300: Unknown blend function %d\n", blend_func);
  54             break;
  55     }
  56     return 0;
  57 }
  58
  59 /* XXX we can also offer the D3D versions of some of these... */
  60 static INLINE uint32_t r300_translate_blend_factor(int blend_fact)
  61 {
  62     switch (blend_fact) {
  63         case PIPE_BLENDFACTOR_ONE:
  64             return R300_BLEND_GL_ONE;
  65         case PIPE_BLENDFACTOR_SRC_COLOR:
  66             return R300_BLEND_GL_SRC_COLOR;
  67         case PIPE_BLENDFACTOR_SRC_ALPHA:
  68             return R300_BLEND_GL_SRC_ALPHA;
  69         case PIPE_BLENDFACTOR_DST_ALPHA:
  70             return R300_BLEND_GL_DST_ALPHA;
  71         case PIPE_BLENDFACTOR_DST_COLOR:
  72             return R300_BLEND_GL_DST_COLOR;
  73         case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
  74             return R300_BLEND_GL_SRC_ALPHA_SATURATE;
  75         case PIPE_BLENDFACTOR_CONST_COLOR:
  76             return R300_BLEND_GL_CONST_COLOR;
  77         case PIPE_BLENDFACTOR_CONST_ALPHA:
  78             return R300_BLEND_GL_CONST_ALPHA;
  79         /* XXX WTF are these?
  80         case PIPE_BLENDFACTOR_SRC1_COLOR:
  81         case PIPE_BLENDFACTOR_SRC1_ALPHA: */
  82         case PIPE_BLENDFACTOR_ZERO:
  83             return R300_BLEND_GL_ZERO;
  84         case PIPE_BLENDFACTOR_INV_SRC_COLOR:
  85             return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
  86         case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
  87             return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
  88         case PIPE_BLENDFACTOR_INV_DST_ALPHA:
  89             return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
  90         case PIPE_BLENDFACTOR_INV_DST_COLOR:
  91             return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
  92         case PIPE_BLENDFACTOR_INV_CONST_COLOR:
  93             return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
  94         case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
  95             return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
  96         /* XXX see above
  97         case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
  98         case PIPE_BLENDFACTOR_INV_SRC1_ALPHA: */
  99         default:
 100             debug_printf("r300: Unknown blend factor %d\n", blend_fact);
 101             break;
 102     }
 103     return 0;
 104 }
 105
 106 /* DSA state. */
 107
 108 static INLINE uint32_t r300_translate_depth_stencil_function(int zs_func)
 109 {
 110     switch (zs_func) {
 111         case PIPE_FUNC_NEVER:
 112             return R300_ZS_NEVER;
 113         case PIPE_FUNC_LESS:
 114             return R300_ZS_LESS;
 115         case PIPE_FUNC_EQUAL:
 116             return R300_ZS_EQUAL;
 117         case PIPE_FUNC_LEQUAL:
 118             return R300_ZS_LEQUAL;
 119         case PIPE_FUNC_GREATER:
 120             return R300_ZS_GREATER;
 121         case PIPE_FUNC_NOTEQUAL:
 122             return R300_ZS_NOTEQUAL;
 123         case PIPE_FUNC_GEQUAL:
 124             return R300_ZS_GEQUAL;
 125         case PIPE_FUNC_ALWAYS:
 126             return R300_ZS_ALWAYS;
 127         default:
 128             debug_printf("r300: Unknown depth/stencil function %d\n",
 129                 zs_func);
 130             break;
 131     }
 132     return 0;
 133 }
 134
 135 static INLINE uint32_t r300_translate_stencil_op(int s_op)
 136 {
 137     switch (s_op) {
 138         case PIPE_STENCIL_OP_KEEP:
 139             return R300_ZS_KEEP;
 140         case PIPE_STENCIL_OP_ZERO:
 141             return R300_ZS_ZERO;
 142         case PIPE_STENCIL_OP_REPLACE:
 143             return R300_ZS_REPLACE;
 144         case PIPE_STENCIL_OP_INCR:
 145             return R300_ZS_INCR;
 146         case PIPE_STENCIL_OP_DECR:
 147             return R300_ZS_DECR;
 148         case PIPE_STENCIL_OP_INCR_WRAP:
 149             return R300_ZS_INCR_WRAP;
 150         case PIPE_STENCIL_OP_DECR_WRAP:
 151             return R300_ZS_DECR_WRAP;
 152         case PIPE_STENCIL_OP_INVERT:
 153             return R300_ZS_INVERT;
 154         default:
 155             debug_printf("r300: Unknown stencil op %d", s_op);
 156             break;
 157     }
 158     return 0;
 159 }
 160
 161 static INLINE uint32_t r300_translate_alpha_function(int alpha_func)
 162 {
 163     switch (alpha_func) {
 164         case PIPE_FUNC_NEVER:
 165             return R300_FG_ALPHA_FUNC_NEVER;
 166         case PIPE_FUNC_LESS:
 167             return R300_FG_ALPHA_FUNC_LESS;
 168         case PIPE_FUNC_EQUAL:
 169             return R300_FG_ALPHA_FUNC_EQUAL;
 170         case PIPE_FUNC_LEQUAL:
 171             return R300_FG_ALPHA_FUNC_LE;
 172         case PIPE_FUNC_GREATER:
 173             return R300_FG_ALPHA_FUNC_GREATER;
 174         case PIPE_FUNC_NOTEQUAL:
 175             return R300_FG_ALPHA_FUNC_NOTEQUAL;
 176         case PIPE_FUNC_GEQUAL:
 177             return R300_FG_ALPHA_FUNC_GE;
 178         case PIPE_FUNC_ALWAYS:
 179             return R300_FG_ALPHA_FUNC_ALWAYS;
 180         default:
 181             debug_printf("r300: Unknown alpha function %d", alpha_func);
 182             break;
 183     }
 184     return 0;
 185 }
 186
 187 /* Texture sampler state. */
 188
 189 static INLINE uint32_t r300_translate_wrap(int wrap)
 190 {
 191     switch (wrap) {
 192         case PIPE_TEX_WRAP_REPEAT:
 193             return R300_TX_REPEAT;
 194         case PIPE_TEX_WRAP_CLAMP:
 195             return R300_TX_CLAMP;
 196         case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
 197             return R300_TX_CLAMP_TO_EDGE;
 198         case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
 199             return R300_TX_CLAMP_TO_BORDER;
 200         case PIPE_TEX_WRAP_MIRROR_REPEAT:
 201             return R300_TX_REPEAT | R300_TX_MIRRORED;
 202         case PIPE_TEX_WRAP_MIRROR_CLAMP:
 203             return R300_TX_CLAMP | R300_TX_MIRRORED;
 204         case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
 205             return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
 206         case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
 207             return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
 208         default:
 209             debug_printf("r300: Unknown texture wrap %d", wrap);
 210             return 0;
 211     }
 212 }
 213
 214 static INLINE uint32_t r300_translate_tex_filters(int min, int mag, int mip)
 215 {
 216     uint32_t retval = 0;
 217     switch (min) {
 218         case PIPE_TEX_FILTER_NEAREST:
 219             retval |= R300_TX_MIN_FILTER_NEAREST;
 220             break;
 221         case PIPE_TEX_FILTER_LINEAR:
 222             retval |= R300_TX_MIN_FILTER_LINEAR;
 223             break;
 224         case PIPE_TEX_FILTER_ANISO:
 225             retval |= R300_TX_MIN_FILTER_ANISO;
 226             break;
 227         default:
 228             debug_printf("r300: Unknown texture filter %d\n", min);
 229             break;
 230     }
 231     switch (mag) {
 232         case PIPE_TEX_FILTER_NEAREST:
 233             retval |= R300_TX_MAG_FILTER_NEAREST;
 234             break;
 235         case PIPE_TEX_FILTER_LINEAR:
 236             retval |= R300_TX_MAG_FILTER_LINEAR;
 237             break;
 238         case PIPE_TEX_FILTER_ANISO:
 239             retval |= R300_TX_MAG_FILTER_ANISO;
 240             break;
 241         default:
 242             debug_printf("r300: Unknown texture filter %d\n", mag);
 243             break;
 244     }
 245     switch (mip) {
 246         case PIPE_TEX_MIPFILTER_NONE:
 247             retval |= R300_TX_MIN_FILTER_MIP_NONE;
 248             break;
 249         case PIPE_TEX_MIPFILTER_NEAREST:
 250             retval |= R300_TX_MIN_FILTER_MIP_NEAREST;
 251             break;
 252         case PIPE_TEX_MIPFILTER_LINEAR:
 253             retval |= R300_TX_MIN_FILTER_MIP_LINEAR;
 254             break;
 255         default:
 256             debug_printf("r300: Unknown texture filter %d\n", mip);
 257             break;
 258     }
 259
 260     return retval;
 261 }
 262
 263 static INLINE uint32_t r300_anisotropy(float max_aniso)
 264 {
 265     if (max_aniso >= 16.0f) {
 266         return R300_TX_MAX_ANISO_16_TO_1;
 267     } else if (max_aniso >= 8.0f) {
 268         return R300_TX_MAX_ANISO_8_TO_1;
 269     } else if (max_aniso >= 4.0f) {
 270         return R300_TX_MAX_ANISO_4_TO_1;
 271     } else if (max_aniso >= 2.0f) {
 272         return R300_TX_MAX_ANISO_2_TO_1;
 273     } else {
 274         return R300_TX_MAX_ANISO_1_TO_1;
 275     }
 276 }
 277
 278 /* Buffer formats. */
 279
 280 static INLINE uint32_t r300_translate_colorformat(enum pipe_format format)
 281 {
 282     switch (format) {
 283         /* 8-bit buffers */
 284         case PIPE_FORMAT_I8_UNORM:
 285             return R300_COLOR_FORMAT_I8;
 286         /* 16-bit buffers */
 287         case PIPE_FORMAT_R5G6B5_UNORM:
 288             return R300_COLOR_FORMAT_RGB565;
 289         case PIPE_FORMAT_A1R5G5B5_UNORM:
 290             return R300_COLOR_FORMAT_ARGB1555;
 291         case PIPE_FORMAT_A4R4G4B4_UNORM:
 292             return R300_COLOR_FORMAT_ARGB4444;
 293         /* 32-bit buffers */
 294         case PIPE_FORMAT_A8R8G8B8_UNORM:
 295         case PIPE_FORMAT_Z24S8_UNORM:
 296             return R300_COLOR_FORMAT_ARGB8888;
 297         /* XXX Not in pipe_format
 298         case PIPE_FORMAT_A32R32G32B32:
 299             return R300_COLOR_FORMAT_ARGB32323232;
 300         case PIPE_FORMAT_A16R16G16B16:
 301             return R300_COLOR_FORMAT_ARGB16161616;
 302         case PIPE_FORMAT_A10R10G10B10_UNORM:
 303             return R500_COLOR_FORMAT_ARGB10101010;
 304         case PIPE_FORMAT_A2R10G10B10_UNORM:
 305             return R500_COLOR_FORMAT_ARGB2101010;
 306         case PIPE_FORMAT_I10_UNORM:
 307             return R500_COLOR_FORMAT_I10; */
 308         default:
 309             debug_printf("r300: Implementation error: "
 310                 "Got unsupported color format %s in %s\n",
 311                 pf_name(format), __FUNCTION__);
 312             break;
 313     }
 314     return 0;
 315 }
 316
 317 static INLINE uint32_t r300_translate_zsformat(enum pipe_format format)
 318 {
 319     switch (format) {
 320         /* 16-bit depth, no stencil */
 321         case PIPE_FORMAT_Z16_UNORM:
 322             return R300_DEPTHFORMAT_16BIT_INT_Z;
 323         /* 24-bit depth, 8-bit stencil */
 324         case PIPE_FORMAT_Z24S8_UNORM:
 325             return R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL;
 326         default:
 327             debug_printf("r300: Implementation error: "
 328                 "Got unsupported ZS format %s in %s\n",
 329                 pf_name(format), __FUNCTION__);
 330             break;
 331     }
 332     return 0;
 333 }
 334
 335 /* Translate pipe_format into US_OUT_FMT.
 336  * Note that formats are stored from C3 to C0. */
 337 static INLINE uint32_t r300_translate_out_fmt(enum pipe_format format)
 338 {
 339     switch (format) {
 340         case PIPE_FORMAT_A8R8G8B8_UNORM:
 341         case PIPE_FORMAT_Z24S8_UNORM:
 342             return R300_US_OUT_FMT_C4_8 |
 343                 R300_C0_SEL_B | R300_C1_SEL_G |
 344                 R300_C2_SEL_R | R300_C3_SEL_A;
 345         default:
 346             debug_printf("r300: Implementation error: "
 347                 "Got unsupported output format %s in %s\n",
 348                 pf_name(format), __FUNCTION__);
 349             return R300_US_OUT_FMT_UNUSED;
 350     }
 351     return 0;
 352 }
 353
 354 /* Non-CSO state. (For now.) */
 355
 356 static INLINE uint32_t translate_vertex_data_type(int type) {
 357     switch (type) {
 358         case EMIT_1F:
 359         case EMIT_1F_PSIZE:
 360             return R300_DATA_TYPE_FLOAT_1;
 361             break;
 362         case EMIT_2F:
 363             return R300_DATA_TYPE_FLOAT_2;
 364             break;
 365         case EMIT_3F:
 366             return R300_DATA_TYPE_FLOAT_3;
 367             break;
 368         case EMIT_4F:
 369             return R300_DATA_TYPE_FLOAT_4;
 370             break;
 371         case EMIT_4UB:
 372             return R300_DATA_TYPE_BYTE;
 373             break;
 374         default:
 375             debug_printf("r300: Implementation error: "
 376                     "Bad vertex data type!\n");
 377             assert(0);
 378             break;
 379     }
 380
 381     return 0;
 382 }
 383
 384 #endif /* R300_STATE_INLINES_H */