src/gallium/state_trackers/nine/nine_pipe.h

   1 /*
   2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  22
  23 #ifndef _NINE_PIPE_H_
  24 #define _NINE_PIPE_H_
  25
  26 #include "d3d9.h"
  27 #include "pipe/p_format.h"
  28 #include "pipe/p_screen.h"
  29 #include "pipe/p_state.h" /* pipe_box */
  30 #include "util/u_rect.h"
  31 #include "util/u_format.h"
  32 #include "nine_helpers.h"
  33
  34 struct cso_context;
  35
  36 extern const enum pipe_format nine_d3d9_to_pipe_format_map[120];
  37 extern const D3DFORMAT nine_pipe_to_d3d9_format_map[PIPE_FORMAT_COUNT];
  38
  39 void nine_convert_dsa_state(struct cso_context *, const DWORD *);
  40 void nine_convert_rasterizer_state(struct cso_context *, const DWORD *);
  41 void nine_convert_blend_state(struct cso_context *, const DWORD *);
  42 void nine_convert_sampler_state(struct cso_context *, int idx, const DWORD *);
  43
  44 void nine_pipe_context_clear(struct NineDevice9 *);
  45
  46 static INLINE unsigned d3dlock_buffer_to_pipe_transfer_usage(DWORD Flags)
  47 {
  48     unsigned usage;
  49
  50     if (Flags & D3DLOCK_DISCARD)
  51         usage = PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
  52     else
  53     if (Flags & D3DLOCK_READONLY)
  54         usage = PIPE_TRANSFER_READ;
  55     else
  56         usage = PIPE_TRANSFER_READ_WRITE;
  57
  58     if (Flags & D3DLOCK_NOOVERWRITE)
  59         usage = (PIPE_TRANSFER_UNSYNCHRONIZED |
  60                  PIPE_TRANSFER_DISCARD_RANGE | usage) & ~PIPE_TRANSFER_READ;
  61     else
  62     if (Flags & D3DLOCK_DONOTWAIT)
  63         usage |= PIPE_TRANSFER_DONTBLOCK;
  64
  65     /*
  66     if (Flags & D3DLOCK_NO_DIRTY_UPDATE)
  67         usage |= PIPE_TRANSFER_FLUSH_EXPLICIT;
  68     */
  69
  70     return usage;
  71 }
  72
  73 static INLINE void
  74 rect_to_pipe_box(struct pipe_box *dst, const RECT *src)
  75 {
  76     dst->x = src->left;
  77     dst->y = src->top;
  78     dst->z = 0;
  79     dst->width = src->right - src->left;
  80     dst->height = src->bottom - src->top;
  81     dst->depth = 1;
  82 }
  83
  84 static INLINE boolean
  85 rect_to_pipe_box_clamp(struct pipe_box *dst, const RECT *src)
  86 {
  87     rect_to_pipe_box(dst, src);
  88
  89     if (dst->width <= 0 || dst->height <= 0) {
  90         DBG_FLAG(DBG_UNKNOWN, "Warning: NULL box");
  91         dst->width = MAX2(dst->width, 0);
  92         dst->height = MAX2(dst->height, 0);
  93         return TRUE;
  94     }
  95     return FALSE;
  96 }
  97
  98 static INLINE boolean
  99 rect_to_pipe_box_flip(struct pipe_box *dst, const RECT *src)
 100 {
 101     rect_to_pipe_box(dst, src);
 102
 103     if (dst->width >= 0 && dst->height >= 0)
 104         return FALSE;
 105     if (dst->width < 0) dst->width = -dst->width;
 106     if (dst->height < 0) dst->height = -dst->height;
 107     return TRUE;
 108 }
 109
 110 static INLINE void
 111 nine_u_rect_to_pipe_box(struct pipe_box *dst, const struct u_rect *rect, int z)
 112 {
 113     dst->x = rect->x0;
 114     dst->y = rect->y0;
 115     dst->z = z;
 116     dst->width = rect->x1 - rect->x0;
 117     dst->height = rect->y1 - rect->y0;
 118     dst->depth = 1;
 119 }
 120
 121 static INLINE void
 122 rect_to_pipe_box_xy_only(struct pipe_box *dst, const RECT *src)
 123 {
 124     user_warn(src->left > src->right || src->top > src->bottom);
 125
 126     dst->x = src->left;
 127     dst->y = src->top;
 128     dst->width = src->right - src->left;
 129     dst->height = src->bottom - src->top;
 130 }
 131
 132 static INLINE boolean
 133 rect_to_pipe_box_xy_only_clamp(struct pipe_box *dst, const RECT *src)
 134 {
 135     rect_to_pipe_box_xy_only(dst, src);
 136
 137     if (dst->width <= 0 || dst->height <= 0) {
 138         DBG_FLAG(DBG_UNKNOWN, "Warning: NULL box");
 139         dst->width = MAX2(dst->width, 0);
 140         dst->height = MAX2(dst->height, 0);
 141         return TRUE;
 142     }
 143     return FALSE;
 144 }
 145
 146 static INLINE void
 147 rect_to_g3d_u_rect(struct u_rect *dst, const RECT *src)
 148 {
 149     user_warn(src->left > src->right || src->top > src->bottom);
 150
 151     dst->x0 = src->left;
 152     dst->x1 = src->right;
 153     dst->y0 = src->top;
 154     dst->y1 = src->bottom;
 155 }
 156
 157 static INLINE void
 158 d3dbox_to_pipe_box(struct pipe_box *dst, const D3DBOX *src)
 159 {
 160     user_warn(src->Left > src->Right);
 161     user_warn(src->Top > src->Bottom);
 162     user_warn(src->Front > src->Back);
 163
 164     dst->x = src->Left;
 165     dst->y = src->Top;
 166     dst->z = src->Front;
 167     dst->width = src->Right - src->Left;
 168     dst->height = src->Bottom - src->Top;
 169     dst->depth = src->Back - src->Front;
 170 }
 171
 172 static INLINE D3DFORMAT
 173 pipe_to_d3d9_format(enum pipe_format format)
 174 {
 175     return nine_pipe_to_d3d9_format_map[format];
 176 }
 177
 178 static INLINE enum pipe_format
 179 d3d9_to_pipe_format_internal(D3DFORMAT format)
 180 {
 181     if (format <= D3DFMT_A2B10G10R10_XR_BIAS)
 182         return nine_d3d9_to_pipe_format_map[format];
 183     switch (format) {
 184     case D3DFMT_INTZ: return PIPE_FORMAT_S8_UINT_Z24_UNORM;
 185     case D3DFMT_DF16: return PIPE_FORMAT_Z16_UNORM;
 186     case D3DFMT_DXT1: return PIPE_FORMAT_DXT1_RGBA;
 187     case D3DFMT_DXT2: return PIPE_FORMAT_DXT3_RGBA; /* XXX */
 188     case D3DFMT_DXT3: return PIPE_FORMAT_DXT3_RGBA;
 189     case D3DFMT_DXT4: return PIPE_FORMAT_DXT5_RGBA; /* XXX */
 190     case D3DFMT_DXT5: return PIPE_FORMAT_DXT5_RGBA;
 191     case D3DFMT_ATI1: return PIPE_FORMAT_RGTC1_UNORM;
 192     case D3DFMT_ATI2: return PIPE_FORMAT_RGTC2_UNORM;
 193     case D3DFMT_UYVY: return PIPE_FORMAT_UYVY;
 194     case D3DFMT_YUY2: return PIPE_FORMAT_YUYV; /* XXX check */
 195     case D3DFMT_NV12: return PIPE_FORMAT_NV12;
 196     case D3DFMT_G8R8_G8B8: return PIPE_FORMAT_G8R8_G8B8_UNORM; /* XXX order ? */
 197     case D3DFMT_R8G8_B8G8: return PIPE_FORMAT_R8G8_B8G8_UNORM; /* XXX order ? */
 198     case D3DFMT_BINARYBUFFER: return PIPE_FORMAT_NONE; /* not a format */
 199     case D3DFMT_MULTI2_ARGB8: return PIPE_FORMAT_NONE; /* not supported */
 200     case D3DFMT_Y210: /* XXX */
 201     case D3DFMT_Y216:
 202     case D3DFMT_NV11:
 203     case D3DFMT_DF24: /* Similar to D3DFMT_DF16 but for 24-bits.
 204         We don't advertise it because when it is supported, Fetch-4 is
 205         supposed to be supported, which we don't support yet. */
 206     case D3DFMT_NULL: /* special cased, only for surfaces */
 207         return PIPE_FORMAT_NONE;
 208     default:
 209         DBG_FLAG(DBG_UNKNOWN, "unknown D3DFORMAT: 0x%x/%c%c%c%c\n",
 210                  format, (char)format, (char)(format >> 8),
 211                  (char)(format >> 16), (char)(format >> 24));
 212         return PIPE_FORMAT_NONE;
 213     }
 214 }
 215
 216 #define format_check_internal(pipe_format) \
 217     screen->is_format_supported(screen, pipe_format, target, \
 218                                 sample_count, bindings)
 219
 220 static INLINE enum pipe_format
 221 d3d9_to_pipe_format_checked(struct pipe_screen *screen,
 222                             D3DFORMAT format,
 223                             enum pipe_texture_target target,
 224                             unsigned sample_count,
 225                             unsigned bindings,
 226                             boolean srgb)
 227 {
 228     enum pipe_format result;
 229
 230     result = d3d9_to_pipe_format_internal(format);
 231     if (result == PIPE_FORMAT_NONE)
 232         return PIPE_FORMAT_NONE;
 233
 234     if (srgb)
 235         result = util_format_srgb(result);
 236
 237     if (format_check_internal(result))
 238         return result;
 239
 240     /* fallback to another format for formats
 241      * that match several pipe_format */
 242     switch(format) {
 243         /* depth buffer formats are not lockable (except those for which it
 244          * is precised in the name), so it is ok to match to another similar
 245          * format. In all cases, if the app reads the texture with a shader,
 246          * it gets depth on r and doesn't get stencil.*/
 247         case D3DFMT_INTZ:
 248         case D3DFMT_D24S8:
 249             if (format_check_internal(PIPE_FORMAT_Z24_UNORM_S8_UINT))
 250                 return PIPE_FORMAT_Z24_UNORM_S8_UINT;
 251             break;
 252         case D3DFMT_D24X8:
 253             if (format_check_internal(PIPE_FORMAT_Z24X8_UNORM))
 254                 return PIPE_FORMAT_Z24X8_UNORM;
 255         default:
 256             break;
 257     }
 258     return PIPE_FORMAT_NONE;
 259 }
 260
 261 /* same that above, but determines binding flags */
 262 static INLINE enum pipe_format
 263 d3d9_to_pipe_format_checked_no_bind(struct pipe_screen *screen,
 264                                     D3DFORMAT format,
 265                                     enum pipe_texture_target target,
 266                                     unsigned sample_count,
 267                                     boolean srgb)
 268 {
 269     enum pipe_format result;
 270     unsigned bindings;
 271
 272     result = d3d9_to_pipe_format_internal(format);
 273     if (result == PIPE_FORMAT_NONE)
 274         return PIPE_FORMAT_NONE;
 275
 276     bindings = util_format_is_depth_or_stencil(result) ?
 277         PIPE_BIND_DEPTH_STENCIL : PIPE_BIND_RENDER_TARGET;
 278     if (srgb)
 279         result = util_format_srgb(result);
 280
 281     if (format_check_internal(result))
 282         return result;
 283     return PIPE_FORMAT_NONE;
 284 }
 285
 286 static INLINE const char *
 287 d3dformat_to_string(D3DFORMAT fmt)
 288 {
 289     switch (fmt) {
 290     case D3DFMT_UNKNOWN: return "D3DFMT_UNKNOWN";
 291     case D3DFMT_R8G8B8: return "D3DFMT_R8G8B8";
 292     case D3DFMT_A8R8G8B8: return "D3DFMT_A8R8G8B8";
 293     case D3DFMT_X8R8G8B8: return "D3DFMT_X8R8G8B8";
 294     case D3DFMT_R5G6B5: return "D3DFMT_R5G6B5";
 295     case D3DFMT_X1R5G5B5: return "D3DFMT_X1R5G5B5";
 296     case D3DFMT_A1R5G5B5: return "D3DFMT_A1R5G5B5";
 297     case D3DFMT_A4R4G4B4: return "D3DFMT_A4R4G4B4";
 298     case D3DFMT_R3G3B2: return "D3DFMT_R3G3B2";
 299     case D3DFMT_A8: return "D3DFMT_A8";
 300     case D3DFMT_A8R3G3B2: return "D3DFMT_A8R3G3B2";
 301     case D3DFMT_X4R4G4B4: return "D3DFMT_X4R4G4B4";
 302     case D3DFMT_A2B10G10R10: return "D3DFMT_A2B10G10R10";
 303     case D3DFMT_A8B8G8R8: return "D3DFMT_A8B8G8R8";
 304     case D3DFMT_X8B8G8R8: return "D3DFMT_X8B8G8R8";
 305     case D3DFMT_G16R16: return "D3DFMT_G16R16";
 306     case D3DFMT_A2R10G10B10: return "D3DFMT_A2R10G10B10";
 307     case D3DFMT_A16B16G16R16: return "D3DFMT_A16B16G16R16";
 308     case D3DFMT_A8P8: return "D3DFMT_A8P8";
 309     case D3DFMT_P8: return "D3DFMT_P8";
 310     case D3DFMT_L8: return "D3DFMT_L8";
 311     case D3DFMT_A8L8: return "D3DFMT_A8L8";
 312     case D3DFMT_A4L4: return "D3DFMT_A4L4";
 313     case D3DFMT_V8U8: return "D3DFMT_V8U8";
 314     case D3DFMT_L6V5U5: return "D3DFMT_L6V5U5";
 315     case D3DFMT_X8L8V8U8: return "D3DFMT_X8L8V8U8";
 316     case D3DFMT_Q8W8V8U8: return "D3DFMT_Q8W8V8U8";
 317     case D3DFMT_V16U16: return "D3DFMT_V16U16";
 318     case D3DFMT_A2W10V10U10: return "D3DFMT_A2W10V10U10";
 319     case D3DFMT_UYVY: return "D3DFMT_UYVY";
 320     case D3DFMT_R8G8_B8G8: return "D3DFMT_R8G8_B8G8";
 321     case D3DFMT_YUY2: return "D3DFMT_YUY2";
 322     case D3DFMT_G8R8_G8B8: return "D3DFMT_G8R8_G8B8";
 323     case D3DFMT_DXT1: return "D3DFMT_DXT1";
 324     case D3DFMT_DXT2: return "D3DFMT_DXT2";
 325     case D3DFMT_DXT3: return "D3DFMT_DXT3";
 326     case D3DFMT_DXT4: return "D3DFMT_DXT4";
 327     case D3DFMT_DXT5: return "D3DFMT_DXT5";
 328     case D3DFMT_ATI1: return "D3DFMT_ATI1";
 329     case D3DFMT_ATI2: return "D3DFMT_ATI2";
 330     case D3DFMT_D16_LOCKABLE: return "D3DFMT_D16_LOCKABLE";
 331     case D3DFMT_D32: return "D3DFMT_D32";
 332     case D3DFMT_D15S1: return "D3DFMT_D15S1";
 333     case D3DFMT_D24S8: return "D3DFMT_D24S8";
 334     case D3DFMT_D24X8: return "D3DFMT_D24X8";
 335     case D3DFMT_D24X4S4: return "D3DFMT_D24X4S4";
 336     case D3DFMT_D16: return "D3DFMT_D16";
 337     case D3DFMT_D32F_LOCKABLE: return "D3DFMT_D32F_LOCKABLE";
 338     case D3DFMT_D24FS8: return "D3DFMT_D24FS8";
 339     case D3DFMT_D32_LOCKABLE: return "D3DFMT_D32_LOCKABLE";
 340     case D3DFMT_S8_LOCKABLE: return "D3DFMT_S8_LOCKABLE";
 341     case D3DFMT_L16: return "D3DFMT_L16";
 342     case D3DFMT_VERTEXDATA: return "D3DFMT_VERTEXDATA";
 343     case D3DFMT_INDEX16: return "D3DFMT_INDEX16";
 344     case D3DFMT_INDEX32: return "D3DFMT_INDEX32";
 345     case D3DFMT_Q16W16V16U16: return "D3DFMT_Q16W16V16U16";
 346     case D3DFMT_MULTI2_ARGB8: return "D3DFMT_MULTI2_ARGB8";
 347     case D3DFMT_R16F: return "D3DFMT_R16F";
 348     case D3DFMT_G16R16F: return "D3DFMT_G16R16F";
 349     case D3DFMT_A16B16G16R16F: return "D3DFMT_A16B16G16R16F";
 350     case D3DFMT_R32F: return "D3DFMT_R32F";
 351     case D3DFMT_G32R32F: return "D3DFMT_G32R32F";
 352     case D3DFMT_A32B32G32R32F: return "D3DFMT_A32B32G32R32F";
 353     case D3DFMT_CxV8U8: return "D3DFMT_CxV8U8";
 354     case D3DFMT_A1: return "D3DFMT_A1";
 355     case D3DFMT_A2B10G10R10_XR_BIAS: return "D3DFMT_A2B10G10R10_XR_BIAS";
 356     case D3DFMT_BINARYBUFFER: return "D3DFMT_BINARYBUFFER";
 357     case D3DFMT_DF16: return "D3DFMT_DF16";
 358     case D3DFMT_DF24: return "D3DFMT_DF24";
 359     case D3DFMT_INTZ: return "D3DFMT_INTZ";
 360     case D3DFMT_NVDB: return "D3DFMT_NVDB";
 361     case D3DFMT_RESZ: return "D3DFMT_RESZ";
 362     case D3DFMT_NULL: return "D3DFMT_NULL";
 363     default:
 364         break;
 365     }
 366     return "Unknown";
 367 }
 368
 369 static INLINE unsigned
 370 nine_fvf_stride( DWORD fvf )
 371 {
 372     unsigned texcount, i, size = 0;
 373
 374     switch (fvf & D3DFVF_POSITION_MASK) {
 375     case D3DFVF_XYZ:    size += 3*4; break;
 376     case D3DFVF_XYZRHW: size += 4*4; break;
 377     case D3DFVF_XYZB1:  size += 4*4; break;
 378     case D3DFVF_XYZB2:  size += 5*4; break;
 379     case D3DFVF_XYZB3:  size += 6*4; break;
 380     case D3DFVF_XYZB4:  size += 7*4; break;
 381     case D3DFVF_XYZB5:  size += 8*4; break;
 382     case D3DFVF_XYZW:   size += 4*4; break;
 383     default:
 384         user_warn("Position doesn't match any known combination.");
 385         break;
 386     }
 387
 388     if (fvf & D3DFVF_NORMAL)   { size += 3*4; }
 389     if (fvf & D3DFVF_PSIZE)    { size += 1*4; }
 390     if (fvf & D3DFVF_DIFFUSE)  { size += 1*4; }
 391     if (fvf & D3DFVF_SPECULAR) { size += 1*4; }
 392
 393     texcount = (fvf >> D3DFVF_TEXCOUNT_SHIFT) & D3DFVF_TEXCOUNT_MASK;
 394     if (user_error(texcount <= 8))
 395         texcount = 8;
 396
 397     for (i = 0; i < texcount; ++i) {
 398         unsigned texformat = (fvf>>(16+i*2))&0x3;
 399         /* texformats are defined having been shifted around so 1=3,2=0,3=1,4=2
 400          * meaning we can just do this instead of the switch below */
 401         size += (((texformat+1)&0x3)+1)*4;
 402
 403         /*
 404         switch (texformat) {
 405         case D3DFVF_TEXTUREFORMAT1: size += 1*4;
 406         case D3DFVF_TEXTUREFORMAT2: size += 2*4;
 407         case D3DFVF_TEXTUREFORMAT3: size += 3*4;
 408         case D3DFVF_TEXTUREFORMAT4: size += 4*4;
 409         }
 410         */
 411     }
 412
 413     return size;
 414 }
 415
 416 static INLINE void
 417 d3dcolor_to_rgba(float *rgba, D3DCOLOR color)
 418 {
 419     rgba[0] = (float)((color >> 16) & 0xFF) / 0xFF;
 420     rgba[1] = (float)((color >>  8) & 0xFF) / 0xFF;
 421     rgba[2] = (float)((color >>  0) & 0xFF) / 0xFF;
 422     rgba[3] = (float)((color >> 24) & 0xFF) / 0xFF;
 423 }
 424
 425 static INLINE void
 426 d3dcolor_to_pipe_color_union(union pipe_color_union *rgba, D3DCOLOR color)
 427 {
 428     d3dcolor_to_rgba(&rgba->f[0], color);
 429 }
 430
 431 static INLINE unsigned
 432 d3dprimitivetype_to_pipe_prim(D3DPRIMITIVETYPE prim)
 433 {
 434     switch (prim) {
 435     case D3DPT_POINTLIST:     return PIPE_PRIM_POINTS;
 436     case D3DPT_LINELIST:      return PIPE_PRIM_LINES;
 437     case D3DPT_LINESTRIP:     return PIPE_PRIM_LINE_STRIP;
 438     case D3DPT_TRIANGLELIST:  return PIPE_PRIM_TRIANGLES;
 439     case D3DPT_TRIANGLESTRIP: return PIPE_PRIM_TRIANGLE_STRIP;
 440     case D3DPT_TRIANGLEFAN:   return PIPE_PRIM_TRIANGLE_FAN;
 441     default:
 442         assert(0);
 443         return PIPE_PRIM_POINTS;
 444     }
 445 }
 446
 447 static INLINE unsigned
 448 prim_count_to_vertex_count(D3DPRIMITIVETYPE prim, UINT count)
 449 {
 450     switch (prim) {
 451     case D3DPT_POINTLIST:     return count;
 452     case D3DPT_LINELIST:      return count * 2;
 453     case D3DPT_LINESTRIP:     return count + 1;
 454     case D3DPT_TRIANGLELIST:  return count * 3;
 455     case D3DPT_TRIANGLESTRIP: return count + 2;
 456     case D3DPT_TRIANGLEFAN:   return count + 2;
 457     default:
 458         assert(0);
 459         return 0;
 460     }
 461 }
 462
 463 static INLINE unsigned
 464 d3dcmpfunc_to_pipe_func(D3DCMPFUNC func)
 465 {
 466     switch (func) {
 467     case D3DCMP_NEVER:        return PIPE_FUNC_NEVER;
 468     case D3DCMP_LESS:         return PIPE_FUNC_LESS;
 469     case D3DCMP_EQUAL:        return PIPE_FUNC_EQUAL;
 470     case D3DCMP_LESSEQUAL:    return PIPE_FUNC_LEQUAL;
 471     case D3DCMP_GREATER:      return PIPE_FUNC_GREATER;
 472     case D3DCMP_NOTEQUAL:     return PIPE_FUNC_NOTEQUAL;
 473     case D3DCMP_GREATEREQUAL: return PIPE_FUNC_GEQUAL;
 474     case D3DCMP_ALWAYS:       return PIPE_FUNC_ALWAYS;
 475     case D3DCMP_NEVER_ZERO:   return PIPE_FUNC_NEVER; // Tested on windows + ATI HD5770
 476     default:
 477         assert(0);
 478         return PIPE_FUNC_NEVER;
 479     }
 480 }
 481
 482 static INLINE unsigned
 483 d3dstencilop_to_pipe_stencil_op(D3DSTENCILOP op)
 484 {
 485     switch (op) {
 486     case D3DSTENCILOP_KEEP:    return PIPE_STENCIL_OP_KEEP;
 487     case D3DSTENCILOP_ZERO:    return PIPE_STENCIL_OP_ZERO;
 488     case D3DSTENCILOP_REPLACE: return PIPE_STENCIL_OP_REPLACE;
 489     case D3DSTENCILOP_INCRSAT: return PIPE_STENCIL_OP_INCR;
 490     case D3DSTENCILOP_DECRSAT: return PIPE_STENCIL_OP_DECR;
 491     case D3DSTENCILOP_INVERT:  return PIPE_STENCIL_OP_INVERT;
 492     case D3DSTENCILOP_INCR:    return PIPE_STENCIL_OP_INCR_WRAP;
 493     case D3DSTENCILOP_DECR:    return PIPE_STENCIL_OP_DECR_WRAP;
 494     default:
 495         return PIPE_STENCIL_OP_ZERO;
 496     }
 497 }
 498
 499 static INLINE unsigned
 500 d3dcull_to_pipe_face(D3DCULL cull)
 501 {
 502     switch (cull) {
 503     case D3DCULL_NONE: return PIPE_FACE_NONE;
 504     case D3DCULL_CW:   return PIPE_FACE_FRONT;
 505     case D3DCULL_CCW:  return PIPE_FACE_BACK;
 506     default:
 507         assert(0);
 508         return PIPE_FACE_NONE;
 509     }
 510 }
 511
 512 static INLINE unsigned
 513 d3dfillmode_to_pipe_polygon_mode(D3DFILLMODE mode)
 514 {
 515     switch (mode) {
 516     case D3DFILL_POINT:     return PIPE_POLYGON_MODE_POINT;
 517     case D3DFILL_WIREFRAME: return PIPE_POLYGON_MODE_LINE;
 518     case D3DFILL_SOLID:     return PIPE_POLYGON_MODE_FILL;
 519     case D3DFILL_SOLID_ZERO:return PIPE_POLYGON_MODE_FILL;
 520     default:
 521         assert(0);
 522         return PIPE_POLYGON_MODE_FILL;
 523     }
 524 }
 525
 526 static INLINE unsigned
 527 d3dblendop_to_pipe_blend(D3DBLENDOP op)
 528 {
 529     switch (op) {
 530     case D3DBLENDOP_ADD:         return PIPE_BLEND_ADD;
 531     case D3DBLENDOP_SUBTRACT:    return PIPE_BLEND_SUBTRACT;
 532     case D3DBLENDOP_REVSUBTRACT: return PIPE_BLEND_REVERSE_SUBTRACT;
 533     case D3DBLENDOP_MIN:         return PIPE_BLEND_MIN;
 534     case D3DBLENDOP_MAX:         return PIPE_BLEND_MAX;
 535     default:
 536         assert(0);
 537         return PIPE_BLEND_ADD;
 538     }
 539 }
 540
 541 /* NOTE: The COLOR factors for are equal to the ALPHA ones for alpha.
 542  * Drivers may check RGB and ALPHA factors for equality so we should not
 543  * simply substitute the ALPHA variants.
 544  */
 545 static INLINE unsigned
 546 d3dblend_alpha_to_pipe_blendfactor(D3DBLEND b)
 547 {
 548     switch (b) {
 549     case D3DBLEND_ZERO:            return PIPE_BLENDFACTOR_ZERO;
 550     case D3DBLEND_ONE:             return PIPE_BLENDFACTOR_ONE;
 551     case D3DBLEND_SRCCOLOR:        return PIPE_BLENDFACTOR_SRC_COLOR/*ALPHA*/;
 552     case D3DBLEND_INVSRCCOLOR:     return PIPE_BLENDFACTOR_INV_SRC_COLOR/*ALPHA*/;
 553     case D3DBLEND_SRCALPHA:        return PIPE_BLENDFACTOR_SRC_ALPHA;
 554     case D3DBLEND_INVSRCALPHA:     return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
 555     case D3DBLEND_DESTALPHA:       return PIPE_BLENDFACTOR_DST_ALPHA;
 556     case D3DBLEND_INVDESTALPHA:    return PIPE_BLENDFACTOR_INV_DST_ALPHA;
 557     case D3DBLEND_DESTCOLOR:       return PIPE_BLENDFACTOR_DST_COLOR/*ALPHA*/;
 558     case D3DBLEND_INVDESTCOLOR:    return PIPE_BLENDFACTOR_INV_DST_COLOR/*ALPHA*/;
 559     case D3DBLEND_SRCALPHASAT:     return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;
 560     case D3DBLEND_BOTHSRCALPHA:    return PIPE_BLENDFACTOR_SRC_ALPHA;
 561     case D3DBLEND_BOTHINVSRCALPHA: return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
 562     case D3DBLEND_BLENDFACTOR:     return PIPE_BLENDFACTOR_CONST_COLOR/*ALPHA*/;
 563     case D3DBLEND_INVBLENDFACTOR:  return PIPE_BLENDFACTOR_INV_CONST_COLOR/*ALPHA*/;
 564     case D3DBLEND_SRCCOLOR2:       return PIPE_BLENDFACTOR_ONE; /* XXX */
 565     case D3DBLEND_INVSRCCOLOR2:    return PIPE_BLENDFACTOR_ZERO; /* XXX */
 566     default:
 567        DBG_FLAG(DBG_UNKNOWN, "Unhandled blend factor %d\n", b);
 568        return PIPE_BLENDFACTOR_ZERO;
 569     }
 570 }
 571
 572 static INLINE unsigned
 573 d3dblend_color_to_pipe_blendfactor(D3DBLEND b)
 574 {
 575     switch (b) {
 576     case D3DBLEND_ZERO:            return PIPE_BLENDFACTOR_ZERO;
 577     case D3DBLEND_ONE:             return PIPE_BLENDFACTOR_ONE;
 578     case D3DBLEND_SRCCOLOR:        return PIPE_BLENDFACTOR_SRC_COLOR;
 579     case D3DBLEND_INVSRCCOLOR:     return PIPE_BLENDFACTOR_INV_SRC_COLOR;
 580     case D3DBLEND_SRCALPHA:        return PIPE_BLENDFACTOR_SRC_ALPHA;
 581     case D3DBLEND_INVSRCALPHA:     return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
 582     case D3DBLEND_DESTALPHA:       return PIPE_BLENDFACTOR_DST_ALPHA;
 583     case D3DBLEND_INVDESTALPHA:    return PIPE_BLENDFACTOR_INV_DST_ALPHA;
 584     case D3DBLEND_DESTCOLOR:       return PIPE_BLENDFACTOR_DST_COLOR;
 585     case D3DBLEND_INVDESTCOLOR:    return PIPE_BLENDFACTOR_INV_DST_COLOR;
 586     case D3DBLEND_SRCALPHASAT:     return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;
 587     case D3DBLEND_BOTHSRCALPHA:    return PIPE_BLENDFACTOR_SRC_ALPHA;
 588     case D3DBLEND_BOTHINVSRCALPHA: return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
 589     case D3DBLEND_BLENDFACTOR:     return PIPE_BLENDFACTOR_CONST_COLOR;
 590     case D3DBLEND_INVBLENDFACTOR:  return PIPE_BLENDFACTOR_INV_CONST_COLOR;
 591     case D3DBLEND_SRCCOLOR2:       return PIPE_BLENDFACTOR_SRC1_COLOR;
 592     case D3DBLEND_INVSRCCOLOR2:    return PIPE_BLENDFACTOR_INV_SRC1_COLOR;
 593     default:
 594        DBG_FLAG(DBG_UNKNOWN, "Unhandled blend factor %d\n", b);
 595        return PIPE_BLENDFACTOR_ZERO;
 596     }
 597 }
 598
 599 static INLINE unsigned
 600 d3dtextureaddress_to_pipe_tex_wrap(D3DTEXTUREADDRESS addr)
 601 {
 602     switch (addr) {
 603     case D3DTADDRESS_WRAP:       return PIPE_TEX_WRAP_REPEAT;
 604     case D3DTADDRESS_MIRROR:     return PIPE_TEX_WRAP_MIRROR_REPEAT;
 605     case D3DTADDRESS_CLAMP:      return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 606     case D3DTADDRESS_BORDER:     return PIPE_TEX_WRAP_CLAMP_TO_BORDER;
 607     case D3DTADDRESS_MIRRORONCE: return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
 608     default:
 609         assert(0);
 610         return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
 611     }
 612 }
 613
 614 static INLINE unsigned
 615 d3dtexturefiltertype_to_pipe_tex_filter(D3DTEXTUREFILTERTYPE filter)
 616 {
 617     switch (filter) {
 618     case D3DTEXF_POINT:       return PIPE_TEX_FILTER_NEAREST;
 619     case D3DTEXF_LINEAR:      return PIPE_TEX_FILTER_LINEAR;
 620     case D3DTEXF_ANISOTROPIC: return PIPE_TEX_FILTER_LINEAR;
 621
 622     case D3DTEXF_NONE:
 623     case D3DTEXF_PYRAMIDALQUAD:
 624     case D3DTEXF_GAUSSIANQUAD:
 625     case D3DTEXF_CONVOLUTIONMONO:
 626     default:
 627         assert(0);
 628         return PIPE_TEX_FILTER_NEAREST;
 629     }
 630 }
 631
 632 static INLINE unsigned
 633 d3dtexturefiltertype_to_pipe_tex_mipfilter(D3DTEXTUREFILTERTYPE filter)
 634 {
 635     switch (filter) {
 636     case D3DTEXF_NONE:        return PIPE_TEX_MIPFILTER_NONE;
 637     case D3DTEXF_POINT:       return PIPE_TEX_FILTER_NEAREST;
 638     case D3DTEXF_LINEAR:      return PIPE_TEX_FILTER_LINEAR;
 639     case D3DTEXF_ANISOTROPIC: return PIPE_TEX_FILTER_LINEAR;
 640
 641     case D3DTEXF_PYRAMIDALQUAD:
 642     case D3DTEXF_GAUSSIANQUAD:
 643     case D3DTEXF_CONVOLUTIONMONO:
 644     default:
 645         assert(0);
 646         return PIPE_TEX_MIPFILTER_NONE;
 647     }
 648 }
 649
 650 #endif /* _NINE_PIPE_H_ */