src/gallium/state_trackers/nine/nine_state.c

   1 /*
   2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
   3  * Copyright 2013 Christoph Bumiller
   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 #include "device9.h"
  25 #include "basetexture9.h"
  26 #include "indexbuffer9.h"
  27 #include "surface9.h"
  28 #include "vertexdeclaration9.h"
  29 #include "vertexshader9.h"
  30 #include "pixelshader9.h"
  31 #include "nine_pipe.h"
  32 #include "nine_ff.h"
  33 #include "pipe/p_context.h"
  34 #include "pipe/p_state.h"
  35 #include "cso_cache/cso_context.h"
  36 #include "util/u_math.h"
  37
  38 #define DBG_CHANNEL DBG_DEVICE
  39
  40 static uint32_t
  41 update_framebuffer(struct NineDevice9 *device)
  42 {
  43     struct pipe_context *pipe = device->pipe;
  44     struct nine_state *state = &device->state;
  45     struct pipe_framebuffer_state *fb = &device->state.fb;
  46     unsigned i;
  47     struct NineSurface9 *rt0 = state->rt[0];
  48     unsigned w = rt0->desc.Width;
  49     unsigned h = rt0->desc.Height;
  50     D3DMULTISAMPLE_TYPE nr_samples = rt0->desc.MultiSampleType;
  51     unsigned mask = state->ps ? state->ps->rt_mask : 1;
  52     const int sRGB = state->rs[D3DRS_SRGBWRITEENABLE] ? 1 : 0;
  53
  54     DBG("\n");
  55
  56     state->rt_mask = 0x0;
  57     fb->nr_cbufs = 0;
  58
  59     /* all render targets must have the same size and the depth buffer must be
  60      * bigger. Multisample has to match, according to spec. But some apps do
  61      * things wrong there, and no error is returned. The behaviour they get
  62      * apparently is that depth buffer is disabled if it doesn't match.
  63      * Surely the same for render targets. */
  64
  65     /* Special case: D3DFMT_NULL is used to bound no real render target,
  66      * but render to depth buffer. We have to not take into account the render
  67      * target info. TODO: know what should happen when there are several render targers
  68      * and the first one is D3DFMT_NULL */
  69     if (rt0->desc.Format == D3DFMT_NULL && state->ds) {
  70         w = state->ds->desc.Width;
  71         h = state->ds->desc.Height;
  72         nr_samples = state->ds->desc.MultiSampleType;
  73     }
  74
  75     for (i = 0; i < device->caps.NumSimultaneousRTs; ++i) {
  76         struct NineSurface9 *rt = state->rt[i];
  77
  78         if (rt && rt->desc.Format != D3DFMT_NULL && (mask & (1 << i)) &&
  79             rt->desc.Width == w && rt->desc.Height == h &&
  80             rt->desc.MultiSampleType == nr_samples) {
  81             fb->cbufs[i] = NineSurface9_GetSurface(rt, sRGB);
  82             state->rt_mask |= 1 << i;
  83             fb->nr_cbufs = i + 1;
  84
  85             if (unlikely(rt->desc.Usage & D3DUSAGE_AUTOGENMIPMAP)) {
  86                 assert(rt->texture == D3DRTYPE_TEXTURE ||
  87                        rt->texture == D3DRTYPE_CUBETEXTURE);
  88                 NineBaseTexture9(rt->base.base.container)->dirty_mip = TRUE;
  89             }
  90         } else {
  91             /* Color outputs must match RT slot,
  92              * drivers will have to handle NULL entries for GL, too.
  93              */
  94             fb->cbufs[i] = NULL;
  95         }
  96     }
  97
  98     if (state->ds && state->ds->desc.Width >= w &&
  99         state->ds->desc.Height >= h &&
 100         state->ds->desc.MultiSampleType == nr_samples) {
 101         fb->zsbuf = NineSurface9_GetSurface(state->ds, 0);
 102     } else {
 103         fb->zsbuf = NULL;
 104     }
 105
 106     fb->width = w;
 107     fb->height = h;
 108
 109     pipe->set_framebuffer_state(pipe, fb); /* XXX: cso ? */
 110
 111     if (fb->zsbuf) {
 112         DWORD scale;
 113         switch (fb->zsbuf->format) {
 114         case PIPE_FORMAT_Z32_FLOAT:
 115         case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
 116             scale = fui(1.0f);
 117             break;
 118         case PIPE_FORMAT_Z16_UNORM:
 119             scale = fui((float)(1 << 16));
 120             break;
 121         default:
 122             scale = fui((float)(1 << 24));
 123             break;
 124         }
 125         if (state->rs[NINED3DRS_ZBIASSCALE] != scale) {
 126             state->rs[NINED3DRS_ZBIASSCALE] = scale;
 127             state->changed.group |= NINE_STATE_RASTERIZER;
 128         }
 129     }
 130
 131     return state->changed.group;
 132 }
 133
 134 static void
 135 update_viewport(struct NineDevice9 *device)
 136 {
 137     struct pipe_context *pipe = device->pipe;
 138     const D3DVIEWPORT9 *vport = &device->state.viewport;
 139     struct pipe_viewport_state pvport;
 140
 141     /* XXX:
 142      * I hope D3D clip coordinates are still
 143      * -1 .. +1 for X,Y and
 144      *  0 .. +1 for Z (use pipe_rasterizer_state.clip_halfz)
 145      */
 146     pvport.scale[0] = (float)vport->Width * 0.5f;
 147     pvport.scale[1] = (float)vport->Height * -0.5f;
 148     pvport.scale[2] = vport->MaxZ - vport->MinZ;
 149     pvport.translate[0] = (float)vport->Width * 0.5f + (float)vport->X;
 150     pvport.translate[1] = (float)vport->Height * 0.5f + (float)vport->Y;
 151     pvport.translate[2] = vport->MinZ;
 152
 153     pipe->set_viewport_states(pipe, 0, 1, &pvport);
 154 }
 155
 156 static INLINE void
 157 update_scissor(struct NineDevice9 *device)
 158 {
 159     struct pipe_context *pipe = device->pipe;
 160
 161     pipe->set_scissor_states(pipe, 0, 1, &device->state.scissor);
 162 }
 163
 164 static INLINE void
 165 update_blend(struct NineDevice9 *device)
 166 {
 167     nine_convert_blend_state(device->cso, device->state.rs);
 168 }
 169
 170 static INLINE void
 171 update_dsa(struct NineDevice9 *device)
 172 {
 173     nine_convert_dsa_state(device->cso, device->state.rs);
 174 }
 175
 176 static INLINE void
 177 update_rasterizer(struct NineDevice9 *device)
 178 {
 179     nine_convert_rasterizer_state(device->cso, device->state.rs);
 180 }
 181
 182 /* Loop through VS inputs and pick the vertex elements with the declared
 183  * usage from the vertex declaration, then insert the instance divisor from
 184  * the stream source frequency setting.
 185  */
 186 static void
 187 update_vertex_elements(struct NineDevice9 *device)
 188 {
 189     struct nine_state *state = &device->state;
 190     const struct NineVertexDeclaration9 *vdecl = device->state.vdecl;
 191     const struct NineVertexShader9 *vs;
 192     unsigned n, b, i;
 193     int index;
 194     struct pipe_vertex_element ve[PIPE_MAX_ATTRIBS];
 195
 196     state->stream_usage_mask = 0;
 197
 198     vs = device->state.vs ? device->state.vs : device->ff.vs;
 199
 200     if (!vdecl) /* no inputs */
 201         return;
 202     for (n = 0; n < vs->num_inputs; ++n) {
 203         DBG("looking up input %u (usage %u) from vdecl(%p)\n",
 204             n, vs->input_map[n].ndecl, vdecl);
 205
 206         index = -1;
 207         for (i = 0; i < vdecl->nelems; i++) {
 208             if (vdecl->usage_map[i] == vs->input_map[n].ndecl) {
 209                 index = i;
 210                 break;
 211             }
 212         }
 213
 214         if (index >= 0) {
 215             ve[n] = vdecl->elems[index];
 216             b = ve[n].vertex_buffer_index;
 217             state->stream_usage_mask |= 1 << b;
 218             /* XXX wine just uses 1 here: */
 219             if (state->stream_freq[b] & D3DSTREAMSOURCE_INSTANCEDATA)
 220                 ve[n].instance_divisor = state->stream_freq[b] & 0x7FFFFF;
 221         } else {
 222             /* TODO: msdn doesn't specify what should happen when the vertex
 223              * declaration doesn't match the vertex shader inputs.
 224              * Some websites say the code will pass but nothing will get rendered.
 225              * We should check and implement the correct behaviour. */
 226             /* Put PIPE_FORMAT_NONE.
 227              * Some drivers (r300) are very unhappy with that */
 228             ve[n].src_format = PIPE_FORMAT_NONE;
 229             ve[n].src_offset = 0;
 230             ve[n].instance_divisor = 0;
 231             ve[n].vertex_buffer_index = 0;
 232         }
 233     }
 234     cso_set_vertex_elements(device->cso, vs->num_inputs, ve);
 235
 236     state->changed.stream_freq = 0;
 237 }
 238
 239 static INLINE uint32_t
 240 update_shader_variant_keys(struct NineDevice9 *device)
 241 {
 242     struct nine_state *state = &device->state;
 243     uint32_t mask = 0;
 244     uint32_t vs_key = state->samplers_shadow;
 245     uint32_t ps_key = state->samplers_shadow;
 246
 247     vs_key = (vs_key & NINE_VS_SAMPLERS_MASK) >> NINE_SAMPLER_VS(0);
 248     ps_key = (ps_key & NINE_PS_SAMPLERS_MASK) >> NINE_SAMPLER_PS(0);
 249
 250     if (state->vs) vs_key &= state->vs->sampler_mask;
 251     if (state->ps) {
 252         if (unlikely(state->ps->byte_code.version < 0x20)) {
 253             /* no depth textures, but variable targets */
 254             uint32_t m = state->ps->sampler_mask;
 255             ps_key = 0;
 256             while (m) {
 257                 int s = ffs(m) - 1;
 258                 m &= ~(1 << s);
 259                 ps_key |= (state->texture[s] ? state->texture[s]->pstype : 1) << (s * 2);
 260             }
 261         } else {
 262             ps_key &= state->ps->sampler_mask;
 263         }
 264     }
 265
 266     if (state->vs && state->vs_key != vs_key) {
 267         state->vs_key = vs_key;
 268         mask |= NINE_STATE_VS;
 269     }
 270     if (state->ps && state->ps_key != ps_key) {
 271         state->ps_key = ps_key;
 272         mask |= NINE_STATE_PS;
 273     }
 274     return mask;
 275 }
 276
 277 static INLINE uint32_t
 278 update_vs(struct NineDevice9 *device)
 279 {
 280     struct nine_state *state = &device->state;
 281     struct NineVertexShader9 *vs = state->vs;
 282
 283     /* likely because we dislike FF */
 284     if (likely(vs)) {
 285         state->cso.vs = NineVertexShader9_GetVariant(vs, state->vs_key);
 286     } else {
 287         vs = device->ff.vs;
 288         state->cso.vs = vs->variant.cso;
 289     }
 290     device->pipe->bind_vs_state(device->pipe, state->cso.vs);
 291
 292     if (state->rs[NINED3DRS_VSPOINTSIZE] != vs->point_size) {
 293         state->rs[NINED3DRS_VSPOINTSIZE] = vs->point_size;
 294         return NINE_STATE_RASTERIZER;
 295     }
 296 #ifdef DEBUG
 297     {
 298         unsigned s, mask = vs->sampler_mask;
 299         for (s = 0; mask; ++s, mask >>= 1)
 300             if ((mask & 1) && !(device->state.texture[NINE_SAMPLER_VS(s)]))
 301                 WARN_ONCE("FIXME: unbound sampler should return alpha=1\n");
 302     }
 303 #endif
 304     return 0;
 305 }
 306
 307 static INLINE uint32_t
 308 update_ps(struct NineDevice9 *device)
 309 {
 310     struct nine_state *state = &device->state;
 311     struct NinePixelShader9 *ps = state->ps;
 312
 313     if (likely(ps)) {
 314         state->cso.ps = NinePixelShader9_GetVariant(ps, state->ps_key);
 315     } else {
 316         ps = device->ff.ps;
 317         state->cso.ps = ps->variant.cso;
 318     }
 319     device->pipe->bind_fs_state(device->pipe, state->cso.ps);
 320
 321 #ifdef DEBUG
 322     {
 323         unsigned s, mask = ps->sampler_mask;
 324         for (s = 0; mask; ++s, mask >>= 1)
 325             if ((mask & 1) && !(device->state.texture[NINE_SAMPLER_PS(s)]))
 326                 WARN_ONCE("FIXME: unbound sampler should return alpha=1\n");
 327     }
 328 #endif
 329     return 0;
 330 }
 331
 332 #define DO_UPLOAD_CONST_F(buf,p,c,d) \
 333     do { \
 334         DBG("upload ConstantF [%u .. %u]\n", x, (x) + (c) - 1); \
 335         box.x = (p) * 4 * sizeof(float); \
 336         box.width = (c) * 4 * sizeof(float); \
 337         pipe->transfer_inline_write(pipe, buf, 0, usage, &box, &((d)[p * 4]), \
 338                                     0, 0); \
 339     } while(0)
 340
 341 /* OK, this is a bit ugly ... */
 342 static void
 343 update_constants(struct NineDevice9 *device, unsigned shader_type)
 344 {
 345     struct pipe_context *pipe = device->pipe;
 346     struct pipe_resource *buf;
 347     struct pipe_box box;
 348     const void *data;
 349     const float *const_f;
 350     const int *const_i;
 351     const BOOL *const_b;
 352     uint32_t data_b[NINE_MAX_CONST_B];
 353     uint16_t dirty_i;
 354     uint16_t dirty_b;
 355     const unsigned usage = PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE;
 356     unsigned x = 0; /* silence warning */
 357     unsigned i, c;
 358     struct nine_range *r, *p, *lconstf_ranges;
 359     float *lconstf_data;
 360
 361     box.y = 0;
 362     box.z = 0;
 363     box.height = 1;
 364     box.depth = 1;
 365
 366     if (shader_type == PIPE_SHADER_VERTEX) {
 367         DBG("VS\n");
 368         buf = device->constbuf_vs;
 369
 370         const_f = device->state.vs_const_f;
 371         for (p = r = device->state.changed.vs_const_f; r; p = r, r = r->next)
 372             DO_UPLOAD_CONST_F(buf, r->bgn, r->end - r->bgn, const_f);
 373         if (p) {
 374             nine_range_pool_put_chain(&device->range_pool,
 375                                       device->state.changed.vs_const_f, p);
 376             device->state.changed.vs_const_f = NULL;
 377         }
 378
 379         dirty_i = device->state.changed.vs_const_i;
 380         device->state.changed.vs_const_i = 0;
 381         const_i = &device->state.vs_const_i[0][0];
 382
 383         dirty_b = device->state.changed.vs_const_b;
 384         device->state.changed.vs_const_b = 0;
 385         const_b = device->state.vs_const_b;
 386
 387         lconstf_ranges = device->state.vs->lconstf.ranges;
 388         lconstf_data = device->state.vs->lconstf.data;
 389
 390         device->state.ff.clobber.vs_const = TRUE;
 391         device->state.changed.group &= ~NINE_STATE_VS_CONST;
 392     } else {
 393         DBG("PS\n");
 394         buf = device->constbuf_ps;
 395
 396         const_f = device->state.ps_const_f;
 397         for (p = r = device->state.changed.ps_const_f; r; p = r, r = r->next)
 398             DO_UPLOAD_CONST_F(buf, r->bgn, r->end - r->bgn, const_f);
 399         if (p) {
 400             nine_range_pool_put_chain(&device->range_pool,
 401                                       device->state.changed.ps_const_f, p);
 402             device->state.changed.ps_const_f = NULL;
 403         }
 404
 405         dirty_i = device->state.changed.ps_const_i;
 406         device->state.changed.ps_const_i = 0;
 407         const_i = &device->state.ps_const_i[0][0];
 408
 409         dirty_b = device->state.changed.ps_const_b;
 410         device->state.changed.ps_const_b = 0;
 411         const_b = device->state.ps_const_b;
 412
 413         lconstf_ranges = NULL;
 414         lconstf_data = NULL;
 415
 416         device->state.ff.clobber.ps_const = TRUE;
 417         device->state.changed.group &= ~NINE_STATE_PS_CONST;
 418     }
 419
 420     /* write range from min to max changed, it's not much data */
 421     /* bool1 */
 422     if (dirty_b) {
 423        c = util_last_bit(dirty_b);
 424        i = ffs(dirty_b) - 1;
 425        x = buf->width0 - (NINE_MAX_CONST_B - i) * 4;
 426        c -= i;
 427        memcpy(data_b, &(const_b[i]), c * sizeof(uint32_t));
 428        box.x = x;
 429        box.width = c * 4;
 430        DBG("upload ConstantB [%u .. %u]\n", x, x + c - 1);
 431        pipe->transfer_inline_write(pipe, buf, 0, usage, &box, data_b, 0, 0);
 432     }
 433
 434     /* int4 */
 435     for (c = 0, i = 0; dirty_i; i++, dirty_i >>= 1) {
 436         if (dirty_i & 1) {
 437             if (!c)
 438                 x = i;
 439             ++c;
 440         } else
 441         if (c) {
 442             DBG("upload ConstantI [%u .. %u]\n", x, x + c - 1);
 443             data = &const_i[x * 4];
 444             box.x  = buf->width0 - (NINE_MAX_CONST_I * 4 + NINE_MAX_CONST_B) * 4;
 445             box.x += x * 4 * sizeof(int);
 446             box.width = c * 4 * sizeof(int);
 447             c = 0;
 448             pipe->transfer_inline_write(pipe, buf, 0, usage, &box, data, 0, 0);
 449         }
 450     }
 451     if (c) {
 452         DBG("upload ConstantI [%u .. %u]\n", x, x + c - 1);
 453         data = &const_i[x * 4];
 454         box.x  = buf->width0 - (NINE_MAX_CONST_I * 4 + NINE_MAX_CONST_B) * 4;
 455         box.x += x * 4 * sizeof(int);
 456         box.width = c * 4 * sizeof(int);
 457         pipe->transfer_inline_write(pipe, buf, 0, usage, &box, data, 0, 0);
 458     }
 459
 460     /* TODO: only upload these when shader itself changes */
 461     if (lconstf_ranges) {
 462         unsigned n = 0;
 463         struct nine_range *r = lconstf_ranges;
 464         while (r) {
 465             box.x = r->bgn * 4 * sizeof(float);
 466             n += r->end - r->bgn;
 467             box.width = (r->end - r->bgn) * 4 * sizeof(float);
 468             data = &lconstf_data[4 * n];
 469             pipe->transfer_inline_write(pipe, buf, 0, usage, &box, data, 0, 0);
 470             r = r->next;
 471         }
 472     }
 473 }
 474
 475 static void
 476 update_vs_constants_userbuf(struct NineDevice9 *device)
 477 {
 478     struct nine_state *state = &device->state;
 479     struct pipe_context *pipe = device->pipe;
 480     struct pipe_constant_buffer cb;
 481     cb.buffer = NULL;
 482     cb.buffer_offset = 0;
 483     cb.buffer_size = device->state.vs->const_used_size;
 484     cb.user_buffer = device->state.vs_const_f;
 485
 486     if (!cb.buffer_size)
 487         return;
 488
 489     if (state->changed.vs_const_i) {
 490         int *idst = (int *)&state->vs_const_f[4 * device->max_vs_const_f];
 491         memcpy(idst, state->vs_const_i, sizeof(state->vs_const_i));
 492         state->changed.vs_const_i = 0;
 493     }
 494     if (state->changed.vs_const_b) {
 495         int *idst = (int *)&state->vs_const_f[4 * device->max_vs_const_f];
 496         uint32_t *bdst = (uint32_t *)&idst[4 * NINE_MAX_CONST_I];
 497         memcpy(bdst, state->vs_const_b, sizeof(state->vs_const_b));
 498         state->changed.vs_const_b = 0;
 499     }
 500
 501     if (device->state.vs->lconstf.ranges) {
 502         /* TODO: Can we make it so that we don't have to copy everything ? */
 503         const struct nine_lconstf *lconstf =  &device->state.vs->lconstf;
 504         const struct nine_range *r = lconstf->ranges;
 505         unsigned n = 0;
 506         float *dst = device->state.vs_lconstf_temp;
 507         float *src = (float *)cb.user_buffer;
 508         memcpy(dst, src, cb.buffer_size);
 509         while (r) {
 510             unsigned p = r->bgn;
 511             unsigned c = r->end - r->bgn;
 512             memcpy(&dst[p * 4], &lconstf->data[n * 4], c * 4 * sizeof(float));
 513             n += c;
 514             r = r->next;
 515         }
 516         cb.user_buffer = dst;
 517     }
 518
 519     pipe->set_constant_buffer(pipe, PIPE_SHADER_VERTEX, 0, &cb);
 520
 521     if (device->state.changed.vs_const_f) {
 522         struct nine_range *r = device->state.changed.vs_const_f;
 523         struct nine_range *p = r;
 524         while (p->next)
 525             p = p->next;
 526         nine_range_pool_put_chain(&device->range_pool, r, p);
 527         device->state.changed.vs_const_f = NULL;
 528     }
 529     state->changed.group &= ~NINE_STATE_VS_CONST;
 530 }
 531
 532 static void
 533 update_ps_constants_userbuf(struct NineDevice9 *device)
 534 {
 535     struct nine_state *state = &device->state;
 536     struct pipe_context *pipe = device->pipe;
 537     struct pipe_constant_buffer cb;
 538     cb.buffer = NULL;
 539     cb.buffer_offset = 0;
 540     cb.buffer_size = device->state.ps->const_used_size;
 541     cb.user_buffer = device->state.ps_const_f;
 542
 543     if (!cb.buffer_size)
 544         return;
 545
 546     if (state->changed.ps_const_i) {
 547         int *idst = (int *)&state->ps_const_f[4 * device->max_ps_const_f];
 548         memcpy(idst, state->ps_const_i, sizeof(state->ps_const_i));
 549         state->changed.ps_const_i = 0;
 550     }
 551     if (state->changed.ps_const_b) {
 552         int *idst = (int *)&state->ps_const_f[4 * device->max_ps_const_f];
 553         uint32_t *bdst = (uint32_t *)&idst[4 * NINE_MAX_CONST_I];
 554         memcpy(bdst, state->ps_const_b, sizeof(state->ps_const_b));
 555         state->changed.ps_const_b = 0;
 556     }
 557
 558     pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, 0, &cb);
 559
 560     if (device->state.changed.ps_const_f) {
 561         struct nine_range *r = device->state.changed.ps_const_f;
 562         struct nine_range *p = r;
 563         while (p->next)
 564             p = p->next;
 565         nine_range_pool_put_chain(&device->range_pool, r, p);
 566         device->state.changed.ps_const_f = NULL;
 567     }
 568     state->changed.group &= ~NINE_STATE_PS_CONST;
 569 }
 570
 571 static void
 572 update_vertex_buffers(struct NineDevice9 *device)
 573 {
 574     struct pipe_context *pipe = device->pipe;
 575     struct nine_state *state = &device->state;
 576     uint32_t mask = state->changed.vtxbuf;
 577     unsigned i;
 578     unsigned start;
 579     unsigned count = 0;
 580
 581     DBG("mask=%x\n", mask);
 582
 583     for (i = 0; mask; mask >>= 1, ++i) {
 584         if (mask & 1) {
 585             if (!count)
 586                 start = i;
 587             ++count;
 588         } else {
 589             if (count)
 590                 pipe->set_vertex_buffers(pipe,
 591                                          start, count, &state->vtxbuf[start]);
 592             count = 0;
 593         }
 594     }
 595     if (count)
 596         pipe->set_vertex_buffers(pipe, start, count, &state->vtxbuf[start]);
 597
 598     state->changed.vtxbuf = 0;
 599 }
 600
 601 static INLINE void
 602 update_index_buffer(struct NineDevice9 *device)
 603 {
 604     struct pipe_context *pipe = device->pipe;
 605     if (device->state.idxbuf)
 606         pipe->set_index_buffer(pipe, &device->state.idxbuf->buffer);
 607     else
 608         pipe->set_index_buffer(pipe, NULL);
 609 }
 610
 611 /* TODO: only go through dirty textures */
 612 static void
 613 validate_textures(struct NineDevice9 *device)
 614 {
 615     struct NineBaseTexture9 *tex, *ptr;
 616     LIST_FOR_EACH_ENTRY_SAFE(tex, ptr, &device->update_textures, list) {
 617         list_delinit(&tex->list);
 618         NineBaseTexture9_Validate(tex);
 619     }
 620 }
 621
 622 static INLINE boolean
 623 update_sampler_derived(struct nine_state *state, unsigned s)
 624 {
 625     boolean changed = FALSE;
 626
 627     if (state->samp[s][NINED3DSAMP_SHADOW] != state->texture[s]->shadow) {
 628         changed = TRUE;
 629         state->samp[s][NINED3DSAMP_SHADOW] = state->texture[s]->shadow;
 630     }
 631
 632     if (state->samp[s][D3DSAMP_MIPFILTER] != D3DTEXF_NONE) {
 633         int lod = state->samp[s][D3DSAMP_MAXMIPLEVEL] - state->texture[s]->lod;
 634         if (lod < 0)
 635             lod = 0;
 636         if (state->samp[s][NINED3DSAMP_MINLOD] != lod) {
 637             changed = TRUE;
 638             state->samp[s][NINED3DSAMP_MINLOD] = lod;
 639         }
 640     } else {
 641         state->changed.sampler[s] &= ~0x300; /* lod changes irrelevant */
 642     }
 643
 644     return changed;
 645 }
 646
 647 /* TODO: add sRGB override to pipe_sampler_state ? */
 648 static void
 649 update_textures_and_samplers(struct NineDevice9 *device)
 650 {
 651     struct pipe_context *pipe = device->pipe;
 652     struct nine_state *state = &device->state;
 653     struct pipe_sampler_view *view[NINE_MAX_SAMPLERS];
 654     unsigned num_textures;
 655     unsigned i;
 656     boolean commit_samplers;
 657
 658     /* TODO: Can we reduce iterations here ? */
 659
 660     commit_samplers = FALSE;
 661     for (num_textures = 0, i = 0; i < NINE_MAX_SAMPLERS_PS; ++i) {
 662         const unsigned s = NINE_SAMPLER_PS(i);
 663         int sRGB;
 664         if (!state->texture[s]) {
 665             view[i] = NULL;
 666 #ifdef DEBUG
 667             if (state->ps && state->ps->sampler_mask & (1 << i))
 668                 WARN_ONCE("FIXME: unbound sampler should return alpha=1\n");
 669 #endif
 670             continue;
 671         }
 672         sRGB = state->samp[s][D3DSAMP_SRGBTEXTURE] ? 1 : 0;
 673
 674         view[i] = NineBaseTexture9_GetSamplerView(state->texture[s], sRGB);
 675         num_textures = i + 1;
 676
 677         if (update_sampler_derived(state, s) || (state->changed.sampler[s] & 0x05fe)) {
 678             state->changed.sampler[s] = 0;
 679             commit_samplers = TRUE;
 680             nine_convert_sampler_state(device->cso, s, state->samp[s]);
 681         }
 682     }
 683     if (state->changed.texture & NINE_PS_SAMPLERS_MASK || state->changed.srgb)
 684         pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0,
 685                                 num_textures, view);
 686
 687     if (commit_samplers)
 688         cso_single_sampler_done(device->cso, PIPE_SHADER_FRAGMENT);
 689
 690     commit_samplers = FALSE;
 691     for (num_textures = 0, i = 0; i < NINE_MAX_SAMPLERS_VS; ++i) {
 692         const unsigned s = NINE_SAMPLER_VS(i);
 693         int sRGB;
 694         if (!state->texture[s]) {
 695             view[i] = NULL;
 696 #ifdef DEBUG
 697             if (state->vs && state->vs->sampler_mask & (1 << i))
 698                 WARN_ONCE("FIXME: unbound sampler should return alpha=1\n");
 699 #endif
 700             continue;
 701         }
 702         sRGB = state->samp[s][D3DSAMP_SRGBTEXTURE] ? 1 : 0;
 703
 704         view[i] = NineBaseTexture9_GetSamplerView(state->texture[s], sRGB);
 705         num_textures = i + 1;
 706
 707         if (update_sampler_derived(state, s) || (state->changed.sampler[s] & 0x05fe)) {
 708             state->changed.sampler[s] = 0;
 709             commit_samplers = TRUE;
 710             nine_convert_sampler_state(device->cso, s, state->samp[s]);
 711         }
 712     }
 713     if (state->changed.texture & NINE_VS_SAMPLERS_MASK || state->changed.srgb)
 714         pipe->set_sampler_views(pipe, PIPE_SHADER_VERTEX, 0,
 715                                 num_textures, view);
 716
 717     if (commit_samplers)
 718         cso_single_sampler_done(device->cso, PIPE_SHADER_VERTEX);
 719
 720     state->changed.srgb = FALSE;
 721     state->changed.texture = 0;
 722 }
 723
 724
 725 #define NINE_STATE_FREQ_GROUP_0 \
 726    (NINE_STATE_FB |             \
 727     NINE_STATE_VIEWPORT |       \
 728     NINE_STATE_SCISSOR |        \
 729     NINE_STATE_BLEND |          \
 730     NINE_STATE_DSA |            \
 731     NINE_STATE_RASTERIZER |     \
 732     NINE_STATE_VS |             \
 733     NINE_STATE_PS |             \
 734     NINE_STATE_BLEND_COLOR |    \
 735     NINE_STATE_STENCIL_REF |    \
 736     NINE_STATE_SAMPLE_MASK)
 737
 738 #define NINE_STATE_FREQ_GROUP_1 ~NINE_STATE_FREQ_GROUP_0
 739
 740 #define NINE_STATE_SHADER_VARIANT_GROUP \
 741     (NINE_STATE_TEXTURE | \
 742      NINE_STATE_VS | \
 743      NINE_STATE_PS)
 744
 745 boolean
 746 nine_update_state(struct NineDevice9 *device, uint32_t mask)
 747 {
 748     struct pipe_context *pipe = device->pipe;
 749     struct nine_state *state = &device->state;
 750     uint32_t group;
 751
 752     DBG("changed state groups: %x | %x\n",
 753         state->changed.group & NINE_STATE_FREQ_GROUP_0,
 754         state->changed.group & NINE_STATE_FREQ_GROUP_1);
 755
 756     /* NOTE: We may want to use the cso cache for everything, or let
 757      * NineDevice9.RestoreNonCSOState actually set the states, then we wouldn't
 758      * have to care about state being clobbered here and could merge this back
 759      * into update_textures. Except, we also need to re-validate textures that
 760      * may be dirty anyway, even if no texture bindings changed.
 761      */
 762     validate_textures(device); /* may clobber state */
 763
 764     /* ff_update may change VS/PS dirty bits */
 765     if ((mask & NINE_STATE_FF) && unlikely(!state->vs || !state->ps))
 766         nine_ff_update(device);
 767     group = state->changed.group & mask;
 768
 769     if (group & NINE_STATE_SHADER_VARIANT_GROUP)
 770         group |= update_shader_variant_keys(device);
 771
 772     if (group & NINE_STATE_FREQ_GROUP_0) {
 773         if (group & NINE_STATE_FB)
 774             group = update_framebuffer(device) & mask;
 775         if (group & NINE_STATE_VIEWPORT)
 776             update_viewport(device);
 777         if (group & NINE_STATE_SCISSOR)
 778             update_scissor(device);
 779
 780         if (group & NINE_STATE_DSA)
 781             update_dsa(device);
 782         if (group & NINE_STATE_BLEND)
 783             update_blend(device);
 784
 785         if (group & NINE_STATE_VS)
 786             group |= update_vs(device);
 787
 788         if (group & NINE_STATE_RASTERIZER)
 789             update_rasterizer(device);
 790
 791         if (group & NINE_STATE_PS)
 792             group |= update_ps(device);
 793
 794         if (group & NINE_STATE_BLEND_COLOR) {
 795             struct pipe_blend_color color;
 796             d3dcolor_to_rgba(&color.color[0], state->rs[D3DRS_BLENDFACTOR]);
 797             pipe->set_blend_color(pipe, &color);
 798         }
 799         if (group & NINE_STATE_SAMPLE_MASK) {
 800             pipe->set_sample_mask(pipe, state->rs[D3DRS_MULTISAMPLEMASK]);
 801         }
 802         if (group & NINE_STATE_STENCIL_REF) {
 803             struct pipe_stencil_ref ref;
 804             ref.ref_value[0] = state->rs[D3DRS_STENCILREF];
 805             ref.ref_value[1] = ref.ref_value[0];
 806             pipe->set_stencil_ref(pipe, &ref);
 807         }
 808     }
 809
 810     if (state->changed.ucp) {
 811         pipe->set_clip_state(pipe, &state->clip);
 812         state->changed.ucp = 0;
 813     }
 814
 815     if (group & (NINE_STATE_FREQ_GROUP_1 | NINE_STATE_VS)) {
 816         if (group & (NINE_STATE_TEXTURE | NINE_STATE_SAMPLER))
 817             update_textures_and_samplers(device);
 818
 819         if (group & NINE_STATE_IDXBUF)
 820             update_index_buffer(device);
 821
 822         if ((group & (NINE_STATE_VDECL | NINE_STATE_VS)) ||
 823             state->changed.stream_freq & ~1)
 824             update_vertex_elements(device);
 825
 826         if (device->prefer_user_constbuf) {
 827             if ((group & (NINE_STATE_VS_CONST | NINE_STATE_VS)) && state->vs)
 828                 update_vs_constants_userbuf(device);
 829             if ((group & (NINE_STATE_PS_CONST | NINE_STATE_PS)) && state->ps)
 830                 update_ps_constants_userbuf(device);
 831         } else {
 832             if ((group & NINE_STATE_VS_CONST) && state->vs)
 833                 update_constants(device, PIPE_SHADER_VERTEX);
 834             if ((group & NINE_STATE_PS_CONST) && state->ps)
 835                 update_constants(device, PIPE_SHADER_FRAGMENT);
 836         }
 837     }
 838     if (state->changed.vtxbuf)
 839         update_vertex_buffers(device);
 840
 841     device->state.changed.group &= ~mask |
 842         (NINE_STATE_FF | NINE_STATE_VS_CONST | NINE_STATE_PS_CONST);
 843
 844     DBG("finished\n");
 845
 846     return TRUE;
 847 }
 848
 849
 850 static const DWORD nine_render_state_defaults[NINED3DRS_LAST + 1] =
 851 {
 852  /* [D3DRS_ZENABLE] = D3DZB_TRUE; wine: auto_depth_stencil */
 853     [D3DRS_ZENABLE] = D3DZB_FALSE,
 854     [D3DRS_FILLMODE] = D3DFILL_SOLID,
 855     [D3DRS_SHADEMODE] = D3DSHADE_GOURAUD,
 856 /*  [D3DRS_LINEPATTERN] = 0x00000000, */
 857     [D3DRS_ZWRITEENABLE] = TRUE,
 858     [D3DRS_ALPHATESTENABLE] = FALSE,
 859     [D3DRS_LASTPIXEL] = TRUE,
 860     [D3DRS_SRCBLEND] = D3DBLEND_ONE,
 861     [D3DRS_DESTBLEND] = D3DBLEND_ZERO,
 862     [D3DRS_CULLMODE] = D3DCULL_CCW,
 863     [D3DRS_ZFUNC] = D3DCMP_LESSEQUAL,
 864     [D3DRS_ALPHAFUNC] = D3DCMP_ALWAYS,
 865     [D3DRS_ALPHAREF] = 0,
 866     [D3DRS_DITHERENABLE] = FALSE,
 867     [D3DRS_ALPHABLENDENABLE] = FALSE,
 868     [D3DRS_FOGENABLE] = FALSE,
 869     [D3DRS_SPECULARENABLE] = FALSE,
 870 /*  [D3DRS_ZVISIBLE] = 0, */
 871     [D3DRS_FOGCOLOR] = 0,
 872     [D3DRS_FOGTABLEMODE] = D3DFOG_NONE,
 873     [D3DRS_FOGSTART] = 0x00000000,
 874     [D3DRS_FOGEND] = 0x3F800000,
 875     [D3DRS_FOGDENSITY] = 0x3F800000,
 876 /*  [D3DRS_EDGEANTIALIAS] = FALSE, */
 877     [D3DRS_RANGEFOGENABLE] = FALSE,
 878     [D3DRS_STENCILENABLE] = FALSE,
 879     [D3DRS_STENCILFAIL] = D3DSTENCILOP_KEEP,
 880     [D3DRS_STENCILZFAIL] = D3DSTENCILOP_KEEP,
 881     [D3DRS_STENCILPASS] = D3DSTENCILOP_KEEP,
 882     [D3DRS_STENCILREF] = 0,
 883     [D3DRS_STENCILMASK] = 0xFFFFFFFF,
 884     [D3DRS_STENCILFUNC] = D3DCMP_ALWAYS,
 885     [D3DRS_STENCILWRITEMASK] = 0xFFFFFFFF,
 886     [D3DRS_TEXTUREFACTOR] = 0xFFFFFFFF,
 887     [D3DRS_WRAP0] = 0,
 888     [D3DRS_WRAP1] = 0,
 889     [D3DRS_WRAP2] = 0,
 890     [D3DRS_WRAP3] = 0,
 891     [D3DRS_WRAP4] = 0,
 892     [D3DRS_WRAP5] = 0,
 893     [D3DRS_WRAP6] = 0,
 894     [D3DRS_WRAP7] = 0,
 895     [D3DRS_CLIPPING] = TRUE,
 896     [D3DRS_LIGHTING] = TRUE,
 897     [D3DRS_AMBIENT] = 0,
 898     [D3DRS_FOGVERTEXMODE] = D3DFOG_NONE,
 899     [D3DRS_COLORVERTEX] = TRUE,
 900     [D3DRS_LOCALVIEWER] = TRUE,
 901     [D3DRS_NORMALIZENORMALS] = FALSE,
 902     [D3DRS_DIFFUSEMATERIALSOURCE] = D3DMCS_COLOR1,
 903     [D3DRS_SPECULARMATERIALSOURCE] = D3DMCS_COLOR2,
 904     [D3DRS_AMBIENTMATERIALSOURCE] = D3DMCS_MATERIAL,
 905     [D3DRS_EMISSIVEMATERIALSOURCE] = D3DMCS_MATERIAL,
 906     [D3DRS_VERTEXBLEND] = D3DVBF_DISABLE,
 907     [D3DRS_CLIPPLANEENABLE] = 0,
 908 /*  [D3DRS_SOFTWAREVERTEXPROCESSING] = FALSE, */
 909     [D3DRS_POINTSIZE] = 0x3F800000,
 910     [D3DRS_POINTSIZE_MIN] = 0x3F800000,
 911     [D3DRS_POINTSPRITEENABLE] = FALSE,
 912     [D3DRS_POINTSCALEENABLE] = FALSE,
 913     [D3DRS_POINTSCALE_A] = 0x3F800000,
 914     [D3DRS_POINTSCALE_B] = 0x00000000,
 915     [D3DRS_POINTSCALE_C] = 0x00000000,
 916     [D3DRS_MULTISAMPLEANTIALIAS] = TRUE,
 917     [D3DRS_MULTISAMPLEMASK] = 0xFFFFFFFF,
 918     [D3DRS_PATCHEDGESTYLE] = D3DPATCHEDGE_DISCRETE,
 919 /*  [D3DRS_PATCHSEGMENTS] = 0x3F800000, */
 920     [D3DRS_DEBUGMONITORTOKEN] = 0xDEADCAFE,
 921     [D3DRS_POINTSIZE_MAX] = 0x3F800000, /* depends on cap */
 922     [D3DRS_INDEXEDVERTEXBLENDENABLE] = FALSE,
 923     [D3DRS_COLORWRITEENABLE] = 0x0000000f,
 924     [D3DRS_TWEENFACTOR] = 0x00000000,
 925     [D3DRS_BLENDOP] = D3DBLENDOP_ADD,
 926     [D3DRS_POSITIONDEGREE] = D3DDEGREE_CUBIC,
 927     [D3DRS_NORMALDEGREE] = D3DDEGREE_LINEAR,
 928     [D3DRS_SCISSORTESTENABLE] = FALSE,
 929     [D3DRS_SLOPESCALEDEPTHBIAS] = 0,
 930     [D3DRS_MINTESSELLATIONLEVEL] = 0x3F800000,
 931     [D3DRS_MAXTESSELLATIONLEVEL] = 0x3F800000,
 932     [D3DRS_ANTIALIASEDLINEENABLE] = FALSE,
 933     [D3DRS_ADAPTIVETESS_X] = 0x00000000,
 934     [D3DRS_ADAPTIVETESS_Y] = 0x00000000,
 935     [D3DRS_ADAPTIVETESS_Z] = 0x3F800000,
 936     [D3DRS_ADAPTIVETESS_W] = 0x00000000,
 937     [D3DRS_ENABLEADAPTIVETESSELLATION] = FALSE,
 938     [D3DRS_TWOSIDEDSTENCILMODE] = FALSE,
 939     [D3DRS_CCW_STENCILFAIL] = D3DSTENCILOP_KEEP,
 940     [D3DRS_CCW_STENCILZFAIL] = D3DSTENCILOP_KEEP,
 941     [D3DRS_CCW_STENCILPASS] = D3DSTENCILOP_KEEP,
 942     [D3DRS_CCW_STENCILFUNC] = D3DCMP_ALWAYS,
 943     [D3DRS_COLORWRITEENABLE1] = 0x0000000F,
 944     [D3DRS_COLORWRITEENABLE2] = 0x0000000F,
 945     [D3DRS_COLORWRITEENABLE3] = 0x0000000F,
 946     [D3DRS_BLENDFACTOR] = 0xFFFFFFFF,
 947     [D3DRS_SRGBWRITEENABLE] = 0,
 948     [D3DRS_DEPTHBIAS] = 0,
 949     [D3DRS_WRAP8] = 0,
 950     [D3DRS_WRAP9] = 0,
 951     [D3DRS_WRAP10] = 0,
 952     [D3DRS_WRAP11] = 0,
 953     [D3DRS_WRAP12] = 0,
 954     [D3DRS_WRAP13] = 0,
 955     [D3DRS_WRAP14] = 0,
 956     [D3DRS_WRAP15] = 0,
 957     [D3DRS_SEPARATEALPHABLENDENABLE] = FALSE,
 958     [D3DRS_SRCBLENDALPHA] = D3DBLEND_ONE,
 959     [D3DRS_DESTBLENDALPHA] = D3DBLEND_ZERO,
 960     [D3DRS_BLENDOPALPHA] = D3DBLENDOP_ADD,
 961     [NINED3DRS_VSPOINTSIZE] = FALSE,
 962     [NINED3DRS_RTMASK] = 0xf,
 963     [NINED3DRS_ALPHACOVERAGE] = FALSE
 964 };
 965 static const DWORD nine_tex_stage_state_defaults[NINED3DTSS_LAST + 1] =
 966 {
 967     [D3DTSS_COLOROP] = D3DTOP_DISABLE,
 968     [D3DTSS_ALPHAOP] = D3DTOP_DISABLE,
 969     [D3DTSS_COLORARG1] = D3DTA_TEXTURE,
 970     [D3DTSS_COLORARG2] = D3DTA_CURRENT,
 971     [D3DTSS_COLORARG0] = D3DTA_CURRENT,
 972     [D3DTSS_ALPHAARG1] = D3DTA_TEXTURE,
 973     [D3DTSS_ALPHAARG2] = D3DTA_CURRENT,
 974     [D3DTSS_ALPHAARG0] = D3DTA_CURRENT,
 975     [D3DTSS_RESULTARG] = D3DTA_CURRENT,
 976     [D3DTSS_BUMPENVMAT00] = 0,
 977     [D3DTSS_BUMPENVMAT01] = 0,
 978     [D3DTSS_BUMPENVMAT10] = 0,
 979     [D3DTSS_BUMPENVMAT11] = 0,
 980     [D3DTSS_BUMPENVLSCALE] = 0,
 981     [D3DTSS_BUMPENVLOFFSET] = 0,
 982     [D3DTSS_TEXCOORDINDEX] = 0,
 983     [D3DTSS_TEXTURETRANSFORMFLAGS] = D3DTTFF_DISABLE,
 984 };
 985 static const DWORD nine_samp_state_defaults[NINED3DSAMP_LAST + 1] =
 986 {
 987     [D3DSAMP_ADDRESSU] = D3DTADDRESS_WRAP,
 988     [D3DSAMP_ADDRESSV] = D3DTADDRESS_WRAP,
 989     [D3DSAMP_ADDRESSW] = D3DTADDRESS_WRAP,
 990     [D3DSAMP_BORDERCOLOR] = 0,
 991     [D3DSAMP_MAGFILTER] = D3DTEXF_POINT,
 992     [D3DSAMP_MINFILTER] = D3DTEXF_POINT,
 993     [D3DSAMP_MIPFILTER] = D3DTEXF_NONE,
 994     [D3DSAMP_MIPMAPLODBIAS] = 0,
 995     [D3DSAMP_MAXMIPLEVEL] = 0,
 996     [D3DSAMP_MAXANISOTROPY] = 1,
 997     [D3DSAMP_SRGBTEXTURE] = 0,
 998     [D3DSAMP_ELEMENTINDEX] = 0,
 999     [D3DSAMP_DMAPOFFSET] = 0,
1000     [NINED3DSAMP_MINLOD] = 0,
1001     [NINED3DSAMP_SHADOW] = 0
1002 };
1003 void
1004 nine_state_set_defaults(struct NineDevice9 *device, const D3DCAPS9 *caps,
1005                         boolean is_reset)
1006 {
1007     struct nine_state *state = &device->state;
1008     unsigned s;
1009
1010     /* Initialize defaults.
1011      */
1012     memcpy(state->rs, nine_render_state_defaults, sizeof(state->rs));
1013
1014     for (s = 0; s < Elements(state->ff.tex_stage); ++s) {
1015         memcpy(&state->ff.tex_stage[s], nine_tex_stage_state_defaults,
1016                sizeof(state->ff.tex_stage[s]));
1017         state->ff.tex_stage[s][D3DTSS_TEXCOORDINDEX] = s;
1018     }
1019     state->ff.tex_stage[0][D3DTSS_COLOROP] = D3DTOP_MODULATE;
1020     state->ff.tex_stage[0][D3DTSS_ALPHAOP] = D3DTOP_SELECTARG1;
1021
1022     for (s = 0; s < Elements(state->samp); ++s) {
1023         memcpy(&state->samp[s], nine_samp_state_defaults,
1024                sizeof(state->samp[s]));
1025     }
1026
1027     if (state->vs_const_f)
1028         memset(state->vs_const_f, 0, device->vs_const_size);
1029     if (state->ps_const_f)
1030         memset(state->ps_const_f, 0, device->ps_const_size);
1031
1032     /* Cap dependent initial state:
1033      */
1034     state->rs[D3DRS_POINTSIZE_MAX] = fui(caps->MaxPointSize);
1035
1036     /* Set changed flags to initialize driver.
1037      */
1038     state->changed.group = NINE_STATE_ALL;
1039
1040     state->ff.changed.transform[0] = ~0;
1041     state->ff.changed.transform[D3DTS_WORLD / 32] |= 1 << (D3DTS_WORLD % 32);
1042
1043     if (!is_reset) {
1044         state->viewport.MinZ = 0.0f;
1045         state->viewport.MaxZ = 1.0f;
1046     }
1047
1048     for (s = 0; s < Elements(state->changed.sampler); ++s)
1049         state->changed.sampler[s] = ~0;
1050 }
1051
1052 void
1053 nine_state_clear(struct nine_state *state, const boolean device)
1054 {
1055     unsigned i;
1056
1057     for (i = 0; i < Elements(state->rt); ++i)
1058        nine_bind(&state->rt[i], NULL);
1059     nine_bind(&state->ds, NULL);
1060     nine_bind(&state->vs, NULL);
1061     nine_bind(&state->ps, NULL);
1062     nine_bind(&state->vdecl, NULL);
1063     for (i = 0; i < PIPE_MAX_ATTRIBS; ++i)
1064         nine_bind(&state->stream[i], NULL);
1065     nine_bind(&state->idxbuf, NULL);
1066     for (i = 0; i < NINE_MAX_SAMPLERS; ++i) {
1067         if (device &&
1068             state->texture[i] &&
1069           --state->texture[i]->bind_count == 0)
1070             list_delinit(&state->texture[i]->list);
1071         nine_bind(&state->texture[i], NULL);
1072     }
1073 }
1074
1075 /*
1076 static const DWORD nine_render_states_pixel[] =
1077 {
1078     D3DRS_ALPHABLENDENABLE,
1079     D3DRS_ALPHAFUNC,
1080     D3DRS_ALPHAREF,
1081     D3DRS_ALPHATESTENABLE,
1082     D3DRS_ANTIALIASEDLINEENABLE,
1083     D3DRS_BLENDFACTOR,
1084     D3DRS_BLENDOP,
1085     D3DRS_BLENDOPALPHA,
1086     D3DRS_CCW_STENCILFAIL,
1087     D3DRS_CCW_STENCILPASS,
1088     D3DRS_CCW_STENCILZFAIL,
1089     D3DRS_COLORWRITEENABLE,
1090     D3DRS_COLORWRITEENABLE1,
1091     D3DRS_COLORWRITEENABLE2,
1092     D3DRS_COLORWRITEENABLE3,
1093     D3DRS_DEPTHBIAS,
1094     D3DRS_DESTBLEND,
1095     D3DRS_DESTBLENDALPHA,
1096     D3DRS_DITHERENABLE,
1097     D3DRS_FILLMODE,
1098     D3DRS_FOGDENSITY,
1099     D3DRS_FOGEND,
1100     D3DRS_FOGSTART,
1101     D3DRS_LASTPIXEL,
1102     D3DRS_SCISSORTESTENABLE,
1103     D3DRS_SEPARATEALPHABLENDENABLE,
1104     D3DRS_SHADEMODE,
1105     D3DRS_SLOPESCALEDEPTHBIAS,
1106     D3DRS_SRCBLEND,
1107     D3DRS_SRCBLENDALPHA,
1108     D3DRS_SRGBWRITEENABLE,
1109     D3DRS_STENCILENABLE,
1110     D3DRS_STENCILFAIL,
1111     D3DRS_STENCILFUNC,
1112     D3DRS_STENCILMASK,
1113     D3DRS_STENCILPASS,
1114     D3DRS_STENCILREF,
1115     D3DRS_STENCILWRITEMASK,
1116     D3DRS_STENCILZFAIL,
1117     D3DRS_TEXTUREFACTOR,
1118     D3DRS_TWOSIDEDSTENCILMODE,
1119     D3DRS_WRAP0,
1120     D3DRS_WRAP1,
1121     D3DRS_WRAP10,
1122     D3DRS_WRAP11,
1123     D3DRS_WRAP12,
1124     D3DRS_WRAP13,
1125     D3DRS_WRAP14,
1126     D3DRS_WRAP15,
1127     D3DRS_WRAP2,
1128     D3DRS_WRAP3,
1129     D3DRS_WRAP4,
1130     D3DRS_WRAP5,
1131     D3DRS_WRAP6,
1132     D3DRS_WRAP7,
1133     D3DRS_WRAP8,
1134     D3DRS_WRAP9,
1135     D3DRS_ZENABLE,
1136     D3DRS_ZFUNC,
1137     D3DRS_ZWRITEENABLE
1138 };
1139 */
1140 const uint32_t nine_render_states_pixel[(NINED3DRS_LAST + 31) / 32] =
1141 {
1142     0x0f99c380, 0x1ff00070, 0x00000000, 0x00000000,
1143     0x000000ff, 0xde01c900, 0x0003ffcf
1144 };
1145
1146 /*
1147 static const DWORD nine_render_states_vertex[] =
1148 {
1149     D3DRS_ADAPTIVETESS_W,
1150     D3DRS_ADAPTIVETESS_X,
1151     D3DRS_ADAPTIVETESS_Y,
1152     D3DRS_ADAPTIVETESS_Z,
1153     D3DRS_AMBIENT,
1154     D3DRS_AMBIENTMATERIALSOURCE,
1155     D3DRS_CLIPPING,
1156     D3DRS_CLIPPLANEENABLE,
1157     D3DRS_COLORVERTEX,
1158     D3DRS_CULLMODE,
1159     D3DRS_DIFFUSEMATERIALSOURCE,
1160     D3DRS_EMISSIVEMATERIALSOURCE,
1161     D3DRS_ENABLEADAPTIVETESSELLATION,
1162     D3DRS_FOGCOLOR,
1163     D3DRS_FOGDENSITY,
1164     D3DRS_FOGENABLE,
1165     D3DRS_FOGEND,
1166     D3DRS_FOGSTART,
1167     D3DRS_FOGTABLEMODE,
1168     D3DRS_FOGVERTEXMODE,
1169     D3DRS_INDEXEDVERTEXBLENDENABLE,
1170     D3DRS_LIGHTING,
1171     D3DRS_LOCALVIEWER,
1172     D3DRS_MAXTESSELLATIONLEVEL,
1173     D3DRS_MINTESSELLATIONLEVEL,
1174     D3DRS_MULTISAMPLEANTIALIAS,
1175     D3DRS_MULTISAMPLEMASK,
1176     D3DRS_NORMALDEGREE,
1177     D3DRS_NORMALIZENORMALS,
1178     D3DRS_PATCHEDGESTYLE,
1179     D3DRS_POINTSCALE_A,
1180     D3DRS_POINTSCALE_B,
1181     D3DRS_POINTSCALE_C,
1182     D3DRS_POINTSCALEENABLE,
1183     D3DRS_POINTSIZE,
1184     D3DRS_POINTSIZE_MAX,
1185     D3DRS_POINTSIZE_MIN,
1186     D3DRS_POINTSPRITEENABLE,
1187     D3DRS_POSITIONDEGREE,
1188     D3DRS_RANGEFOGENABLE,
1189     D3DRS_SHADEMODE,
1190     D3DRS_SPECULARENABLE,
1191     D3DRS_SPECULARMATERIALSOURCE,
1192     D3DRS_TWEENFACTOR,
1193     D3DRS_VERTEXBLEND
1194 };
1195 */
1196 const uint32_t nine_render_states_vertex[(NINED3DRS_LAST + 31) / 32] =
1197 {
1198     0x30400200, 0x0001007c, 0x00000000, 0x00000000,
1199     0xfd9efb00, 0x01fc34cf, 0x00000000
1200 };
1201
1202 /* TODO: put in the right values */
1203 const uint32_t nine_render_state_group[NINED3DRS_LAST + 1] =
1204 {
1205     [D3DRS_ZENABLE] = NINE_STATE_DSA,
1206     [D3DRS_FILLMODE] = NINE_STATE_RASTERIZER,
1207     [D3DRS_SHADEMODE] = NINE_STATE_RASTERIZER,
1208     [D3DRS_ZWRITEENABLE] = NINE_STATE_DSA,
1209     [D3DRS_ALPHATESTENABLE] = NINE_STATE_DSA,
1210     [D3DRS_LASTPIXEL] = NINE_STATE_RASTERIZER,
1211     [D3DRS_SRCBLEND] = NINE_STATE_BLEND,
1212     [D3DRS_DESTBLEND] = NINE_STATE_BLEND,
1213     [D3DRS_CULLMODE] = NINE_STATE_RASTERIZER,
1214     [D3DRS_ZFUNC] = NINE_STATE_DSA,
1215     [D3DRS_ALPHAREF] = NINE_STATE_DSA,
1216     [D3DRS_ALPHAFUNC] = NINE_STATE_DSA,
1217     [D3DRS_DITHERENABLE] = NINE_STATE_RASTERIZER,
1218     [D3DRS_ALPHABLENDENABLE] = NINE_STATE_BLEND,
1219     [D3DRS_FOGENABLE] = NINE_STATE_FF_OTHER,
1220     [D3DRS_SPECULARENABLE] = NINE_STATE_FF_LIGHTING,
1221     [D3DRS_FOGCOLOR] = NINE_STATE_FF_OTHER,
1222     [D3DRS_FOGTABLEMODE] = NINE_STATE_FF_OTHER,
1223     [D3DRS_FOGSTART] = NINE_STATE_FF_OTHER,
1224     [D3DRS_FOGEND] = NINE_STATE_FF_OTHER,
1225     [D3DRS_FOGDENSITY] = NINE_STATE_FF_OTHER,
1226     [D3DRS_RANGEFOGENABLE] = NINE_STATE_FF_OTHER,
1227     [D3DRS_STENCILENABLE] = NINE_STATE_DSA,
1228     [D3DRS_STENCILFAIL] = NINE_STATE_DSA,
1229     [D3DRS_STENCILZFAIL] = NINE_STATE_DSA,
1230     [D3DRS_STENCILPASS] = NINE_STATE_DSA,
1231     [D3DRS_STENCILFUNC] = NINE_STATE_DSA,
1232     [D3DRS_STENCILREF] = NINE_STATE_STENCIL_REF,
1233     [D3DRS_STENCILMASK] = NINE_STATE_DSA,
1234     [D3DRS_STENCILWRITEMASK] = NINE_STATE_DSA,
1235     [D3DRS_TEXTUREFACTOR] = NINE_STATE_FF_PSSTAGES,
1236     [D3DRS_WRAP0] = NINE_STATE_UNHANDLED, /* cylindrical wrap is crazy */
1237     [D3DRS_WRAP1] = NINE_STATE_UNHANDLED,
1238     [D3DRS_WRAP2] = NINE_STATE_UNHANDLED,
1239     [D3DRS_WRAP3] = NINE_STATE_UNHANDLED,
1240     [D3DRS_WRAP4] = NINE_STATE_UNHANDLED,
1241     [D3DRS_WRAP5] = NINE_STATE_UNHANDLED,
1242     [D3DRS_WRAP6] = NINE_STATE_UNHANDLED,
1243     [D3DRS_WRAP7] = NINE_STATE_UNHANDLED,
1244     [D3DRS_CLIPPING] = 0, /* software vertex processing only */
1245     [D3DRS_LIGHTING] = NINE_STATE_FF_LIGHTING,
1246     [D3DRS_AMBIENT] = NINE_STATE_FF_LIGHTING | NINE_STATE_FF_MATERIAL,
1247     [D3DRS_FOGVERTEXMODE] = NINE_STATE_FF_OTHER,
1248     [D3DRS_COLORVERTEX] = NINE_STATE_FF_LIGHTING,
1249     [D3DRS_LOCALVIEWER] = NINE_STATE_FF_LIGHTING,
1250     [D3DRS_NORMALIZENORMALS] = NINE_STATE_FF_OTHER,
1251     [D3DRS_DIFFUSEMATERIALSOURCE] = NINE_STATE_FF_LIGHTING,
1252     [D3DRS_SPECULARMATERIALSOURCE] = NINE_STATE_FF_LIGHTING,
1253     [D3DRS_AMBIENTMATERIALSOURCE] = NINE_STATE_FF_LIGHTING,
1254     [D3DRS_EMISSIVEMATERIALSOURCE] = NINE_STATE_FF_LIGHTING,
1255     [D3DRS_VERTEXBLEND] = NINE_STATE_FF_OTHER,
1256     [D3DRS_CLIPPLANEENABLE] = NINE_STATE_RASTERIZER,
1257     [D3DRS_POINTSIZE] = NINE_STATE_RASTERIZER,
1258     [D3DRS_POINTSIZE_MIN] = NINE_STATE_MISC_CONST,
1259     [D3DRS_POINTSPRITEENABLE] = NINE_STATE_RASTERIZER,
1260     [D3DRS_POINTSCALEENABLE] = NINE_STATE_FF_OTHER,
1261     [D3DRS_POINTSCALE_A] = NINE_STATE_FF_OTHER,
1262     [D3DRS_POINTSCALE_B] = NINE_STATE_FF_OTHER,
1263     [D3DRS_POINTSCALE_C] = NINE_STATE_FF_OTHER,
1264     [D3DRS_MULTISAMPLEANTIALIAS] = NINE_STATE_RASTERIZER,
1265     [D3DRS_MULTISAMPLEMASK] = NINE_STATE_SAMPLE_MASK,
1266     [D3DRS_PATCHEDGESTYLE] = NINE_STATE_UNHANDLED,
1267     [D3DRS_DEBUGMONITORTOKEN] = NINE_STATE_UNHANDLED,
1268     [D3DRS_POINTSIZE_MAX] = NINE_STATE_MISC_CONST,
1269     [D3DRS_INDEXEDVERTEXBLENDENABLE] = NINE_STATE_FF_OTHER,
1270     [D3DRS_COLORWRITEENABLE] = NINE_STATE_BLEND,
1271     [D3DRS_TWEENFACTOR] = NINE_STATE_FF_OTHER,
1272     [D3DRS_BLENDOP] = NINE_STATE_BLEND,
1273     [D3DRS_POSITIONDEGREE] = NINE_STATE_UNHANDLED,
1274     [D3DRS_NORMALDEGREE] = NINE_STATE_UNHANDLED,
1275     [D3DRS_SCISSORTESTENABLE] = NINE_STATE_RASTERIZER,
1276     [D3DRS_SLOPESCALEDEPTHBIAS] = NINE_STATE_RASTERIZER,
1277     [D3DRS_ANTIALIASEDLINEENABLE] = NINE_STATE_RASTERIZER,
1278     [D3DRS_MINTESSELLATIONLEVEL] = NINE_STATE_UNHANDLED,
1279     [D3DRS_MAXTESSELLATIONLEVEL] = NINE_STATE_UNHANDLED,
1280     [D3DRS_ADAPTIVETESS_X] = NINE_STATE_UNHANDLED,
1281     [D3DRS_ADAPTIVETESS_Y] = NINE_STATE_UNHANDLED,
1282     [D3DRS_ADAPTIVETESS_Z] = NINE_STATE_UNHANDLED,
1283     [D3DRS_ADAPTIVETESS_W] = NINE_STATE_UNHANDLED,
1284     [D3DRS_ENABLEADAPTIVETESSELLATION] = NINE_STATE_UNHANDLED,
1285     [D3DRS_TWOSIDEDSTENCILMODE] = NINE_STATE_DSA,
1286     [D3DRS_CCW_STENCILFAIL] = NINE_STATE_DSA,
1287     [D3DRS_CCW_STENCILZFAIL] = NINE_STATE_DSA,
1288     [D3DRS_CCW_STENCILPASS] = NINE_STATE_DSA,
1289     [D3DRS_CCW_STENCILFUNC] = NINE_STATE_DSA,
1290     [D3DRS_COLORWRITEENABLE1] = NINE_STATE_BLEND,
1291     [D3DRS_COLORWRITEENABLE2] = NINE_STATE_BLEND,
1292     [D3DRS_COLORWRITEENABLE3] = NINE_STATE_BLEND,
1293     [D3DRS_BLENDFACTOR] = NINE_STATE_BLEND_COLOR,
1294     [D3DRS_SRGBWRITEENABLE] = NINE_STATE_FB,
1295     [D3DRS_DEPTHBIAS] = NINE_STATE_RASTERIZER,
1296     [D3DRS_WRAP8] = NINE_STATE_UNHANDLED, /* cylwrap has to be done via GP */
1297     [D3DRS_WRAP9] = NINE_STATE_UNHANDLED,
1298     [D3DRS_WRAP10] = NINE_STATE_UNHANDLED,
1299     [D3DRS_WRAP11] = NINE_STATE_UNHANDLED,
1300     [D3DRS_WRAP12] = NINE_STATE_UNHANDLED,
1301     [D3DRS_WRAP13] = NINE_STATE_UNHANDLED,
1302     [D3DRS_WRAP14] = NINE_STATE_UNHANDLED,
1303     [D3DRS_WRAP15] = NINE_STATE_UNHANDLED,
1304     [D3DRS_SEPARATEALPHABLENDENABLE] = NINE_STATE_BLEND,
1305     [D3DRS_SRCBLENDALPHA] = NINE_STATE_BLEND,
1306     [D3DRS_DESTBLENDALPHA] = NINE_STATE_BLEND,
1307     [D3DRS_BLENDOPALPHA] = NINE_STATE_BLEND
1308 };
1309
1310 D3DMATRIX *
1311 nine_state_access_transform(struct nine_state *state, D3DTRANSFORMSTATETYPE t,
1312                             boolean alloc)
1313 {
1314     static D3DMATRIX Identity = { .m[0] = { 1, 0, 0, 0 },
1315                                   .m[1] = { 0, 1, 0, 0 },
1316                                   .m[2] = { 0, 0, 1, 0 },
1317                                   .m[3] = { 0, 0, 0, 1 } };
1318     unsigned index;
1319
1320     switch (t) {
1321     case D3DTS_VIEW: index = 0; break;
1322     case D3DTS_PROJECTION: index = 1; break;
1323     case D3DTS_TEXTURE0: index = 2; break;
1324     case D3DTS_TEXTURE1: index = 3; break;
1325     case D3DTS_TEXTURE2: index = 4; break;
1326     case D3DTS_TEXTURE3: index = 5; break;
1327     case D3DTS_TEXTURE4: index = 6; break;
1328     case D3DTS_TEXTURE5: index = 7; break;
1329     case D3DTS_TEXTURE6: index = 8; break;
1330     case D3DTS_TEXTURE7: index = 9; break;
1331     default:
1332         if (!(t >= D3DTS_WORLDMATRIX(0) && t <= D3DTS_WORLDMATRIX(255)))
1333             return NULL;
1334         index = 10 + (t - D3DTS_WORLDMATRIX(0));
1335         break;
1336     }
1337
1338     if (index >= state->ff.num_transforms) {
1339         unsigned N = index + 1;
1340         unsigned n = state->ff.num_transforms;
1341
1342         if (!alloc)
1343             return &Identity;
1344         state->ff.transform = REALLOC(state->ff.transform,
1345                                       n * sizeof(D3DMATRIX),
1346                                       N * sizeof(D3DMATRIX));
1347         for (; n < N; ++n)
1348             state->ff.transform[n] = Identity;
1349         state->ff.num_transforms = N;
1350     }
1351     return &state->ff.transform[index];
1352 }
1353
1354 #define D3DRS_TO_STRING_CASE(n) case D3DRS_##n: return "D3DRS_"#n
1355 const char *nine_d3drs_to_string(DWORD State)
1356 {
1357     switch (State) {
1358     D3DRS_TO_STRING_CASE(ZENABLE);
1359     D3DRS_TO_STRING_CASE(FILLMODE);
1360     D3DRS_TO_STRING_CASE(SHADEMODE);
1361     D3DRS_TO_STRING_CASE(ZWRITEENABLE);
1362     D3DRS_TO_STRING_CASE(ALPHATESTENABLE);
1363     D3DRS_TO_STRING_CASE(LASTPIXEL);
1364     D3DRS_TO_STRING_CASE(SRCBLEND);
1365     D3DRS_TO_STRING_CASE(DESTBLEND);
1366     D3DRS_TO_STRING_CASE(CULLMODE);
1367     D3DRS_TO_STRING_CASE(ZFUNC);
1368     D3DRS_TO_STRING_CASE(ALPHAREF);
1369     D3DRS_TO_STRING_CASE(ALPHAFUNC);
1370     D3DRS_TO_STRING_CASE(DITHERENABLE);
1371     D3DRS_TO_STRING_CASE(ALPHABLENDENABLE);
1372     D3DRS_TO_STRING_CASE(FOGENABLE);
1373     D3DRS_TO_STRING_CASE(SPECULARENABLE);
1374     D3DRS_TO_STRING_CASE(FOGCOLOR);
1375     D3DRS_TO_STRING_CASE(FOGTABLEMODE);
1376     D3DRS_TO_STRING_CASE(FOGSTART);
1377     D3DRS_TO_STRING_CASE(FOGEND);
1378     D3DRS_TO_STRING_CASE(FOGDENSITY);
1379     D3DRS_TO_STRING_CASE(RANGEFOGENABLE);
1380     D3DRS_TO_STRING_CASE(STENCILENABLE);
1381     D3DRS_TO_STRING_CASE(STENCILFAIL);
1382     D3DRS_TO_STRING_CASE(STENCILZFAIL);
1383     D3DRS_TO_STRING_CASE(STENCILPASS);
1384     D3DRS_TO_STRING_CASE(STENCILFUNC);
1385     D3DRS_TO_STRING_CASE(STENCILREF);
1386     D3DRS_TO_STRING_CASE(STENCILMASK);
1387     D3DRS_TO_STRING_CASE(STENCILWRITEMASK);
1388     D3DRS_TO_STRING_CASE(TEXTUREFACTOR);
1389     D3DRS_TO_STRING_CASE(WRAP0);
1390     D3DRS_TO_STRING_CASE(WRAP1);
1391     D3DRS_TO_STRING_CASE(WRAP2);
1392     D3DRS_TO_STRING_CASE(WRAP3);
1393     D3DRS_TO_STRING_CASE(WRAP4);
1394     D3DRS_TO_STRING_CASE(WRAP5);
1395     D3DRS_TO_STRING_CASE(WRAP6);
1396     D3DRS_TO_STRING_CASE(WRAP7);
1397     D3DRS_TO_STRING_CASE(CLIPPING);
1398     D3DRS_TO_STRING_CASE(LIGHTING);
1399     D3DRS_TO_STRING_CASE(AMBIENT);
1400     D3DRS_TO_STRING_CASE(FOGVERTEXMODE);
1401     D3DRS_TO_STRING_CASE(COLORVERTEX);
1402     D3DRS_TO_STRING_CASE(LOCALVIEWER);
1403     D3DRS_TO_STRING_CASE(NORMALIZENORMALS);
1404     D3DRS_TO_STRING_CASE(DIFFUSEMATERIALSOURCE);
1405     D3DRS_TO_STRING_CASE(SPECULARMATERIALSOURCE);
1406     D3DRS_TO_STRING_CASE(AMBIENTMATERIALSOURCE);
1407     D3DRS_TO_STRING_CASE(EMISSIVEMATERIALSOURCE);
1408     D3DRS_TO_STRING_CASE(VERTEXBLEND);
1409     D3DRS_TO_STRING_CASE(CLIPPLANEENABLE);
1410     D3DRS_TO_STRING_CASE(POINTSIZE);
1411     D3DRS_TO_STRING_CASE(POINTSIZE_MIN);
1412     D3DRS_TO_STRING_CASE(POINTSPRITEENABLE);
1413     D3DRS_TO_STRING_CASE(POINTSCALEENABLE);
1414     D3DRS_TO_STRING_CASE(POINTSCALE_A);
1415     D3DRS_TO_STRING_CASE(POINTSCALE_B);
1416     D3DRS_TO_STRING_CASE(POINTSCALE_C);
1417     D3DRS_TO_STRING_CASE(MULTISAMPLEANTIALIAS);
1418     D3DRS_TO_STRING_CASE(MULTISAMPLEMASK);
1419     D3DRS_TO_STRING_CASE(PATCHEDGESTYLE);
1420     D3DRS_TO_STRING_CASE(DEBUGMONITORTOKEN);
1421     D3DRS_TO_STRING_CASE(POINTSIZE_MAX);
1422     D3DRS_TO_STRING_CASE(INDEXEDVERTEXBLENDENABLE);
1423     D3DRS_TO_STRING_CASE(COLORWRITEENABLE);
1424     D3DRS_TO_STRING_CASE(TWEENFACTOR);
1425     D3DRS_TO_STRING_CASE(BLENDOP);
1426     D3DRS_TO_STRING_CASE(POSITIONDEGREE);
1427     D3DRS_TO_STRING_CASE(NORMALDEGREE);
1428     D3DRS_TO_STRING_CASE(SCISSORTESTENABLE);
1429     D3DRS_TO_STRING_CASE(SLOPESCALEDEPTHBIAS);
1430     D3DRS_TO_STRING_CASE(ANTIALIASEDLINEENABLE);
1431     D3DRS_TO_STRING_CASE(MINTESSELLATIONLEVEL);
1432     D3DRS_TO_STRING_CASE(MAXTESSELLATIONLEVEL);
1433     D3DRS_TO_STRING_CASE(ADAPTIVETESS_X);
1434     D3DRS_TO_STRING_CASE(ADAPTIVETESS_Y);
1435     D3DRS_TO_STRING_CASE(ADAPTIVETESS_Z);
1436     D3DRS_TO_STRING_CASE(ADAPTIVETESS_W);
1437     D3DRS_TO_STRING_CASE(ENABLEADAPTIVETESSELLATION);
1438     D3DRS_TO_STRING_CASE(TWOSIDEDSTENCILMODE);
1439     D3DRS_TO_STRING_CASE(CCW_STENCILFAIL);
1440     D3DRS_TO_STRING_CASE(CCW_STENCILZFAIL);
1441     D3DRS_TO_STRING_CASE(CCW_STENCILPASS);
1442     D3DRS_TO_STRING_CASE(CCW_STENCILFUNC);
1443     D3DRS_TO_STRING_CASE(COLORWRITEENABLE1);
1444     D3DRS_TO_STRING_CASE(COLORWRITEENABLE2);
1445     D3DRS_TO_STRING_CASE(COLORWRITEENABLE3);
1446     D3DRS_TO_STRING_CASE(BLENDFACTOR);
1447     D3DRS_TO_STRING_CASE(SRGBWRITEENABLE);
1448     D3DRS_TO_STRING_CASE(DEPTHBIAS);
1449     D3DRS_TO_STRING_CASE(WRAP8);
1450     D3DRS_TO_STRING_CASE(WRAP9);
1451     D3DRS_TO_STRING_CASE(WRAP10);
1452     D3DRS_TO_STRING_CASE(WRAP11);
1453     D3DRS_TO_STRING_CASE(WRAP12);
1454     D3DRS_TO_STRING_CASE(WRAP13);
1455     D3DRS_TO_STRING_CASE(WRAP14);
1456     D3DRS_TO_STRING_CASE(WRAP15);
1457     D3DRS_TO_STRING_CASE(SEPARATEALPHABLENDENABLE);
1458     D3DRS_TO_STRING_CASE(SRCBLENDALPHA);
1459     D3DRS_TO_STRING_CASE(DESTBLENDALPHA);
1460     D3DRS_TO_STRING_CASE(BLENDOPALPHA);
1461     default:
1462         return "(invalid)";
1463     }
1464 }
1465