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