src/gallium/state_trackers/nine/device9.c

   1 /*
   2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  22
  23 #include "device9.h"
  24 #include "stateblock9.h"
  25 #include "surface9.h"
  26 #include "swapchain9.h"
  27 #include "swapchain9ex.h"
  28 #include "indexbuffer9.h"
  29 #include "vertexbuffer9.h"
  30 #include "vertexdeclaration9.h"
  31 #include "vertexshader9.h"
  32 #include "pixelshader9.h"
  33 #include "query9.h"
  34 #include "texture9.h"
  35 #include "cubetexture9.h"
  36 #include "volumetexture9.h"
  37 #include "nine_helpers.h"
  38 #include "nine_pipe.h"
  39 #include "nine_ff.h"
  40 #include "nine_dump.h"
  41
  42 #include "pipe/p_screen.h"
  43 #include "pipe/p_context.h"
  44 #include "util/u_math.h"
  45 #include "util/u_inlines.h"
  46 #include "util/u_hash_table.h"
  47 #include "util/u_format.h"
  48 #include "util/u_surface.h"
  49 #include "util/u_upload_mgr.h"
  50 #include "hud/hud_context.h"
  51
  52 #include "cso_cache/cso_context.h"
  53
  54 #define DBG_CHANNEL DBG_DEVICE
  55
  56 static void
  57 NineDevice9_SetDefaultState( struct NineDevice9 *This, boolean is_reset )
  58 {
  59     struct NineSurface9 *refSurf = NULL;
  60
  61     DBG("This=%p is_reset=%d\n", This, (int) is_reset);
  62
  63     assert(!This->is_recording);
  64
  65     nine_state_set_defaults(This, &This->caps, is_reset);
  66
  67     This->state.viewport.X = 0;
  68     This->state.viewport.Y = 0;
  69     This->state.viewport.Width = 0;
  70     This->state.viewport.Height = 0;
  71
  72     This->state.scissor.minx = 0;
  73     This->state.scissor.miny = 0;
  74     This->state.scissor.maxx = 0xffff;
  75     This->state.scissor.maxy = 0xffff;
  76
  77     if (This->nswapchains && This->swapchains[0]->params.BackBufferCount)
  78         refSurf = This->swapchains[0]->buffers[0];
  79
  80     if (refSurf) {
  81         This->state.viewport.Width = refSurf->desc.Width;
  82         This->state.viewport.Height = refSurf->desc.Height;
  83         This->state.scissor.maxx = refSurf->desc.Width;
  84         This->state.scissor.maxy = refSurf->desc.Height;
  85     }
  86
  87     if (This->nswapchains && This->swapchains[0]->params.EnableAutoDepthStencil)
  88         This->state.rs[D3DRS_ZENABLE] = TRUE;
  89     if (This->state.rs[D3DRS_ZENABLE])
  90         NineDevice9_SetDepthStencilSurface(
  91             This, (IDirect3DSurface9 *)This->swapchains[0]->zsbuf);
  92 }
  93
  94 void
  95 NineDevice9_RestoreNonCSOState( struct NineDevice9 *This, unsigned mask )
  96 {
  97     struct pipe_context *pipe = This->pipe;
  98
  99     DBG("This=%p mask=%u\n", This, mask);
 100
 101     if (mask & 0x1) {
 102         struct pipe_constant_buffer cb;
 103         cb.buffer_offset = 0;
 104
 105         if (This->prefer_user_constbuf) {
 106             cb.buffer = NULL;
 107             cb.user_buffer = This->state.vs_const_f;
 108         } else {
 109             cb.buffer = This->constbuf_vs;
 110             cb.user_buffer = NULL;
 111         }
 112         cb.buffer_size = This->vs_const_size;
 113         pipe->set_constant_buffer(pipe, PIPE_SHADER_VERTEX, 0, &cb);
 114
 115         if (This->prefer_user_constbuf) {
 116             cb.user_buffer = This->state.ps_const_f;
 117         } else {
 118             cb.buffer = This->constbuf_ps;
 119         }
 120         cb.buffer_size = This->ps_const_size;
 121         pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, 0, &cb);
 122     }
 123
 124     if (mask & 0x2) {
 125         struct pipe_poly_stipple stipple;
 126         memset(&stipple, ~0, sizeof(stipple));
 127         pipe->set_polygon_stipple(pipe, &stipple);
 128     }
 129
 130     This->state.changed.group = NINE_STATE_ALL;
 131     This->state.changed.vtxbuf = (1ULL << This->caps.MaxStreams) - 1;
 132     This->state.changed.ucp = (1 << PIPE_MAX_CLIP_PLANES) - 1;
 133     This->state.changed.texture = NINE_PS_SAMPLERS_MASK | NINE_VS_SAMPLERS_MASK;
 134 }
 135
 136 #define GET_PCAP(n) pScreen->get_param(pScreen, PIPE_CAP_##n)
 137 HRESULT
 138 NineDevice9_ctor( struct NineDevice9 *This,
 139                   struct NineUnknownParams *pParams,
 140                   struct pipe_screen *pScreen,
 141                   D3DDEVICE_CREATION_PARAMETERS *pCreationParameters,
 142                   D3DCAPS9 *pCaps,
 143                   D3DPRESENT_PARAMETERS *pPresentationParameters,
 144                   IDirect3D9 *pD3D9,
 145                   ID3DPresentGroup *pPresentationGroup,
 146                   struct d3dadapter9_context *pCTX,
 147                   boolean ex,
 148                   D3DDISPLAYMODEEX *pFullscreenDisplayMode )
 149 {
 150     unsigned i;
 151     HRESULT hr = NineUnknown_ctor(&This->base, pParams);
 152
 153     DBG("This=%p pParams=%p pScreen=%p pCreationParameters=%p pCaps=%p pPresentationParameters=%p "
 154         "pD3D9=%p pPresentationGroup=%p pCTX=%p ex=%d pFullscreenDisplayMode=%p\n",
 155         This, pParams, pScreen, pCreationParameters, pCaps, pPresentationParameters, pD3D9,
 156         pPresentationGroup, pCTX, (int) ex, pFullscreenDisplayMode);
 157
 158     if (FAILED(hr)) { return hr; }
 159
 160     list_inithead(&This->update_textures);
 161
 162     This->screen = pScreen;
 163     This->caps = *pCaps;
 164     This->d3d9 = pD3D9;
 165     This->params = *pCreationParameters;
 166     This->ex = ex;
 167     This->present = pPresentationGroup;
 168     IDirect3D9_AddRef(This->d3d9);
 169     ID3DPresentGroup_AddRef(This->present);
 170
 171     This->pipe = This->screen->context_create(This->screen, NULL);
 172     if (!This->pipe) { return E_OUTOFMEMORY; } /* guess */
 173
 174     This->cso = cso_create_context(This->pipe);
 175     if (!This->cso) { return E_OUTOFMEMORY; } /* also a guess */
 176
 177     /* Create first, it messes up our state. */
 178     This->hud = hud_create(This->pipe, This->cso); /* NULL result is fine */
 179
 180     /* create implicit swapchains */
 181     This->nswapchains = ID3DPresentGroup_GetMultiheadCount(This->present);
 182     This->swapchains = CALLOC(This->nswapchains,
 183                               sizeof(struct NineSwapChain9 *));
 184     if (!This->swapchains) { return E_OUTOFMEMORY; }
 185
 186     for (i = 0; i < This->nswapchains; ++i) {
 187         ID3DPresent *present;
 188
 189         hr = ID3DPresentGroup_GetPresent(This->present, i, &present);
 190         if (FAILED(hr))
 191             return hr;
 192
 193         if (ex) {
 194             D3DDISPLAYMODEEX *mode = NULL;
 195             struct NineSwapChain9Ex **ret =
 196                 (struct NineSwapChain9Ex **)&This->swapchains[i];
 197
 198             if (pFullscreenDisplayMode) mode = &(pFullscreenDisplayMode[i]);
 199             /* when this is a Device9Ex, it should create SwapChain9Exs */
 200             hr = NineSwapChain9Ex_new(This, TRUE, present,
 201                                       &pPresentationParameters[i], pCTX,
 202                                       This->params.hFocusWindow, mode, ret);
 203         } else {
 204             hr = NineSwapChain9_new(This, TRUE, present,
 205                                     &pPresentationParameters[i], pCTX,
 206                                     This->params.hFocusWindow,
 207                                     &This->swapchains[i]);
 208         }
 209
 210         ID3DPresent_Release(present);
 211         if (FAILED(hr))
 212             return hr;
 213         NineUnknown_ConvertRefToBind(NineUnknown(This->swapchains[i]));
 214
 215         hr = NineSwapChain9_GetBackBuffer(This->swapchains[i], 0,
 216                                           D3DBACKBUFFER_TYPE_MONO,
 217                                           (IDirect3DSurface9 **)
 218                                           &This->state.rt[i]);
 219         if (FAILED(hr))
 220             return hr;
 221         NineUnknown_ConvertRefToBind(NineUnknown(This->state.rt[i]));
 222     }
 223
 224     /* Initialize a dummy VBO to be used when a a vertex declaration does not
 225      * specify all the inputs needed by vertex shader, on win default behavior
 226      * is to pass 0,0,0,0 to the shader */
 227     {
 228         struct pipe_transfer *transfer;
 229         struct pipe_resource tmpl;
 230         struct pipe_box box;
 231         unsigned char *data;
 232
 233         tmpl.target = PIPE_BUFFER;
 234         tmpl.format = PIPE_FORMAT_R8_UNORM;
 235         tmpl.width0 = 16; /* 4 floats */
 236         tmpl.height0 = 1;
 237         tmpl.depth0 = 1;
 238         tmpl.array_size = 1;
 239         tmpl.last_level = 0;
 240         tmpl.nr_samples = 0;
 241         tmpl.usage = PIPE_USAGE_DEFAULT;
 242         tmpl.bind = PIPE_BIND_VERTEX_BUFFER | PIPE_BIND_TRANSFER_WRITE;
 243         tmpl.flags = 0;
 244         This->dummy_vbo = pScreen->resource_create(pScreen, &tmpl);
 245
 246         if (!This->dummy_vbo)
 247             return D3DERR_OUTOFVIDEOMEMORY;
 248
 249         u_box_1d(0, 16, &box);
 250         data = This->pipe->transfer_map(This->pipe, This->dummy_vbo, 0,
 251                                         PIPE_TRANSFER_WRITE |
 252                                         PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
 253                                         &box, &transfer);
 254         assert(data);
 255         assert(transfer);
 256         memset(data, 0, 16);
 257         This->pipe->transfer_unmap(This->pipe, transfer);
 258     }
 259
 260     This->cursor.software = FALSE;
 261     This->cursor.hotspot.x = -1;
 262     This->cursor.hotspot.y = -1;
 263     {
 264         struct pipe_resource tmpl;
 265         tmpl.target = PIPE_TEXTURE_2D;
 266         tmpl.format = PIPE_FORMAT_R8G8B8A8_UNORM;
 267         tmpl.width0 = 64;
 268         tmpl.height0 = 64;
 269         tmpl.depth0 = 1;
 270         tmpl.array_size = 1;
 271         tmpl.last_level = 0;
 272         tmpl.nr_samples = 0;
 273         tmpl.usage = PIPE_USAGE_DEFAULT;
 274         tmpl.bind = PIPE_BIND_CURSOR | PIPE_BIND_SAMPLER_VIEW;
 275         tmpl.flags = 0;
 276
 277         This->cursor.image = pScreen->resource_create(pScreen, &tmpl);
 278         if (!This->cursor.image)
 279             return D3DERR_OUTOFVIDEOMEMORY;
 280     }
 281
 282     /* Create constant buffers. */
 283     {
 284         struct pipe_resource tmpl;
 285         unsigned max_const_vs, max_const_ps;
 286
 287         /* vs 3.0: >= 256 float constants, but for cards with exactly 256 slots,
 288          * we have to take in some more slots for int and bool*/
 289         max_const_vs = _min(pScreen->get_shader_param(pScreen, PIPE_SHADER_VERTEX,
 290                                 PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) /
 291                                 sizeof(float[4]),
 292                             NINE_MAX_CONST_ALL);
 293         /* ps 3.0: 224 float constants. All cards supported support at least
 294          * 256 constants for ps */
 295         max_const_ps = NINE_MAX_CONST_F_PS3 + (NINE_MAX_CONST_I + NINE_MAX_CONST_B / 4);
 296
 297         This->max_vs_const_f = max_const_vs -
 298                                (NINE_MAX_CONST_I + NINE_MAX_CONST_B / 4);
 299         This->max_ps_const_f = max_const_ps -
 300                                (NINE_MAX_CONST_I + NINE_MAX_CONST_B / 4);
 301
 302         This->vs_const_size = max_const_vs * sizeof(float[4]);
 303         This->ps_const_size = max_const_ps * sizeof(float[4]);
 304         /* Include space for I,B constants for user constbuf. */
 305         This->state.vs_const_f = CALLOC(This->vs_const_size, 1);
 306         This->state.ps_const_f = CALLOC(This->ps_const_size, 1);
 307         This->state.vs_lconstf_temp = CALLOC(This->vs_const_size,1);
 308         if (!This->state.vs_const_f || !This->state.ps_const_f ||
 309             !This->state.vs_lconstf_temp)
 310             return E_OUTOFMEMORY;
 311
 312         if (strstr(pScreen->get_name(pScreen), "AMD") ||
 313             strstr(pScreen->get_name(pScreen), "ATI"))
 314             This->prefer_user_constbuf = TRUE;
 315
 316         tmpl.target = PIPE_BUFFER;
 317         tmpl.format = PIPE_FORMAT_R8_UNORM;
 318         tmpl.height0 = 1;
 319         tmpl.depth0 = 1;
 320         tmpl.array_size = 1;
 321         tmpl.last_level = 0;
 322         tmpl.nr_samples = 0;
 323         tmpl.usage = PIPE_USAGE_DYNAMIC;
 324         tmpl.bind = PIPE_BIND_CONSTANT_BUFFER;
 325         tmpl.flags = 0;
 326
 327         tmpl.width0 = This->vs_const_size;
 328         This->constbuf_vs = pScreen->resource_create(pScreen, &tmpl);
 329
 330         tmpl.width0 = This->ps_const_size;
 331         This->constbuf_ps = pScreen->resource_create(pScreen, &tmpl);
 332
 333         if (!This->constbuf_vs || !This->constbuf_ps)
 334             return E_OUTOFMEMORY;
 335     }
 336
 337     /* allocate dummy texture/sampler for when there are missing ones bound */
 338     {
 339         struct pipe_resource tmplt;
 340         struct pipe_sampler_view templ;
 341
 342         tmplt.target = PIPE_TEXTURE_2D;
 343         tmplt.width0 = 1;
 344         tmplt.height0 = 1;
 345         tmplt.depth0 = 1;
 346         tmplt.last_level = 0;
 347         tmplt.array_size = 1;
 348         tmplt.usage = PIPE_USAGE_DEFAULT;
 349         tmplt.flags = 0;
 350         tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM;
 351         tmplt.bind = PIPE_BIND_SAMPLER_VIEW;
 352         tmplt.nr_samples = 0;
 353
 354         This->dummy_texture = This->screen->resource_create(This->screen, &tmplt);
 355         if (!This->dummy_texture)
 356             return D3DERR_DRIVERINTERNALERROR;
 357
 358         templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
 359         templ.u.tex.first_layer = 0;
 360         templ.u.tex.last_layer = 0;
 361         templ.u.tex.first_level = 0;
 362         templ.u.tex.last_level = 0;
 363         templ.swizzle_r = PIPE_SWIZZLE_ZERO;
 364         templ.swizzle_g = PIPE_SWIZZLE_ZERO;
 365         templ.swizzle_b = PIPE_SWIZZLE_ZERO;
 366         templ.swizzle_a = PIPE_SWIZZLE_ONE;
 367         templ.target = This->dummy_texture->target;
 368
 369         This->dummy_sampler = This->pipe->create_sampler_view(This->pipe, This->dummy_texture, &templ);
 370         if (!This->dummy_sampler)
 371             return D3DERR_DRIVERINTERNALERROR;
 372     }
 373
 374     /* Allocate upload helper for drivers that suck (from st pov ;). */
 375     {
 376         unsigned bind = 0;
 377
 378         This->driver_caps.user_vbufs = GET_PCAP(USER_VERTEX_BUFFERS);
 379         This->driver_caps.user_ibufs = GET_PCAP(USER_INDEX_BUFFERS);
 380
 381         if (!This->driver_caps.user_vbufs) bind |= PIPE_BIND_VERTEX_BUFFER;
 382         if (!This->driver_caps.user_ibufs) bind |= PIPE_BIND_INDEX_BUFFER;
 383         if (bind)
 384             This->upload = u_upload_create(This->pipe, 1 << 20, 4, bind);
 385     }
 386
 387     This->driver_caps.window_space_position_support = GET_PCAP(TGSI_VS_WINDOW_SPACE_POSITION);
 388     This->driver_caps.vs_integer = pScreen->get_shader_param(pScreen, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_INTEGERS);
 389     This->driver_caps.ps_integer = pScreen->get_shader_param(pScreen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS);
 390
 391     nine_ff_init(This); /* initialize fixed function code */
 392
 393     NineDevice9_SetDefaultState(This, FALSE);
 394     NineDevice9_RestoreNonCSOState(This, ~0);
 395
 396     This->update = &This->state;
 397     nine_update_state(This, ~0);
 398
 399     ID3DPresentGroup_Release(This->present);
 400
 401     return D3D_OK;
 402 }
 403 #undef GET_PCAP
 404
 405 void
 406 NineDevice9_dtor( struct NineDevice9 *This )
 407 {
 408     unsigned i;
 409
 410     DBG("This=%p\n", This);
 411
 412     if (This->pipe && This->cso)
 413         nine_pipe_context_clear(This);
 414     nine_ff_fini(This);
 415     nine_state_clear(&This->state, TRUE);
 416
 417     if (This->upload)
 418         u_upload_destroy(This->upload);
 419
 420     nine_bind(&This->record, NULL);
 421
 422     pipe_sampler_view_reference(&This->dummy_sampler, NULL);
 423     pipe_resource_reference(&This->dummy_texture, NULL);
 424     pipe_resource_reference(&This->constbuf_vs, NULL);
 425     pipe_resource_reference(&This->constbuf_ps, NULL);
 426     pipe_resource_reference(&This->dummy_vbo, NULL);
 427     FREE(This->state.vs_const_f);
 428     FREE(This->state.ps_const_f);
 429     FREE(This->state.vs_lconstf_temp);
 430
 431     if (This->swapchains) {
 432         for (i = 0; i < This->nswapchains; ++i)
 433             NineUnknown_Unbind(NineUnknown(This->swapchains[i]));
 434         FREE(This->swapchains);
 435     }
 436
 437     /* state stuff */
 438     if (This->pipe) {
 439         if (This->cso) {
 440             cso_destroy_context(This->cso);
 441         }
 442         if (This->pipe->destroy) { This->pipe->destroy(This->pipe); }
 443     }
 444
 445     if (This->present) { ID3DPresentGroup_Release(This->present); }
 446     if (This->d3d9) { IDirect3D9_Release(This->d3d9); }
 447
 448     NineUnknown_dtor(&This->base);
 449 }
 450
 451 struct pipe_screen *
 452 NineDevice9_GetScreen( struct NineDevice9 *This )
 453 {
 454     return This->screen;
 455 }
 456
 457 struct pipe_context *
 458 NineDevice9_GetPipe( struct NineDevice9 *This )
 459 {
 460     return This->pipe;
 461 }
 462
 463 struct cso_context *
 464 NineDevice9_GetCSO( struct NineDevice9 *This )
 465 {
 466     return This->cso;
 467 }
 468
 469 const D3DCAPS9 *
 470 NineDevice9_GetCaps( struct NineDevice9 *This )
 471 {
 472     return &This->caps;
 473 }
 474
 475 static INLINE void
 476 NineDevice9_PauseRecording( struct NineDevice9 *This )
 477 {
 478     if (This->record) {
 479         This->update = &This->state;
 480         This->is_recording = FALSE;
 481     }
 482 }
 483
 484 static INLINE void
 485 NineDevice9_ResumeRecording( struct NineDevice9 *This )
 486 {
 487     if (This->record) {
 488         This->update = &This->record->state;
 489         This->is_recording = TRUE;
 490     }
 491 }
 492
 493 HRESULT WINAPI
 494 NineDevice9_TestCooperativeLevel( struct NineDevice9 *This )
 495 {
 496     return D3D_OK; /* TODO */
 497 }
 498
 499 UINT WINAPI
 500 NineDevice9_GetAvailableTextureMem( struct NineDevice9 *This )
 501 {
 502    const unsigned mem = This->screen->get_param(This->screen, PIPE_CAP_VIDEO_MEMORY);
 503    if (mem < 4096)
 504       return mem << 20;
 505    else
 506       return UINT_MAX;
 507 }
 508
 509 HRESULT WINAPI
 510 NineDevice9_EvictManagedResources( struct NineDevice9 *This )
 511 {
 512     /* We don't really need to do anything here, but might want to free up
 513      * the GPU virtual address space by killing pipe_resources.
 514      */
 515     STUB(D3D_OK);
 516 }
 517
 518 HRESULT WINAPI
 519 NineDevice9_GetDirect3D( struct NineDevice9 *This,
 520                          IDirect3D9 **ppD3D9 )
 521 {
 522     user_assert(ppD3D9 != NULL, E_POINTER);
 523     IDirect3D9_AddRef(This->d3d9);
 524     *ppD3D9 = This->d3d9;
 525     return D3D_OK;
 526 }
 527
 528 HRESULT WINAPI
 529 NineDevice9_GetDeviceCaps( struct NineDevice9 *This,
 530                            D3DCAPS9 *pCaps )
 531 {
 532     user_assert(pCaps != NULL, D3DERR_INVALIDCALL);
 533     *pCaps = This->caps;
 534     return D3D_OK;
 535 }
 536
 537 HRESULT WINAPI
 538 NineDevice9_GetDisplayMode( struct NineDevice9 *This,
 539                             UINT iSwapChain,
 540                             D3DDISPLAYMODE *pMode )
 541 {
 542     DBG("This=%p iSwapChain=%u pMode=%p\n", This, iSwapChain, pMode);
 543
 544     user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
 545
 546     return NineSwapChain9_GetDisplayMode(This->swapchains[iSwapChain], pMode);
 547 }
 548
 549 HRESULT WINAPI
 550 NineDevice9_GetCreationParameters( struct NineDevice9 *This,
 551                                    D3DDEVICE_CREATION_PARAMETERS *pParameters )
 552 {
 553     user_assert(pParameters != NULL, D3DERR_INVALIDCALL);
 554     *pParameters = This->params;
 555     return D3D_OK;
 556 }
 557
 558 HRESULT WINAPI
 559 NineDevice9_SetCursorProperties( struct NineDevice9 *This,
 560                                  UINT XHotSpot,
 561                                  UINT YHotSpot,
 562                                  IDirect3DSurface9 *pCursorBitmap )
 563 {
 564     /* TODO: hardware cursor */
 565     struct NineSurface9 *surf = NineSurface9(pCursorBitmap);
 566     struct pipe_context *pipe = This->pipe;
 567     struct pipe_box box;
 568     struct pipe_transfer *transfer;
 569     void *ptr;
 570
 571     DBG_FLAG(DBG_SWAPCHAIN, "This=%p XHotSpot=%u YHotSpot=%u "
 572              "pCursorBitmap=%p\n", This, XHotSpot, YHotSpot, pCursorBitmap);
 573
 574     user_assert(pCursorBitmap, D3DERR_INVALIDCALL);
 575
 576     This->cursor.w = MIN2(surf->desc.Width, This->cursor.image->width0);
 577     This->cursor.h = MIN2(surf->desc.Height, This->cursor.image->height0);
 578
 579     u_box_origin_2d(This->cursor.w, This->cursor.h, &box);
 580
 581     ptr = pipe->transfer_map(pipe, This->cursor.image, 0,
 582                              PIPE_TRANSFER_WRITE |
 583                              PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
 584                              &box, &transfer);
 585     if (!ptr)
 586         ret_err("Failed to update cursor image.\n", D3DERR_DRIVERINTERNALERROR);
 587
 588     This->cursor.hotspot.x = XHotSpot;
 589     This->cursor.hotspot.y = YHotSpot;
 590
 591     /* Copy cursor image to internal storage. */
 592     {
 593         D3DLOCKED_RECT lock;
 594         HRESULT hr;
 595         const struct util_format_description *sfmt =
 596             util_format_description(surf->base.info.format);
 597         assert(sfmt);
 598
 599         hr = NineSurface9_LockRect(surf, &lock, NULL, D3DLOCK_READONLY);
 600         if (FAILED(hr))
 601             ret_err("Failed to map cursor source image.\n",
 602                     D3DERR_DRIVERINTERNALERROR);
 603
 604         sfmt->unpack_rgba_8unorm(ptr, transfer->stride,
 605                                  lock.pBits, lock.Pitch,
 606                                  This->cursor.w, This->cursor.h);
 607
 608         if (!This->cursor.software &&
 609             This->cursor.w == 32 && This->cursor.h == 32)
 610             ID3DPresent_SetCursor(This->swapchains[0]->present,
 611                                   lock.pBits, &This->cursor.hotspot,
 612                                   This->cursor.visible);
 613
 614         NineSurface9_UnlockRect(surf);
 615     }
 616     pipe->transfer_unmap(pipe, transfer);
 617
 618     return D3D_OK;
 619 }
 620
 621 void WINAPI
 622 NineDevice9_SetCursorPosition( struct NineDevice9 *This,
 623                                int X,
 624                                int Y,
 625                                DWORD Flags )
 626 {
 627     struct NineSwapChain9 *swap = This->swapchains[0];
 628
 629     DBG("This=%p X=%d Y=%d Flags=%d\n", This, X, Y, Flags);
 630
 631     This->cursor.pos.x = X;
 632     This->cursor.pos.y = Y;
 633
 634     if (!This->cursor.software)
 635         ID3DPresent_SetCursorPos(swap->present, &This->cursor.pos);
 636 }
 637
 638 BOOL WINAPI
 639 NineDevice9_ShowCursor( struct NineDevice9 *This,
 640                         BOOL bShow )
 641 {
 642     BOOL old = This->cursor.visible;
 643
 644     DBG("This=%p bShow=%d\n", This, (int) bShow);
 645
 646     This->cursor.visible = bShow && (This->cursor.hotspot.x != -1);
 647     if (!This->cursor.software)
 648         ID3DPresent_SetCursor(This->swapchains[0]->present, NULL, NULL, bShow);
 649
 650     return old;
 651 }
 652
 653 HRESULT WINAPI
 654 NineDevice9_CreateAdditionalSwapChain( struct NineDevice9 *This,
 655                                        D3DPRESENT_PARAMETERS *pPresentationParameters,
 656                                        IDirect3DSwapChain9 **pSwapChain )
 657 {
 658     struct NineSwapChain9 *swapchain, *tmplt = This->swapchains[0];
 659     ID3DPresent *present;
 660     HRESULT hr;
 661
 662     DBG("This=%p pPresentationParameters=%p pSwapChain=%p\n",
 663         This, pPresentationParameters, pSwapChain);
 664
 665     user_assert(pPresentationParameters, D3DERR_INVALIDCALL);
 666
 667     hr = ID3DPresentGroup_CreateAdditionalPresent(This->present, pPresentationParameters, &present);
 668
 669     if (FAILED(hr))
 670         return hr;
 671
 672     hr = NineSwapChain9_new(This, FALSE, present, pPresentationParameters,
 673                             tmplt->actx,
 674                             tmplt->params.hDeviceWindow,
 675                             &swapchain);
 676     if (FAILED(hr))
 677         return hr;
 678
 679     *pSwapChain = (IDirect3DSwapChain9 *)swapchain;
 680     return D3D_OK;
 681 }
 682
 683 HRESULT WINAPI
 684 NineDevice9_GetSwapChain( struct NineDevice9 *This,
 685                           UINT iSwapChain,
 686                           IDirect3DSwapChain9 **pSwapChain )
 687 {
 688     user_assert(pSwapChain != NULL, D3DERR_INVALIDCALL);
 689
 690     *pSwapChain = NULL;
 691     user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
 692
 693     NineUnknown_AddRef(NineUnknown(This->swapchains[iSwapChain]));
 694     *pSwapChain = (IDirect3DSwapChain9 *)This->swapchains[iSwapChain];
 695
 696     return D3D_OK;
 697 }
 698
 699 UINT WINAPI
 700 NineDevice9_GetNumberOfSwapChains( struct NineDevice9 *This )
 701 {
 702     return This->nswapchains;
 703 }
 704
 705 HRESULT WINAPI
 706 NineDevice9_Reset( struct NineDevice9 *This,
 707                    D3DPRESENT_PARAMETERS *pPresentationParameters )
 708 {
 709     HRESULT hr = D3D_OK;
 710     unsigned i;
 711
 712     DBG("This=%p pPresentationParameters=%p\n", This, pPresentationParameters);
 713
 714     for (i = 0; i < This->nswapchains; ++i) {
 715         D3DPRESENT_PARAMETERS *params = &pPresentationParameters[i];
 716         hr = NineSwapChain9_Resize(This->swapchains[i], params, NULL);
 717         if (FAILED(hr))
 718             return (hr == D3DERR_OUTOFVIDEOMEMORY) ? hr : D3DERR_DEVICELOST;
 719     }
 720
 721     nine_pipe_context_clear(This);
 722     nine_state_clear(&This->state, TRUE);
 723
 724     NineDevice9_SetDefaultState(This, TRUE);
 725     NineDevice9_SetRenderTarget(
 726         This, 0, (IDirect3DSurface9 *)This->swapchains[0]->buffers[0]);
 727     /* XXX: better use GetBackBuffer here ? */
 728
 729     return hr;
 730 }
 731
 732 HRESULT WINAPI
 733 NineDevice9_Present( struct NineDevice9 *This,
 734                      const RECT *pSourceRect,
 735                      const RECT *pDestRect,
 736                      HWND hDestWindowOverride,
 737                      const RGNDATA *pDirtyRegion )
 738 {
 739     unsigned i;
 740     HRESULT hr;
 741
 742     DBG("This=%p pSourceRect=%p pDestRect=%p hDestWindowOverride=%p pDirtyRegion=%p\n",
 743         This, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
 744
 745     /* XXX is this right? */
 746     for (i = 0; i < This->nswapchains; ++i) {
 747         hr = NineSwapChain9_Present(This->swapchains[i], pSourceRect, pDestRect,
 748                                     hDestWindowOverride, pDirtyRegion, 0);
 749         if (FAILED(hr)) { return hr; }
 750     }
 751
 752     return D3D_OK;
 753 }
 754
 755 HRESULT WINAPI
 756 NineDevice9_GetBackBuffer( struct NineDevice9 *This,
 757                            UINT iSwapChain,
 758                            UINT iBackBuffer,
 759                            D3DBACKBUFFER_TYPE Type,
 760                            IDirect3DSurface9 **ppBackBuffer )
 761 {
 762     user_assert(ppBackBuffer != NULL, D3DERR_INVALIDCALL);
 763     user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
 764
 765     return NineSwapChain9_GetBackBuffer(This->swapchains[iSwapChain],
 766                                         iBackBuffer, Type, ppBackBuffer);
 767 }
 768
 769 HRESULT WINAPI
 770 NineDevice9_GetRasterStatus( struct NineDevice9 *This,
 771                              UINT iSwapChain,
 772                              D3DRASTER_STATUS *pRasterStatus )
 773 {
 774     user_assert(pRasterStatus != NULL, D3DERR_INVALIDCALL);
 775     user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
 776
 777     return NineSwapChain9_GetRasterStatus(This->swapchains[iSwapChain],
 778                                           pRasterStatus);
 779 }
 780
 781 HRESULT WINAPI
 782 NineDevice9_SetDialogBoxMode( struct NineDevice9 *This,
 783                               BOOL bEnableDialogs )
 784 {
 785     STUB(D3DERR_INVALIDCALL);
 786 }
 787
 788 void WINAPI
 789 NineDevice9_SetGammaRamp( struct NineDevice9 *This,
 790                           UINT iSwapChain,
 791                           DWORD Flags,
 792                           const D3DGAMMARAMP *pRamp )
 793 {
 794     DBG("This=%p iSwapChain=%u Flags=%x pRamp=%p\n", This,
 795         iSwapChain, Flags, pRamp);
 796
 797     user_warn(iSwapChain >= This->nswapchains);
 798     user_warn(!pRamp);
 799
 800     if (pRamp && (iSwapChain < This->nswapchains)) {
 801         struct NineSwapChain9 *swap = This->swapchains[iSwapChain];
 802         swap->gamma = *pRamp;
 803         ID3DPresent_SetGammaRamp(swap->present, pRamp, swap->params.hDeviceWindow);
 804     }
 805 }
 806
 807 void WINAPI
 808 NineDevice9_GetGammaRamp( struct NineDevice9 *This,
 809                           UINT iSwapChain,
 810                           D3DGAMMARAMP *pRamp )
 811 {
 812     DBG("This=%p iSwapChain=%u pRamp=%p\n", This, iSwapChain, pRamp);
 813
 814     user_warn(iSwapChain >= This->nswapchains);
 815     user_warn(!pRamp);
 816
 817     if (pRamp && (iSwapChain < This->nswapchains))
 818         *pRamp = This->swapchains[iSwapChain]->gamma;
 819 }
 820
 821 HRESULT WINAPI
 822 NineDevice9_CreateTexture( struct NineDevice9 *This,
 823                            UINT Width,
 824                            UINT Height,
 825                            UINT Levels,
 826                            DWORD Usage,
 827                            D3DFORMAT Format,
 828                            D3DPOOL Pool,
 829                            IDirect3DTexture9 **ppTexture,
 830                            HANDLE *pSharedHandle )
 831 {
 832     struct NineTexture9 *tex;
 833     HRESULT hr;
 834
 835     DBG("This=%p Width=%u Height=%u Levels=%u Usage=%s Format=%s Pool=%s "
 836         "ppOut=%p pSharedHandle=%p\n", This, Width, Height, Levels,
 837         nine_D3DUSAGE_to_str(Usage), d3dformat_to_string(Format),
 838         nine_D3DPOOL_to_str(Pool), ppTexture, pSharedHandle);
 839
 840     Usage &= D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_DEPTHSTENCIL | D3DUSAGE_DMAP |
 841              D3DUSAGE_DYNAMIC | D3DUSAGE_NONSECURE | D3DUSAGE_RENDERTARGET |
 842              D3DUSAGE_SOFTWAREPROCESSING | D3DUSAGE_TEXTAPI;
 843
 844     *ppTexture = NULL;
 845     user_assert(Width && Height, D3DERR_INVALIDCALL);
 846     user_assert(!pSharedHandle || This->ex, D3DERR_INVALIDCALL);
 847     /* When is used shared handle, Pool must be
 848      * SYSTEMMEM with Levels 1 or DEFAULT with any Levels */
 849     user_assert(!pSharedHandle || Pool != D3DPOOL_SYSTEMMEM || Levels == 1,
 850                 D3DERR_INVALIDCALL);
 851     user_assert(!pSharedHandle || Pool == D3DPOOL_SYSTEMMEM || Pool == D3DPOOL_DEFAULT,
 852                 D3DERR_INVALIDCALL);
 853     user_assert((Usage != D3DUSAGE_AUTOGENMIPMAP || Levels <= 1), D3DERR_INVALIDCALL);
 854
 855     hr = NineTexture9_new(This, Width, Height, Levels, Usage, Format, Pool,
 856                           &tex, pSharedHandle);
 857     if (SUCCEEDED(hr))
 858         *ppTexture = (IDirect3DTexture9 *)tex;
 859
 860     return hr;
 861 }
 862
 863 HRESULT WINAPI
 864 NineDevice9_CreateVolumeTexture( struct NineDevice9 *This,
 865                                  UINT Width,
 866                                  UINT Height,
 867                                  UINT Depth,
 868                                  UINT Levels,
 869                                  DWORD Usage,
 870                                  D3DFORMAT Format,
 871                                  D3DPOOL Pool,
 872                                  IDirect3DVolumeTexture9 **ppVolumeTexture,
 873                                  HANDLE *pSharedHandle )
 874 {
 875     struct NineVolumeTexture9 *tex;
 876     HRESULT hr;
 877
 878     DBG("This=%p Width=%u Height=%u Depth=%u Levels=%u Usage=%s Format=%s Pool=%s "
 879         "ppOut=%p pSharedHandle=%p\n", This, Width, Height, Depth, Levels,
 880         nine_D3DUSAGE_to_str(Usage), d3dformat_to_string(Format),
 881         nine_D3DPOOL_to_str(Pool), ppVolumeTexture, pSharedHandle);
 882
 883     Usage &= D3DUSAGE_DYNAMIC | D3DUSAGE_NONSECURE |
 884              D3DUSAGE_SOFTWAREPROCESSING;
 885
 886     *ppVolumeTexture = NULL;
 887     user_assert(Width && Height && Depth, D3DERR_INVALIDCALL);
 888     user_assert(!pSharedHandle || Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
 889
 890     hr = NineVolumeTexture9_new(This, Width, Height, Depth, Levels,
 891                                 Usage, Format, Pool, &tex, pSharedHandle);
 892     if (SUCCEEDED(hr))
 893         *ppVolumeTexture = (IDirect3DVolumeTexture9 *)tex;
 894
 895     return hr;
 896 }
 897
 898 HRESULT WINAPI
 899 NineDevice9_CreateCubeTexture( struct NineDevice9 *This,
 900                                UINT EdgeLength,
 901                                UINT Levels,
 902                                DWORD Usage,
 903                                D3DFORMAT Format,
 904                                D3DPOOL Pool,
 905                                IDirect3DCubeTexture9 **ppCubeTexture,
 906                                HANDLE *pSharedHandle )
 907 {
 908     struct NineCubeTexture9 *tex;
 909     HRESULT hr;
 910
 911     DBG("This=%p EdgeLength=%u Levels=%u Usage=%s Format=%s Pool=%s ppOut=%p "
 912         "pSharedHandle=%p\n", This, EdgeLength, Levels,
 913         nine_D3DUSAGE_to_str(Usage), d3dformat_to_string(Format),
 914         nine_D3DPOOL_to_str(Pool), ppCubeTexture, pSharedHandle);
 915
 916     Usage &= D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_DEPTHSTENCIL | D3DUSAGE_DYNAMIC |
 917              D3DUSAGE_NONSECURE | D3DUSAGE_RENDERTARGET |
 918              D3DUSAGE_SOFTWAREPROCESSING;
 919
 920     *ppCubeTexture = NULL;
 921     user_assert(EdgeLength, D3DERR_INVALIDCALL);
 922     user_assert(!pSharedHandle || Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
 923
 924     hr = NineCubeTexture9_new(This, EdgeLength, Levels, Usage, Format, Pool,
 925                               &tex, pSharedHandle);
 926     if (SUCCEEDED(hr))
 927         *ppCubeTexture = (IDirect3DCubeTexture9 *)tex;
 928
 929     return hr;
 930 }
 931
 932 HRESULT WINAPI
 933 NineDevice9_CreateVertexBuffer( struct NineDevice9 *This,
 934                                 UINT Length,
 935                                 DWORD Usage,
 936                                 DWORD FVF,
 937                                 D3DPOOL Pool,
 938                                 IDirect3DVertexBuffer9 **ppVertexBuffer,
 939                                 HANDLE *pSharedHandle )
 940 {
 941     struct NineVertexBuffer9 *buf;
 942     HRESULT hr;
 943     D3DVERTEXBUFFER_DESC desc;
 944
 945     DBG("This=%p Length=%u Usage=%x FVF=%x Pool=%u ppOut=%p pSharedHandle=%p\n",
 946         This, Length, Usage, FVF, Pool, ppVertexBuffer, pSharedHandle);
 947
 948     user_assert(!pSharedHandle || Pool == D3DPOOL_DEFAULT, D3DERR_NOTAVAILABLE);
 949
 950     desc.Format = D3DFMT_VERTEXDATA;
 951     desc.Type = D3DRTYPE_VERTEXBUFFER;
 952     desc.Usage = Usage &
 953         (D3DUSAGE_DONOTCLIP | D3DUSAGE_DYNAMIC | D3DUSAGE_NONSECURE |
 954          D3DUSAGE_NPATCHES | D3DUSAGE_POINTS | D3DUSAGE_RTPATCHES |
 955          D3DUSAGE_SOFTWAREPROCESSING | D3DUSAGE_TEXTAPI |
 956          D3DUSAGE_WRITEONLY);
 957     desc.Pool = Pool;
 958     desc.Size = Length;
 959     desc.FVF = FVF;
 960
 961     user_assert(!pSharedHandle || Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
 962     user_assert(desc.Usage == Usage, D3DERR_INVALIDCALL);
 963
 964     hr = NineVertexBuffer9_new(This, &desc, &buf);
 965     if (SUCCEEDED(hr))
 966         *ppVertexBuffer = (IDirect3DVertexBuffer9 *)buf;
 967     return hr;
 968 }
 969
 970 HRESULT WINAPI
 971 NineDevice9_CreateIndexBuffer( struct NineDevice9 *This,
 972                                UINT Length,
 973                                DWORD Usage,
 974                                D3DFORMAT Format,
 975                                D3DPOOL Pool,
 976                                IDirect3DIndexBuffer9 **ppIndexBuffer,
 977                                HANDLE *pSharedHandle )
 978 {
 979     struct NineIndexBuffer9 *buf;
 980     HRESULT hr;
 981     D3DINDEXBUFFER_DESC desc;
 982
 983     DBG("This=%p Length=%u Usage=%x Format=%s Pool=%u ppOut=%p "
 984         "pSharedHandle=%p\n", This, Length, Usage,
 985         d3dformat_to_string(Format), Pool, ppIndexBuffer, pSharedHandle);
 986
 987     user_assert(!pSharedHandle || Pool == D3DPOOL_DEFAULT, D3DERR_NOTAVAILABLE);
 988
 989     desc.Format = Format;
 990     desc.Type = D3DRTYPE_INDEXBUFFER;
 991     desc.Usage = Usage &
 992         (D3DUSAGE_DONOTCLIP | D3DUSAGE_DYNAMIC | D3DUSAGE_NONSECURE |
 993          D3DUSAGE_NPATCHES | D3DUSAGE_POINTS | D3DUSAGE_RTPATCHES |
 994          D3DUSAGE_SOFTWAREPROCESSING | D3DUSAGE_WRITEONLY);
 995     desc.Pool = Pool;
 996     desc.Size = Length;
 997
 998     user_assert(!pSharedHandle || Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
 999     user_assert(desc.Usage == Usage, D3DERR_INVALIDCALL);
1000
1001     hr = NineIndexBuffer9_new(This, &desc, &buf);
1002     if (SUCCEEDED(hr))
1003         *ppIndexBuffer = (IDirect3DIndexBuffer9 *)buf;
1004     return hr;
1005 }
1006
1007 static HRESULT
1008 create_zs_or_rt_surface(struct NineDevice9 *This,
1009                         unsigned type, /* 0 = RT, 1 = ZS, 2 = plain */
1010                         D3DPOOL Pool,
1011                         UINT Width, UINT Height,
1012                         D3DFORMAT Format,
1013                         D3DMULTISAMPLE_TYPE MultiSample,
1014                         DWORD MultisampleQuality,
1015                         BOOL Discard_or_Lockable,
1016                         IDirect3DSurface9 **ppSurface,
1017                         HANDLE *pSharedHandle)
1018 {
1019     struct NineSurface9 *surface;
1020     struct pipe_screen *screen = This->screen;
1021     struct pipe_resource *resource = NULL;
1022     HRESULT hr;
1023     D3DSURFACE_DESC desc;
1024     struct pipe_resource templ;
1025
1026     DBG("This=%p type=%u Pool=%s Width=%u Height=%u Format=%s MS=%u Quality=%u "
1027         "Discard_or_Lockable=%i ppSurface=%p pSharedHandle=%p\n",
1028         This, type, nine_D3DPOOL_to_str(Pool), Width, Height,
1029         d3dformat_to_string(Format), MultiSample, MultisampleQuality,
1030         Discard_or_Lockable, ppSurface, pSharedHandle);
1031
1032     if (pSharedHandle)
1033       DBG("FIXME Used shared handle! This option isn't probably handled correctly!\n");
1034
1035     user_assert(Width && Height, D3DERR_INVALIDCALL);
1036     user_assert(Pool != D3DPOOL_MANAGED, D3DERR_INVALIDCALL);
1037
1038     templ.target = PIPE_TEXTURE_2D;
1039     templ.width0 = Width;
1040     templ.height0 = Height;
1041     templ.depth0 = 1;
1042     templ.array_size = 1;
1043     templ.last_level = 0;
1044     templ.nr_samples = (unsigned)MultiSample;
1045     templ.usage = PIPE_USAGE_DEFAULT;
1046     templ.flags = 0;
1047     templ.bind = PIPE_BIND_SAMPLER_VIEW; /* StretchRect */
1048     switch (type) {
1049     case 0: templ.bind |= PIPE_BIND_RENDER_TARGET; break;
1050     case 1: templ.bind = d3d9_get_pipe_depth_format_bindings(Format); break;
1051     default:
1052         assert(type == 2);
1053         break;
1054     }
1055     templ.format = d3d9_to_pipe_format_checked(screen, Format, templ.target,
1056                                                templ.nr_samples, templ.bind,
1057                                                FALSE);
1058
1059     desc.Format = Format;
1060     desc.Type = D3DRTYPE_SURFACE;
1061     desc.Usage = 0;
1062     desc.Pool = Pool;
1063     desc.MultiSampleType = MultiSample;
1064     desc.MultiSampleQuality = MultisampleQuality;
1065     desc.Width = Width;
1066     desc.Height = Height;
1067     switch (type) {
1068     case 0: desc.Usage = D3DUSAGE_RENDERTARGET; break;
1069     case 1: desc.Usage = D3DUSAGE_DEPTHSTENCIL; break;
1070     default: break;
1071     }
1072
1073     if (Pool == D3DPOOL_DEFAULT && Format != D3DFMT_NULL) {
1074         /* resource_create doesn't return an error code, so check format here */
1075         user_assert(templ.format != PIPE_FORMAT_NONE, D3DERR_INVALIDCALL);
1076         resource = screen->resource_create(screen, &templ);
1077         user_assert(resource, D3DERR_OUTOFVIDEOMEMORY);
1078         if (Discard_or_Lockable && (desc.Usage & D3DUSAGE_RENDERTARGET))
1079             resource->flags |= NINE_RESOURCE_FLAG_LOCKABLE;
1080     } else {
1081         resource = NULL;
1082     }
1083     hr = NineSurface9_new(This, NULL, resource, NULL, 0, 0, 0, &desc, &surface);
1084     pipe_resource_reference(&resource, NULL);
1085
1086     if (SUCCEEDED(hr))
1087         *ppSurface = (IDirect3DSurface9 *)surface;
1088     return hr;
1089 }
1090
1091 HRESULT WINAPI
1092 NineDevice9_CreateRenderTarget( struct NineDevice9 *This,
1093                                 UINT Width,
1094                                 UINT Height,
1095                                 D3DFORMAT Format,
1096                                 D3DMULTISAMPLE_TYPE MultiSample,
1097                                 DWORD MultisampleQuality,
1098                                 BOOL Lockable,
1099                                 IDirect3DSurface9 **ppSurface,
1100                                 HANDLE *pSharedHandle )
1101 {
1102     *ppSurface = NULL;
1103     return create_zs_or_rt_surface(This, 0, D3DPOOL_DEFAULT,
1104                                    Width, Height, Format,
1105                                    MultiSample, MultisampleQuality,
1106                                    Lockable, ppSurface, pSharedHandle);
1107 }
1108
1109 HRESULT WINAPI
1110 NineDevice9_CreateDepthStencilSurface( struct NineDevice9 *This,
1111                                        UINT Width,
1112                                        UINT Height,
1113                                        D3DFORMAT Format,
1114                                        D3DMULTISAMPLE_TYPE MultiSample,
1115                                        DWORD MultisampleQuality,
1116                                        BOOL Discard,
1117                                        IDirect3DSurface9 **ppSurface,
1118                                        HANDLE *pSharedHandle )
1119 {
1120     *ppSurface = NULL;
1121     if (!depth_stencil_format(Format))
1122         return D3DERR_NOTAVAILABLE;
1123     return create_zs_or_rt_surface(This, 1, D3DPOOL_DEFAULT,
1124                                    Width, Height, Format,
1125                                    MultiSample, MultisampleQuality,
1126                                    Discard, ppSurface, pSharedHandle);
1127 }
1128
1129 HRESULT WINAPI
1130 NineDevice9_UpdateSurface( struct NineDevice9 *This,
1131                            IDirect3DSurface9 *pSourceSurface,
1132                            const RECT *pSourceRect,
1133                            IDirect3DSurface9 *pDestinationSurface,
1134                            const POINT *pDestPoint )
1135 {
1136     struct NineSurface9 *dst = NineSurface9(pDestinationSurface);
1137     struct NineSurface9 *src = NineSurface9(pSourceSurface);
1138
1139     DBG("This=%p pSourceSurface=%p pDestinationSurface=%p "
1140         "pSourceRect=%p pDestPoint=%p\n", This,
1141         pSourceSurface, pDestinationSurface, pSourceRect, pDestPoint);
1142     if (pSourceRect)
1143         DBG("pSourceRect = (%u,%u)-(%u,%u)\n",
1144             pSourceRect->left, pSourceRect->top,
1145             pSourceRect->right, pSourceRect->bottom);
1146     if (pDestPoint)
1147         DBG("pDestPoint = (%u,%u)\n", pDestPoint->x, pDestPoint->y);
1148
1149     user_assert(dst->base.pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
1150     user_assert(src->base.pool == D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
1151
1152     user_assert(dst->desc.MultiSampleType == D3DMULTISAMPLE_NONE, D3DERR_INVALIDCALL);
1153     user_assert(src->desc.MultiSampleType == D3DMULTISAMPLE_NONE, D3DERR_INVALIDCALL);
1154
1155     return NineSurface9_CopySurface(dst, src, pDestPoint, pSourceRect);
1156 }
1157
1158 HRESULT WINAPI
1159 NineDevice9_UpdateTexture( struct NineDevice9 *This,
1160                            IDirect3DBaseTexture9 *pSourceTexture,
1161                            IDirect3DBaseTexture9 *pDestinationTexture )
1162 {
1163     struct NineBaseTexture9 *dstb = NineBaseTexture9(pDestinationTexture);
1164     struct NineBaseTexture9 *srcb = NineBaseTexture9(pSourceTexture);
1165     unsigned l, m;
1166     unsigned last_level = dstb->base.info.last_level;
1167
1168     DBG("This=%p pSourceTexture=%p pDestinationTexture=%p\n", This,
1169         pSourceTexture, pDestinationTexture);
1170
1171     user_assert(pSourceTexture != pDestinationTexture, D3DERR_INVALIDCALL);
1172
1173     user_assert(dstb->base.pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
1174     user_assert(srcb->base.pool == D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
1175
1176     if (dstb->base.usage & D3DUSAGE_AUTOGENMIPMAP) {
1177         /* Only the first level is updated, the others regenerated. */
1178         last_level = 0;
1179     } else {
1180         user_assert(!(srcb->base.usage & D3DUSAGE_AUTOGENMIPMAP), D3DERR_INVALIDCALL);
1181     }
1182
1183     user_assert(dstb->base.type == srcb->base.type, D3DERR_INVALIDCALL);
1184
1185     /* TODO: We can restrict the update to the dirty portions of the source.
1186      * Yes, this seems silly, but it's what MSDN says ...
1187      */
1188
1189     /* Find src level that matches dst level 0: */
1190     user_assert(srcb->base.info.width0 >= dstb->base.info.width0 &&
1191                 srcb->base.info.height0 >= dstb->base.info.height0 &&
1192                 srcb->base.info.depth0 >= dstb->base.info.depth0,
1193                 D3DERR_INVALIDCALL);
1194     for (m = 0; m <= srcb->base.info.last_level; ++m) {
1195         unsigned w = u_minify(srcb->base.info.width0, m);
1196         unsigned h = u_minify(srcb->base.info.height0, m);
1197         unsigned d = u_minify(srcb->base.info.depth0, m);
1198
1199         if (w == dstb->base.info.width0 &&
1200             h == dstb->base.info.height0 &&
1201             d == dstb->base.info.depth0)
1202             break;
1203     }
1204     user_assert(m <= srcb->base.info.last_level, D3DERR_INVALIDCALL);
1205
1206     last_level = MIN2(last_level, srcb->base.info.last_level - m);
1207
1208     if (dstb->base.type == D3DRTYPE_TEXTURE) {
1209         struct NineTexture9 *dst = NineTexture9(dstb);
1210         struct NineTexture9 *src = NineTexture9(srcb);
1211
1212         for (l = 0; l <= last_level; ++l, ++m)
1213             NineSurface9_CopySurface(dst->surfaces[l],
1214                                      src->surfaces[m], NULL, NULL);
1215     } else
1216     if (dstb->base.type == D3DRTYPE_CUBETEXTURE) {
1217         struct NineCubeTexture9 *dst = NineCubeTexture9(dstb);
1218         struct NineCubeTexture9 *src = NineCubeTexture9(srcb);
1219         unsigned z;
1220
1221         /* GPUs usually have them stored as arrays of mip-mapped 2D textures. */
1222         for (z = 0; z < 6; ++z) {
1223             for (l = 0; l <= last_level; ++l, ++m) {
1224                 NineSurface9_CopySurface(dst->surfaces[l * 6 + z],
1225                                          src->surfaces[m * 6 + z], NULL, NULL);
1226             }
1227             m -= l;
1228         }
1229     } else
1230     if (dstb->base.type == D3DRTYPE_VOLUMETEXTURE) {
1231         struct NineVolumeTexture9 *dst = NineVolumeTexture9(dstb);
1232         struct NineVolumeTexture9 *src = NineVolumeTexture9(srcb);
1233
1234         for (l = 0; l <= last_level; ++l, ++m)
1235             NineVolume9_CopyVolume(dst->volumes[l],
1236                                    src->volumes[m], 0, 0, 0, NULL);
1237     } else{
1238         assert(!"invalid texture type");
1239     }
1240
1241     if (dstb->base.usage & D3DUSAGE_AUTOGENMIPMAP)
1242         NineBaseTexture9_GenerateMipSubLevels(dstb);
1243
1244     return D3D_OK;
1245 }
1246
1247 HRESULT WINAPI
1248 NineDevice9_GetRenderTargetData( struct NineDevice9 *This,
1249                                  IDirect3DSurface9 *pRenderTarget,
1250                                  IDirect3DSurface9 *pDestSurface )
1251 {
1252     struct NineSurface9 *dst = NineSurface9(pDestSurface);
1253     struct NineSurface9 *src = NineSurface9(pRenderTarget);
1254
1255     DBG("This=%p pRenderTarget=%p pDestSurface=%p\n",
1256         This, pRenderTarget, pDestSurface);
1257
1258     user_assert(dst->desc.Pool == D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
1259     user_assert(src->desc.Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
1260
1261     user_assert(dst->desc.MultiSampleType < 2, D3DERR_INVALIDCALL);
1262     user_assert(src->desc.MultiSampleType < 2, D3DERR_INVALIDCALL);
1263
1264     return NineSurface9_CopySurface(dst, src, NULL, NULL);
1265 }
1266
1267 HRESULT WINAPI
1268 NineDevice9_GetFrontBufferData( struct NineDevice9 *This,
1269                                 UINT iSwapChain,
1270                                 IDirect3DSurface9 *pDestSurface )
1271 {
1272     DBG("This=%p iSwapChain=%u pDestSurface=%p\n", This,
1273         iSwapChain, pDestSurface);
1274
1275     user_assert(pDestSurface != NULL, D3DERR_INVALIDCALL);
1276     user_assert(iSwapChain < This->nswapchains, D3DERR_INVALIDCALL);
1277
1278     return NineSwapChain9_GetFrontBufferData(This->swapchains[iSwapChain],
1279                                              pDestSurface);
1280 }
1281
1282 HRESULT WINAPI
1283 NineDevice9_StretchRect( struct NineDevice9 *This,
1284                          IDirect3DSurface9 *pSourceSurface,
1285                          const RECT *pSourceRect,
1286                          IDirect3DSurface9 *pDestSurface,
1287                          const RECT *pDestRect,
1288                          D3DTEXTUREFILTERTYPE Filter )
1289 {
1290     struct pipe_screen *screen = This->screen;
1291     struct pipe_context *pipe = This->pipe;
1292     struct NineSurface9 *dst = NineSurface9(pDestSurface);
1293     struct NineSurface9 *src = NineSurface9(pSourceSurface);
1294     struct pipe_resource *dst_res = NineSurface9_GetResource(dst);
1295     struct pipe_resource *src_res = NineSurface9_GetResource(src);
1296     const boolean zs = util_format_is_depth_or_stencil(dst_res->format);
1297     struct pipe_blit_info blit;
1298     boolean scaled, clamped, ms, flip_x = FALSE, flip_y = FALSE;
1299
1300     DBG("This=%p pSourceSurface=%p pSourceRect=%p pDestSurface=%p "
1301         "pDestRect=%p Filter=%u\n",
1302         This, pSourceSurface, pSourceRect, pDestSurface, pDestRect, Filter);
1303     if (pSourceRect)
1304         DBG("pSourceRect=(%u,%u)-(%u,%u)\n",
1305             pSourceRect->left, pSourceRect->top,
1306             pSourceRect->right, pSourceRect->bottom);
1307     if (pDestRect)
1308         DBG("pDestRect=(%u,%u)-(%u,%u)\n", pDestRect->left, pDestRect->top,
1309             pDestRect->right, pDestRect->bottom);
1310
1311     user_assert(!zs || !This->in_scene, D3DERR_INVALIDCALL);
1312     user_assert(!zs || !pSourceRect ||
1313                 (pSourceRect->left == 0 &&
1314                  pSourceRect->top == 0 &&
1315                  pSourceRect->right == src->desc.Width &&
1316                  pSourceRect->bottom == src->desc.Height), D3DERR_INVALIDCALL);
1317     user_assert(!zs || !pDestRect ||
1318                 (pDestRect->left == 0 &&
1319                  pDestRect->top == 0 &&
1320                  pDestRect->right == dst->desc.Width &&
1321                  pDestRect->bottom == dst->desc.Height), D3DERR_INVALIDCALL);
1322     user_assert(!zs ||
1323                 (dst->desc.Width == src->desc.Width &&
1324                  dst->desc.Height == src->desc.Height), D3DERR_INVALIDCALL);
1325     user_assert(zs || !util_format_is_depth_or_stencil(src_res->format),
1326                 D3DERR_INVALIDCALL);
1327     user_assert(!zs || dst->desc.Format == src->desc.Format,
1328                 D3DERR_INVALIDCALL);
1329     user_assert(screen->is_format_supported(screen, src_res->format,
1330                                             src_res->target,
1331                                             src_res->nr_samples,
1332                                             PIPE_BIND_SAMPLER_VIEW),
1333                 D3DERR_INVALIDCALL);
1334     user_assert(dst->base.pool == D3DPOOL_DEFAULT &&
1335                 src->base.pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
1336
1337     /* We might want to permit these, but wine thinks we shouldn't. */
1338     user_assert(!pDestRect ||
1339                 (pDestRect->left <= pDestRect->right &&
1340                  pDestRect->top <= pDestRect->bottom), D3DERR_INVALIDCALL);
1341     user_assert(!pSourceRect ||
1342                 (pSourceRect->left <= pSourceRect->right &&
1343                  pSourceRect->top <= pSourceRect->bottom), D3DERR_INVALIDCALL);
1344
1345     blit.dst.resource = dst_res;
1346     blit.dst.level = dst->level;
1347     blit.dst.box.z = dst->layer;
1348     blit.dst.box.depth = 1;
1349     blit.dst.format = dst_res->format;
1350     if (pDestRect) {
1351         flip_x = pDestRect->left > pDestRect->right;
1352         if (flip_x) {
1353             blit.dst.box.x = pDestRect->right;
1354             blit.dst.box.width = pDestRect->left - pDestRect->right;
1355         } else {
1356             blit.dst.box.x = pDestRect->left;
1357             blit.dst.box.width = pDestRect->right - pDestRect->left;
1358         }
1359         flip_y = pDestRect->top > pDestRect->bottom;
1360         if (flip_y) {
1361             blit.dst.box.y = pDestRect->bottom;
1362             blit.dst.box.height = pDestRect->top - pDestRect->bottom;
1363         } else {
1364             blit.dst.box.y = pDestRect->top;
1365             blit.dst.box.height = pDestRect->bottom - pDestRect->top;
1366         }
1367     } else {
1368         blit.dst.box.x = 0;
1369         blit.dst.box.y = 0;
1370         blit.dst.box.width = dst->desc.Width;
1371         blit.dst.box.height = dst->desc.Height;
1372     }
1373     blit.src.resource = src_res;
1374     blit.src.level = src->level;
1375     blit.src.box.z = src->layer;
1376     blit.src.box.depth = 1;
1377     blit.src.format = src_res->format;
1378     if (pSourceRect) {
1379         if (flip_x ^ (pSourceRect->left > pSourceRect->right)) {
1380             blit.src.box.x = pSourceRect->right;
1381             blit.src.box.width = pSourceRect->left - pSourceRect->right;
1382         } else {
1383             blit.src.box.x = pSourceRect->left;
1384             blit.src.box.width = pSourceRect->right - pSourceRect->left;
1385         }
1386         if (flip_y ^ (pSourceRect->top > pSourceRect->bottom)) {
1387             blit.src.box.y = pSourceRect->bottom;
1388             blit.src.box.height = pSourceRect->top - pSourceRect->bottom;
1389         } else {
1390             blit.src.box.y = pSourceRect->top;
1391             blit.src.box.height = pSourceRect->bottom - pSourceRect->top;
1392         }
1393     } else {
1394         blit.src.box.x = flip_x ? src->desc.Width : 0;
1395         blit.src.box.y = flip_y ? src->desc.Height : 0;
1396         blit.src.box.width = flip_x ? -src->desc.Width : src->desc.Width;
1397         blit.src.box.height = flip_y ? -src->desc.Height : src->desc.Height;
1398     }
1399     blit.mask = zs ? PIPE_MASK_ZS : PIPE_MASK_RGBA;
1400     blit.filter = Filter == D3DTEXF_LINEAR ?
1401        PIPE_TEX_FILTER_LINEAR : PIPE_TEX_FILTER_NEAREST;
1402     blit.scissor_enable = FALSE;
1403
1404     /* If both of a src and dst dimension are negative, flip them. */
1405     if (blit.dst.box.width < 0 && blit.src.box.width < 0) {
1406         blit.dst.box.width = -blit.dst.box.width;
1407         blit.src.box.width = -blit.src.box.width;
1408     }
1409     if (blit.dst.box.height < 0 && blit.src.box.height < 0) {
1410         blit.dst.box.height = -blit.dst.box.height;
1411         blit.src.box.height = -blit.src.box.height;
1412     }
1413     scaled =
1414         blit.dst.box.width != blit.src.box.width ||
1415         blit.dst.box.height != blit.src.box.height;
1416
1417     user_assert(!scaled || dst != src, D3DERR_INVALIDCALL);
1418     user_assert(!scaled ||
1419                 !NineSurface9_IsOffscreenPlain(dst) ||
1420                 NineSurface9_IsOffscreenPlain(src), D3DERR_INVALIDCALL);
1421     user_assert(!scaled ||
1422                 (!util_format_is_compressed(dst->base.info.format) &&
1423                  !util_format_is_compressed(src->base.info.format)),
1424                 D3DERR_INVALIDCALL);
1425
1426     user_warn(src == dst &&
1427               u_box_test_intersection_2d(&blit.src.box, &blit.dst.box));
1428
1429     /* Check for clipping/clamping: */
1430     {
1431         struct pipe_box box;
1432         int xy;
1433
1434         xy = u_box_clip_2d(&box, &blit.dst.box,
1435                            dst->desc.Width, dst->desc.Height);
1436         if (xy < 0)
1437             return D3D_OK;
1438         if (xy == 0)
1439             xy = u_box_clip_2d(&box, &blit.src.box,
1440                                src->desc.Width, src->desc.Height);
1441         clamped = !!xy;
1442     }
1443
1444     ms = (dst->desc.MultiSampleType | 1) != (src->desc.MultiSampleType | 1);
1445
1446     if (clamped || scaled || (blit.dst.format != blit.src.format) || ms) {
1447         DBG("using pipe->blit()\n");
1448         /* TODO: software scaling */
1449         user_assert(screen->is_format_supported(screen, dst_res->format,
1450                                                 dst_res->target,
1451                                                 dst_res->nr_samples,
1452                                                 zs ? PIPE_BIND_DEPTH_STENCIL :
1453                                                 PIPE_BIND_RENDER_TARGET),
1454                     D3DERR_INVALIDCALL);
1455
1456         pipe->blit(pipe, &blit);
1457     } else {
1458         assert(blit.dst.box.x >= 0 && blit.dst.box.y >= 0 &&
1459                blit.src.box.x >= 0 && blit.src.box.y >= 0 &&
1460                blit.dst.box.x + blit.dst.box.width <= dst->desc.Width &&
1461                blit.src.box.x + blit.src.box.width <= src->desc.Width &&
1462                blit.dst.box.y + blit.dst.box.height <= dst->desc.Height &&
1463                blit.src.box.y + blit.src.box.height <= src->desc.Height);
1464         /* Or drivers might crash ... */
1465         DBG("Using resource_copy_region.\n");
1466         pipe->resource_copy_region(pipe,
1467             blit.dst.resource, blit.dst.level,
1468             blit.dst.box.x, blit.dst.box.y, blit.dst.box.z,
1469             blit.src.resource, blit.src.level,
1470             &blit.src.box);
1471     }
1472
1473     return D3D_OK;
1474 }
1475
1476 HRESULT WINAPI
1477 NineDevice9_ColorFill( struct NineDevice9 *This,
1478                        IDirect3DSurface9 *pSurface,
1479                        const RECT *pRect,
1480                        D3DCOLOR color )
1481 {
1482     struct pipe_context *pipe = This->pipe;
1483     struct NineSurface9 *surf = NineSurface9(pSurface);
1484     struct pipe_surface *psurf;
1485     unsigned x, y, w, h;
1486     union pipe_color_union rgba;
1487     boolean fallback;
1488
1489     DBG("This=%p pSurface=%p pRect=%p color=%08x\n", This,
1490         pSurface, pRect, color);
1491     if (pRect)
1492         DBG("pRect=(%u,%u)-(%u,%u)\n", pRect->left, pRect->top,
1493             pRect->right, pRect->bottom);
1494
1495     user_assert(surf->base.pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL);
1496
1497     user_assert((surf->base.usage & D3DUSAGE_RENDERTARGET) ||
1498                 NineSurface9_IsOffscreenPlain(surf), D3DERR_INVALIDCALL);
1499
1500     if (pRect) {
1501         x = pRect->left;
1502         y = pRect->top;
1503         w = pRect->right - pRect->left;
1504         h = pRect->bottom - pRect->top;
1505     } else{
1506         x = 0;
1507         y = 0;
1508         w = surf->desc.Width;
1509         h = surf->desc.Height;
1510     }
1511     d3dcolor_to_pipe_color_union(&rgba, color);
1512
1513     fallback =
1514         !This->screen->is_format_supported(This->screen, surf->base.info.format,
1515                                            surf->base.info.target,
1516                                            surf->base.info.nr_samples,
1517                                            PIPE_BIND_RENDER_TARGET);
1518     if (!fallback) {
1519         psurf = NineSurface9_GetSurface(surf, 0);
1520         if (!psurf)
1521             fallback = TRUE;
1522     }
1523
1524     if (!fallback) {
1525         pipe->clear_render_target(pipe, psurf, &rgba, x, y, w, h);
1526     } else {
1527         D3DLOCKED_RECT lock;
1528         union util_color uc;
1529         HRESULT hr;
1530         /* XXX: lock pRect and fix util_fill_rect */
1531         hr = NineSurface9_LockRect(surf, &lock, NULL, 0);
1532         if (FAILED(hr))
1533             return hr;
1534         util_pack_color_ub(color >> 16, color >> 8, color >> 0, color >> 24,
1535                            surf->base.info.format, &uc);
1536         util_fill_rect(lock.pBits, surf->base.info.format,lock.Pitch,
1537                        x, y, w, h, &uc);
1538         NineSurface9_UnlockRect(surf);
1539     }
1540
1541     return D3D_OK;
1542 }
1543
1544 HRESULT WINAPI
1545 NineDevice9_CreateOffscreenPlainSurface( struct NineDevice9 *This,
1546                                          UINT Width,
1547                                          UINT Height,
1548                                          D3DFORMAT Format,
1549                                          D3DPOOL Pool,
1550                                          IDirect3DSurface9 **ppSurface,
1551                                          HANDLE *pSharedHandle )
1552 {
1553     HRESULT hr;
1554
1555     DBG("This=%p Width=%u Height=%u Format=%s(0x%x) Pool=%u "
1556         "ppSurface=%p pSharedHandle=%p\n", This,
1557         Width, Height, d3dformat_to_string(Format), Format, Pool,
1558         ppSurface, pSharedHandle);
1559
1560     *ppSurface = NULL;
1561     user_assert(!pSharedHandle || Pool == D3DPOOL_DEFAULT
1562                                || Pool == D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
1563     user_assert(Pool != D3DPOOL_MANAGED, D3DERR_INVALIDCALL);
1564
1565     /* Can be used with StretchRect and ColorFill. It's also always lockable.
1566      */
1567     hr = create_zs_or_rt_surface(This, 2, Pool, Width, Height,
1568                                  Format,
1569                                  D3DMULTISAMPLE_NONE, 0,
1570                                  TRUE,
1571                                  ppSurface, pSharedHandle);
1572     if (FAILED(hr))
1573         DBG("Failed to create surface.\n");
1574     return hr;
1575 }
1576
1577 HRESULT WINAPI
1578 NineDevice9_SetRenderTarget( struct NineDevice9 *This,
1579                              DWORD RenderTargetIndex,
1580                              IDirect3DSurface9 *pRenderTarget )
1581 {
1582     struct NineSurface9 *rt = NineSurface9(pRenderTarget);
1583     const unsigned i = RenderTargetIndex;
1584
1585     DBG("This=%p RenderTargetIndex=%u pRenderTarget=%p\n", This,
1586         RenderTargetIndex, pRenderTarget);
1587
1588     user_assert(i < This->caps.NumSimultaneousRTs, D3DERR_INVALIDCALL);
1589     user_assert(i != 0 || pRenderTarget, D3DERR_INVALIDCALL);
1590     user_assert(!pRenderTarget ||
1591                 rt->desc.Usage & D3DUSAGE_RENDERTARGET, D3DERR_INVALIDCALL);
1592
1593     if (i == 0) {
1594         This->state.viewport.X = 0;
1595         This->state.viewport.Y = 0;
1596         This->state.viewport.Width = rt->desc.Width;
1597         This->state.viewport.Height = rt->desc.Height;
1598         This->state.viewport.MinZ = 0.0f;
1599         This->state.viewport.MaxZ = 1.0f;
1600
1601         This->state.scissor.minx = 0;
1602         This->state.scissor.miny = 0;
1603         This->state.scissor.maxx = rt->desc.Width;
1604         This->state.scissor.maxy = rt->desc.Height;
1605
1606         This->state.changed.group |= NINE_STATE_VIEWPORT | NINE_STATE_SCISSOR;
1607     }
1608
1609     if (This->state.rt[i] != NineSurface9(pRenderTarget)) {
1610        nine_bind(&This->state.rt[i], pRenderTarget);
1611        This->state.changed.group |= NINE_STATE_FB;
1612     }
1613     return D3D_OK;
1614 }
1615
1616 HRESULT WINAPI
1617 NineDevice9_GetRenderTarget( struct NineDevice9 *This,
1618                              DWORD RenderTargetIndex,
1619                              IDirect3DSurface9 **ppRenderTarget )
1620 {
1621     const unsigned i = RenderTargetIndex;
1622
1623     user_assert(i < This->caps.NumSimultaneousRTs, D3DERR_INVALIDCALL);
1624     user_assert(ppRenderTarget, D3DERR_INVALIDCALL);
1625
1626     *ppRenderTarget = (IDirect3DSurface9 *)This->state.rt[i];
1627     if (!This->state.rt[i])
1628         return D3DERR_NOTFOUND;
1629
1630     NineUnknown_AddRef(NineUnknown(This->state.rt[i]));
1631     return D3D_OK;
1632 }
1633
1634 HRESULT WINAPI
1635 NineDevice9_SetDepthStencilSurface( struct NineDevice9 *This,
1636                                     IDirect3DSurface9 *pNewZStencil )
1637 {
1638     DBG("This=%p pNewZStencil=%p\n", This, pNewZStencil);
1639
1640     if (This->state.ds != NineSurface9(pNewZStencil)) {
1641         nine_bind(&This->state.ds, pNewZStencil);
1642         This->state.changed.group |= NINE_STATE_FB;
1643     }
1644     return D3D_OK;
1645 }
1646
1647 HRESULT WINAPI
1648 NineDevice9_GetDepthStencilSurface( struct NineDevice9 *This,
1649                                     IDirect3DSurface9 **ppZStencilSurface )
1650 {
1651     user_assert(ppZStencilSurface, D3DERR_INVALIDCALL);
1652
1653     *ppZStencilSurface = (IDirect3DSurface9 *)This->state.ds;
1654     if (!This->state.ds)
1655         return D3DERR_NOTFOUND;
1656
1657     NineUnknown_AddRef(NineUnknown(This->state.ds));
1658     return D3D_OK;
1659 }
1660
1661 HRESULT WINAPI
1662 NineDevice9_BeginScene( struct NineDevice9 *This )
1663 {
1664     DBG("This=%p\n", This);
1665     user_assert(!This->in_scene, D3DERR_INVALIDCALL);
1666     This->in_scene = TRUE;
1667     /* Do we want to do anything else here ? */
1668     return D3D_OK;
1669 }
1670
1671 HRESULT WINAPI
1672 NineDevice9_EndScene( struct NineDevice9 *This )
1673 {
1674     DBG("This=%p\n", This);
1675     user_assert(This->in_scene, D3DERR_INVALIDCALL);
1676     This->in_scene = FALSE;
1677     return D3D_OK;
1678 }
1679
1680 HRESULT WINAPI
1681 NineDevice9_Clear( struct NineDevice9 *This,
1682                    DWORD Count,
1683                    const D3DRECT *pRects,
1684                    DWORD Flags,
1685                    D3DCOLOR Color,
1686                    float Z,
1687                    DWORD Stencil )
1688 {
1689     const int sRGB = This->state.rs[D3DRS_SRGBWRITEENABLE] ? 1 : 0;
1690     struct pipe_surface *cbuf, *zsbuf;
1691     struct pipe_context *pipe = This->pipe;
1692     struct NineSurface9 *zsbuf_surf = This->state.ds;
1693     struct NineSurface9 *rt;
1694     unsigned bufs = 0;
1695     unsigned r, i;
1696     union pipe_color_union rgba;
1697     unsigned rt_mask = 0;
1698     D3DRECT rect;
1699
1700     DBG("This=%p Count=%u pRects=%p Flags=%x Color=%08x Z=%f Stencil=%x\n",
1701         This, Count, pRects, Flags, Color, Z, Stencil);
1702
1703     user_assert(This->state.ds || !(Flags & NINED3DCLEAR_DEPTHSTENCIL),
1704                 D3DERR_INVALIDCALL);
1705     user_assert(!(Flags & D3DCLEAR_STENCIL) ||
1706                 (zsbuf_surf &&
1707                  util_format_is_depth_and_stencil(zsbuf_surf->base.info.format)),
1708                 D3DERR_INVALIDCALL);
1709 #ifdef NINE_STRICT
1710     user_assert((Count && pRects) || (!Count && !pRects), D3DERR_INVALIDCALL);
1711 #else
1712     user_warn((pRects && !Count) || (!pRects && Count));
1713     if (pRects && !Count)
1714         return D3D_OK;
1715     if (!pRects)
1716         Count = 0;
1717 #endif
1718
1719     if (Flags & D3DCLEAR_TARGET) bufs |= PIPE_CLEAR_COLOR;
1720     if (Flags & D3DCLEAR_ZBUFFER) bufs |= PIPE_CLEAR_DEPTH;
1721     if (Flags & D3DCLEAR_STENCIL) bufs |= PIPE_CLEAR_STENCIL;
1722     if (!bufs)
1723         return D3D_OK;
1724     d3dcolor_to_pipe_color_union(&rgba, Color);
1725
1726     nine_update_state(This, NINE_STATE_FB);
1727
1728     rect.x1 = This->state.viewport.X;
1729     rect.y1 = This->state.viewport.Y;
1730     rect.x2 = This->state.viewport.Width + rect.x1;
1731     rect.y2 = This->state.viewport.Height + rect.y1;
1732
1733     /* Both rectangles apply, which is weird, but that's D3D9. */
1734     if (This->state.rs[D3DRS_SCISSORTESTENABLE]) {
1735         rect.x1 = MAX2(rect.x1, This->state.scissor.minx);
1736         rect.y1 = MAX2(rect.y1, This->state.scissor.miny);
1737         rect.x2 = MIN2(rect.x2, This->state.scissor.maxx);
1738         rect.y2 = MIN2(rect.y2, This->state.scissor.maxy);
1739     }
1740
1741     if (Count) {
1742         /* Maybe apps like to specify a large rect ? */
1743         if (pRects[0].x1 <= rect.x1 && pRects[0].x2 >= rect.x2 &&
1744             pRects[0].y1 <= rect.y1 && pRects[0].y2 >= rect.y2) {
1745             DBG("First rect covers viewport.\n");
1746             Count = 0;
1747             pRects = NULL;
1748         }
1749     }
1750
1751     if (rect.x1 >= This->state.fb.width || rect.y1 >= This->state.fb.height)
1752         return D3D_OK;
1753
1754     for (i = 0; i < This->caps.NumSimultaneousRTs; ++i) {
1755         if (This->state.rt[i] && This->state.rt[i]->desc.Format != D3DFMT_NULL)
1756             rt_mask |= 1 << i;
1757     }
1758
1759     /* fast path, clears everything at once */
1760     if (!Count &&
1761         (!(bufs & PIPE_CLEAR_COLOR) || (rt_mask == This->state.rt_mask)) &&
1762         rect.x1 == 0 && rect.y1 == 0 &&
1763         /* Case we clear only render target. Check clear region vs rt. */
1764         ((!(bufs & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)) &&
1765          rect.x2 >= This->state.fb.width &&
1766          rect.y2 >= This->state.fb.height) ||
1767         /* Case we clear depth buffer (and eventually rt too).
1768          * depth buffer size is always >= rt size. Compare to clear region */
1769         ((bufs & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)) &&
1770          This->state.fb.zsbuf != NULL &&
1771          rect.x2 >= zsbuf_surf->desc.Width &&
1772          rect.y2 >= zsbuf_surf->desc.Height))) {
1773         DBG("Clear fast path\n");
1774         pipe->clear(pipe, bufs, &rgba, Z, Stencil);
1775         return D3D_OK;
1776     }
1777
1778     if (!Count) {
1779         Count = 1;
1780         pRects = &rect;
1781     }
1782
1783     for (i = 0; i < This->caps.NumSimultaneousRTs; ++i) {
1784         rt = This->state.rt[i];
1785         if (!rt || rt->desc.Format == D3DFMT_NULL ||
1786             !(Flags & D3DCLEAR_TARGET))
1787             continue; /* save space, compiler should hoist this */
1788         cbuf = NineSurface9_GetSurface(rt, sRGB);
1789         for (r = 0; r < Count; ++r) {
1790             /* Don't trust users to pass these in the right order. */
1791             unsigned x1 = MIN2(pRects[r].x1, pRects[r].x2);
1792             unsigned y1 = MIN2(pRects[r].y1, pRects[r].y2);
1793             unsigned x2 = MAX2(pRects[r].x1, pRects[r].x2);
1794             unsigned y2 = MAX2(pRects[r].y1, pRects[r].y2);
1795 #ifndef NINE_LAX
1796             /* Drop negative rectangles (like wine expects). */
1797             if (pRects[r].x1 > pRects[r].x2) continue;
1798             if (pRects[r].y1 > pRects[r].y2) continue;
1799 #endif
1800
1801             x1 = MAX2(x1, rect.x1);
1802             y1 = MAX2(y1, rect.y1);
1803             x2 = MIN3(x2, rect.x2, rt->desc.Width);
1804             y2 = MIN3(y2, rect.y2, rt->desc.Height);
1805
1806             DBG("Clearing (%u..%u)x(%u..%u)\n", x1, x2, y1, y2);
1807             pipe->clear_render_target(pipe, cbuf, &rgba,
1808                                       x1, y1, x2 - x1, y2 - y1);
1809         }
1810     }
1811     if (!(Flags & NINED3DCLEAR_DEPTHSTENCIL))
1812         return D3D_OK;
1813
1814     bufs &= PIPE_CLEAR_DEPTHSTENCIL;
1815
1816     for (r = 0; r < Count; ++r) {
1817         unsigned x1 = MIN2(pRects[r].x1, pRects[r].x2);
1818         unsigned y1 = MIN2(pRects[r].y1, pRects[r].y2);
1819         unsigned x2 = MAX2(pRects[r].x1, pRects[r].x2);
1820         unsigned y2 = MAX2(pRects[r].y1, pRects[r].y2);
1821 #ifndef NINE_LAX
1822         /* Drop negative rectangles. */
1823         if (pRects[r].x1 > pRects[r].x2) continue;
1824         if (pRects[r].y1 > pRects[r].y2) continue;
1825 #endif
1826
1827         x1 = MIN2(x1, rect.x1);
1828         y1 = MIN2(y1, rect.y1);
1829         x2 = MIN3(x2, rect.x2, zsbuf_surf->desc.Width);
1830         y2 = MIN3(y2, rect.y2, zsbuf_surf->desc.Height);
1831
1832         zsbuf = NineSurface9_GetSurface(zsbuf_surf, 0);
1833         assert(zsbuf);
1834         pipe->clear_depth_stencil(pipe, zsbuf, bufs, Z, Stencil,
1835                                   x1, y1, x2 - x1, y2 - y1);
1836     }
1837     return D3D_OK;
1838 }
1839
1840 HRESULT WINAPI
1841 NineDevice9_SetTransform( struct NineDevice9 *This,
1842                           D3DTRANSFORMSTATETYPE State,
1843                           const D3DMATRIX *pMatrix )
1844 {
1845     struct nine_state *state = This->update;
1846     D3DMATRIX *M = nine_state_access_transform(state, State, TRUE);
1847
1848     DBG("This=%p State=%d pMatrix=%p\n", This, State, pMatrix);
1849
1850     user_assert(M, D3DERR_INVALIDCALL);
1851
1852     *M = *pMatrix;
1853     state->ff.changed.transform[State / 32] |= 1 << (State % 32);
1854     state->changed.group |= NINE_STATE_FF;
1855
1856     return D3D_OK;
1857 }
1858
1859 HRESULT WINAPI
1860 NineDevice9_GetTransform( struct NineDevice9 *This,
1861                           D3DTRANSFORMSTATETYPE State,
1862                           D3DMATRIX *pMatrix )
1863 {
1864     D3DMATRIX *M = nine_state_access_transform(&This->state, State, FALSE);
1865     user_assert(M, D3DERR_INVALIDCALL);
1866     *pMatrix = *M;
1867     return D3D_OK;
1868 }
1869
1870 HRESULT WINAPI
1871 NineDevice9_MultiplyTransform( struct NineDevice9 *This,
1872                                D3DTRANSFORMSTATETYPE State,
1873                                const D3DMATRIX *pMatrix )
1874 {
1875     struct nine_state *state = This->update;
1876     D3DMATRIX T;
1877     D3DMATRIX *M = nine_state_access_transform(state, State, TRUE);
1878
1879     DBG("This=%p State=%d pMatrix=%p\n", This, State, pMatrix);
1880
1881     user_assert(M, D3DERR_INVALIDCALL);
1882
1883     nine_d3d_matrix_matrix_mul(&T, pMatrix, M);
1884     return NineDevice9_SetTransform(This, State, &T);
1885 }
1886
1887 HRESULT WINAPI
1888 NineDevice9_SetViewport( struct NineDevice9 *This,
1889                          const D3DVIEWPORT9 *pViewport )
1890 {
1891     struct nine_state *state = This->update;
1892
1893     DBG("X=%u Y=%u W=%u H=%u MinZ=%f MaxZ=%f\n",
1894         pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height,
1895         pViewport->MinZ, pViewport->MaxZ);
1896
1897     state->viewport = *pViewport;
1898     state->changed.group |= NINE_STATE_VIEWPORT;
1899
1900     return D3D_OK;
1901 }
1902
1903 HRESULT WINAPI
1904 NineDevice9_GetViewport( struct NineDevice9 *This,
1905                          D3DVIEWPORT9 *pViewport )
1906 {
1907     *pViewport = This->state.viewport;
1908     return D3D_OK;
1909 }
1910
1911 HRESULT WINAPI
1912 NineDevice9_SetMaterial( struct NineDevice9 *This,
1913                          const D3DMATERIAL9 *pMaterial )
1914 {
1915     struct nine_state *state = This->update;
1916
1917     DBG("This=%p pMaterial=%p\n", This, pMaterial);
1918     if (pMaterial)
1919         nine_dump_D3DMATERIAL9(DBG_FF, pMaterial);
1920
1921     user_assert(pMaterial, E_POINTER);
1922
1923     state->ff.material = *pMaterial;
1924     state->changed.group |= NINE_STATE_FF_MATERIAL;
1925
1926     return D3D_OK;
1927 }
1928
1929 HRESULT WINAPI
1930 NineDevice9_GetMaterial( struct NineDevice9 *This,
1931                          D3DMATERIAL9 *pMaterial )
1932 {
1933     user_assert(pMaterial, E_POINTER);
1934     *pMaterial = This->state.ff.material;
1935     return D3D_OK;
1936 }
1937
1938 HRESULT WINAPI
1939 NineDevice9_SetLight( struct NineDevice9 *This,
1940                       DWORD Index,
1941                       const D3DLIGHT9 *pLight )
1942 {
1943     struct nine_state *state = This->update;
1944
1945     DBG("This=%p Index=%u pLight=%p\n", This, Index, pLight);
1946     if (pLight)
1947         nine_dump_D3DLIGHT9(DBG_FF, pLight);
1948
1949     user_assert(pLight, D3DERR_INVALIDCALL);
1950     user_assert(pLight->Type < NINED3DLIGHT_INVALID, D3DERR_INVALIDCALL);
1951
1952     user_assert(Index < NINE_MAX_LIGHTS, D3DERR_INVALIDCALL); /* sanity */
1953
1954     if (Index >= state->ff.num_lights) {
1955         unsigned n = state->ff.num_lights;
1956         unsigned N = Index + 1;
1957
1958         state->ff.light = REALLOC(state->ff.light, n * sizeof(D3DLIGHT9),
1959                                                    N * sizeof(D3DLIGHT9));
1960         if (!state->ff.light)
1961             return E_OUTOFMEMORY;
1962         state->ff.num_lights = N;
1963
1964         for (; n < Index; ++n)
1965             state->ff.light[n].Type = (D3DLIGHTTYPE)NINED3DLIGHT_INVALID;
1966     }
1967     state->ff.light[Index] = *pLight;
1968
1969     if (pLight->Type == D3DLIGHT_SPOT && pLight->Theta >= pLight->Phi) {
1970         DBG("Warning: clamping D3DLIGHT9.Theta\n");
1971         state->ff.light[Index].Theta = state->ff.light[Index].Phi;
1972     }
1973     if (pLight->Type != D3DLIGHT_DIRECTIONAL &&
1974         pLight->Attenuation0 == 0.0f &&
1975         pLight->Attenuation1 == 0.0f &&
1976         pLight->Attenuation2 == 0.0f) {
1977         DBG("Warning: all D3DLIGHT9.Attenuation[i] are 0\n");
1978     }
1979
1980     state->changed.group |= NINE_STATE_FF_LIGHTING;
1981
1982     return D3D_OK;
1983 }
1984
1985 HRESULT WINAPI
1986 NineDevice9_GetLight( struct NineDevice9 *This,
1987                       DWORD Index,
1988                       D3DLIGHT9 *pLight )
1989 {
1990     const struct nine_state *state = &This->state;
1991
1992     user_assert(pLight, D3DERR_INVALIDCALL);
1993     user_assert(Index < state->ff.num_lights, D3DERR_INVALIDCALL);
1994     user_assert(state->ff.light[Index].Type < NINED3DLIGHT_INVALID,
1995                 D3DERR_INVALIDCALL);
1996
1997     *pLight = state->ff.light[Index];
1998
1999     return D3D_OK;
2000 }
2001
2002 HRESULT WINAPI
2003 NineDevice9_LightEnable( struct NineDevice9 *This,
2004                          DWORD Index,
2005                          BOOL Enable )
2006 {
2007     struct nine_state *state = This->update;
2008     unsigned i;
2009
2010     DBG("This=%p Index=%u Enable=%i\n", This, Index, Enable);
2011
2012     if (Index >= state->ff.num_lights ||
2013         state->ff.light[Index].Type == NINED3DLIGHT_INVALID) {
2014         /* This should create a default light. */
2015         D3DLIGHT9 light;
2016         memset(&light, 0, sizeof(light));
2017         light.Type = D3DLIGHT_DIRECTIONAL;
2018         light.Diffuse.r = 1.0f;
2019         light.Diffuse.g = 1.0f;
2020         light.Diffuse.b = 1.0f;
2021         light.Direction.z = 1.0f;
2022         NineDevice9_SetLight(This, Index, &light);
2023     }
2024     user_assert(Index < state->ff.num_lights, D3DERR_INVALIDCALL);
2025
2026     for (i = 0; i < state->ff.num_lights_active; ++i) {
2027         if (state->ff.active_light[i] == Index)
2028             break;
2029     }
2030
2031     if (Enable) {
2032         if (i < state->ff.num_lights_active)
2033             return D3D_OK;
2034         /* XXX wine thinks this should still succeed:
2035          */
2036         user_assert(i < NINE_MAX_LIGHTS_ACTIVE, D3DERR_INVALIDCALL);
2037
2038         state->ff.active_light[i] = Index;
2039         state->ff.num_lights_active++;
2040     } else {
2041         if (i == state->ff.num_lights_active)
2042             return D3D_OK;
2043         --state->ff.num_lights_active;
2044         for (; i < state->ff.num_lights_active; ++i)
2045             state->ff.active_light[i] = state->ff.active_light[i + 1];
2046     }
2047     state->changed.group |= NINE_STATE_FF_LIGHTING;
2048
2049     return D3D_OK;
2050 }
2051
2052 HRESULT WINAPI
2053 NineDevice9_GetLightEnable( struct NineDevice9 *This,
2054                             DWORD Index,
2055                             BOOL *pEnable )
2056 {
2057     const struct nine_state *state = &This->state;
2058     unsigned i;
2059
2060     user_assert(Index < state->ff.num_lights, D3DERR_INVALIDCALL);
2061     user_assert(state->ff.light[Index].Type < NINED3DLIGHT_INVALID,
2062                 D3DERR_INVALIDCALL);
2063
2064     for (i = 0; i < state->ff.num_lights_active; ++i)
2065         if (state->ff.active_light[i] == Index)
2066             break;
2067
2068     *pEnable = i != state->ff.num_lights_active ? 128 : 0; // Taken from wine
2069
2070     return D3D_OK;
2071 }
2072
2073 HRESULT WINAPI
2074 NineDevice9_SetClipPlane( struct NineDevice9 *This,
2075                           DWORD Index,
2076                           const float *pPlane )
2077 {
2078     struct nine_state *state = This->update;
2079
2080     user_assert(pPlane, D3DERR_INVALIDCALL);
2081
2082     DBG("This=%p Index=%u pPlane=%f %f %f %f\n", This, Index,
2083         pPlane[0], pPlane[1],
2084         pPlane[2], pPlane[3]);
2085
2086     user_assert(Index < PIPE_MAX_CLIP_PLANES, D3DERR_INVALIDCALL);
2087
2088     memcpy(&state->clip.ucp[Index][0], pPlane, sizeof(state->clip.ucp[0]));
2089     state->changed.ucp |= 1 << Index;
2090
2091     return D3D_OK;
2092 }
2093
2094 HRESULT WINAPI
2095 NineDevice9_GetClipPlane( struct NineDevice9 *This,
2096                           DWORD Index,
2097                           float *pPlane )
2098 {
2099     const struct nine_state *state = &This->state;
2100
2101     user_assert(Index < PIPE_MAX_CLIP_PLANES, D3DERR_INVALIDCALL);
2102
2103     memcpy(pPlane, &state->clip.ucp[Index][0], sizeof(state->clip.ucp[0]));
2104     return D3D_OK;
2105 }
2106
2107 #define RESZ_CODE 0x7fa05000
2108
2109 static HRESULT
2110 NineDevice9_ResolveZ( struct NineDevice9 *This )
2111 {
2112     struct nine_state *state = &This->state;
2113     const struct util_format_description *desc;
2114     struct NineSurface9 *source = state->ds;
2115     struct NineBaseTexture9 *destination = state->texture[0];
2116     struct pipe_resource *src, *dst;
2117     struct pipe_blit_info blit;
2118
2119     DBG("RESZ resolve\n");
2120
2121     user_assert(source && destination &&
2122                 destination->base.type == D3DRTYPE_TEXTURE, D3DERR_INVALIDCALL);
2123
2124     src = source->base.resource;
2125     dst = destination->base.resource;
2126
2127     user_assert(src && dst, D3DERR_INVALIDCALL);
2128
2129     /* check dst is depth format. we know already for src */
2130     desc = util_format_description(dst->format);
2131     user_assert(desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS, D3DERR_INVALIDCALL);
2132
2133     blit.src.resource = src;
2134     blit.src.level = 0;
2135     blit.src.format = src->format;
2136     blit.src.box.z = 0;
2137     blit.src.box.depth = 1;
2138     blit.src.box.x = 0;
2139     blit.src.box.y = 0;
2140     blit.src.box.width = src->width0;
2141     blit.src.box.height = src->height0;
2142
2143     blit.dst.resource = dst;
2144     blit.dst.level = 0;
2145     blit.dst.format = dst->format;
2146     blit.dst.box.z = 0;
2147     blit.dst.box.depth = 1;
2148     blit.dst.box.x = 0;
2149     blit.dst.box.y = 0;
2150     blit.dst.box.width = dst->width0;
2151     blit.dst.box.height = dst->height0;
2152
2153     blit.mask = PIPE_MASK_ZS;
2154     blit.filter = PIPE_TEX_FILTER_NEAREST;
2155     blit.scissor_enable = FALSE;
2156
2157     This->pipe->blit(This->pipe, &blit);
2158     return D3D_OK;
2159 }
2160
2161 #define ALPHA_TO_COVERAGE_ENABLE   MAKEFOURCC('A', '2', 'M', '1')
2162 #define ALPHA_TO_COVERAGE_DISABLE  MAKEFOURCC('A', '2', 'M', '0')
2163
2164 HRESULT WINAPI
2165 NineDevice9_SetRenderState( struct NineDevice9 *This,
2166                             D3DRENDERSTATETYPE State,
2167                             DWORD Value )
2168 {
2169     struct nine_state *state = This->update;
2170
2171     DBG("This=%p State=%u(%s) Value=%08x\n", This,
2172         State, nine_d3drs_to_string(State), Value);
2173
2174     /* Amd hacks (equivalent to GL extensions) */
2175     if (State == D3DRS_POINTSIZE) {
2176         if (Value == RESZ_CODE)
2177             return NineDevice9_ResolveZ(This);
2178
2179         if (Value == ALPHA_TO_COVERAGE_ENABLE ||
2180             Value == ALPHA_TO_COVERAGE_DISABLE) {
2181             state->rs[NINED3DRS_ALPHACOVERAGE] = (Value == ALPHA_TO_COVERAGE_ENABLE);
2182             state->changed.group |= NINE_STATE_BLEND;
2183             return D3D_OK;
2184         }
2185     }
2186
2187     /* NV hack */
2188     if (State == D3DRS_ADAPTIVETESS_Y &&
2189         (Value == D3DFMT_ATOC || (Value == D3DFMT_UNKNOWN && state->rs[NINED3DRS_ALPHACOVERAGE]))) {
2190             state->rs[NINED3DRS_ALPHACOVERAGE] = (Value == D3DFMT_ATOC);
2191             state->changed.group |= NINE_STATE_BLEND;
2192             return D3D_OK;
2193     }
2194
2195     user_assert(State < Elements(state->rs), D3DERR_INVALIDCALL);
2196
2197     if (likely(state->rs[State] != Value) || unlikely(This->is_recording)) {
2198         state->rs[State] = Value;
2199         state->changed.rs[State / 32] |= 1 << (State % 32);
2200         state->changed.group |= nine_render_state_group[State];
2201     }
2202
2203     return D3D_OK;
2204 }
2205
2206 HRESULT WINAPI
2207 NineDevice9_GetRenderState( struct NineDevice9 *This,
2208                             D3DRENDERSTATETYPE State,
2209                             DWORD *pValue )
2210 {
2211     user_assert(State < Elements(This->state.rs), D3DERR_INVALIDCALL);
2212
2213     *pValue = This->state.rs[State];
2214     return D3D_OK;
2215 }
2216
2217 HRESULT WINAPI
2218 NineDevice9_CreateStateBlock( struct NineDevice9 *This,
2219                               D3DSTATEBLOCKTYPE Type,
2220                               IDirect3DStateBlock9 **ppSB )
2221 {
2222     struct NineStateBlock9 *nsb;
2223     struct nine_state *dst;
2224     HRESULT hr;
2225     enum nine_stateblock_type type;
2226     unsigned s;
2227
2228     DBG("This=%p Type=%u ppSB=%p\n", This, Type, ppSB);
2229
2230     user_assert(Type == D3DSBT_ALL ||
2231                 Type == D3DSBT_VERTEXSTATE ||
2232                 Type == D3DSBT_PIXELSTATE, D3DERR_INVALIDCALL);
2233
2234     switch (Type) {
2235     case D3DSBT_VERTEXSTATE: type = NINESBT_VERTEXSTATE; break;
2236     case D3DSBT_PIXELSTATE:  type = NINESBT_PIXELSTATE; break;
2237     default:
2238        type = NINESBT_ALL;
2239        break;
2240     }
2241
2242     hr = NineStateBlock9_new(This, &nsb, type);
2243     if (FAILED(hr))
2244        return hr;
2245     *ppSB = (IDirect3DStateBlock9 *)nsb;
2246     dst = &nsb->state;
2247
2248     dst->changed.group =
2249        NINE_STATE_TEXTURE |
2250        NINE_STATE_SAMPLER;
2251
2252     if (Type == D3DSBT_ALL || Type == D3DSBT_VERTEXSTATE) {
2253        dst->changed.group |=
2254            NINE_STATE_FF_LIGHTING |
2255            NINE_STATE_VS | NINE_STATE_VS_CONST |
2256            NINE_STATE_VDECL;
2257        /* TODO: texture/sampler state */
2258        memcpy(dst->changed.rs,
2259               nine_render_states_vertex, sizeof(dst->changed.rs));
2260        nine_ranges_insert(&dst->changed.vs_const_f, 0, This->max_vs_const_f,
2261                           &This->range_pool);
2262        dst->changed.vs_const_i = 0xffff;
2263        dst->changed.vs_const_b = 0xffff;
2264        for (s = 0; s < NINE_MAX_SAMPLERS; ++s)
2265            dst->changed.sampler[s] |= 1 << D3DSAMP_DMAPOFFSET;
2266        if (This->state.ff.num_lights) {
2267            dst->ff.num_lights = This->state.ff.num_lights;
2268            /* zero'd -> light type won't be NINED3DLIGHT_INVALID, so
2269             * all currently existing lights will be captured
2270             */
2271            dst->ff.light = CALLOC(This->state.ff.num_lights,
2272                                   sizeof(D3DLIGHT9));
2273            if (!dst->ff.light) {
2274                nine_bind(ppSB, NULL);
2275                return E_OUTOFMEMORY;
2276            }
2277        }
2278     }
2279     if (Type == D3DSBT_ALL || Type == D3DSBT_PIXELSTATE) {
2280        dst->changed.group |=
2281           NINE_STATE_PS | NINE_STATE_PS_CONST;
2282        /* TODO: texture/sampler state */
2283        memcpy(dst->changed.rs,
2284               nine_render_states_pixel, sizeof(dst->changed.rs));
2285        nine_ranges_insert(&dst->changed.ps_const_f, 0, This->max_ps_const_f,
2286                           &This->range_pool);
2287        dst->changed.ps_const_i = 0xffff;
2288        dst->changed.ps_const_b = 0xffff;
2289        for (s = 0; s < NINE_MAX_SAMPLERS; ++s)
2290            dst->changed.sampler[s] |= 0x1ffe;
2291     }
2292     if (Type == D3DSBT_ALL) {
2293        dst->changed.group |=
2294           NINE_STATE_VIEWPORT |
2295           NINE_STATE_SCISSOR |
2296           NINE_STATE_RASTERIZER |
2297           NINE_STATE_BLEND |
2298           NINE_STATE_DSA |
2299           NINE_STATE_IDXBUF |
2300           NINE_STATE_MATERIAL |
2301           NINE_STATE_BLEND_COLOR |
2302           NINE_STATE_SAMPLE_MASK;
2303        memset(dst->changed.rs, ~0, (D3DRS_COUNT / 32) * sizeof(uint32_t));
2304        dst->changed.rs[D3DRS_LAST / 32] |= (1 << (D3DRS_COUNT % 32)) - 1;
2305        dst->changed.vtxbuf = (1ULL << This->caps.MaxStreams) - 1;
2306        dst->changed.stream_freq = dst->changed.vtxbuf;
2307        dst->changed.ucp = (1 << PIPE_MAX_CLIP_PLANES) - 1;
2308        dst->changed.texture = (1 << NINE_MAX_SAMPLERS) - 1;
2309     }
2310     NineStateBlock9_Capture(NineStateBlock9(*ppSB));
2311
2312     /* TODO: fixed function state */
2313
2314     return D3D_OK;
2315 }
2316
2317 HRESULT WINAPI
2318 NineDevice9_BeginStateBlock( struct NineDevice9 *This )
2319 {
2320     HRESULT hr;
2321
2322     DBG("This=%p\n", This);
2323
2324     user_assert(!This->record, D3DERR_INVALIDCALL);
2325
2326     hr = NineStateBlock9_new(This, &This->record, NINESBT_CUSTOM);
2327     if (FAILED(hr))
2328         return hr;
2329     NineUnknown_ConvertRefToBind(NineUnknown(This->record));
2330
2331     This->update = &This->record->state;
2332     This->is_recording = TRUE;
2333
2334     return D3D_OK;
2335 }
2336
2337 HRESULT WINAPI
2338 NineDevice9_EndStateBlock( struct NineDevice9 *This,
2339                            IDirect3DStateBlock9 **ppSB )
2340 {
2341     DBG("This=%p ppSB=%p\n", This, ppSB);
2342
2343     user_assert(This->record, D3DERR_INVALIDCALL);
2344
2345     This->update = &This->state;
2346     This->is_recording = FALSE;
2347
2348     NineUnknown_AddRef(NineUnknown(This->record));
2349     *ppSB = (IDirect3DStateBlock9 *)This->record;
2350     NineUnknown_Unbind(NineUnknown(This->record));
2351     This->record = NULL;
2352
2353     return D3D_OK;
2354 }
2355
2356 HRESULT WINAPI
2357 NineDevice9_SetClipStatus( struct NineDevice9 *This,
2358                            const D3DCLIPSTATUS9 *pClipStatus )
2359 {
2360     STUB(D3DERR_INVALIDCALL);
2361 }
2362
2363 HRESULT WINAPI
2364 NineDevice9_GetClipStatus( struct NineDevice9 *This,
2365                            D3DCLIPSTATUS9 *pClipStatus )
2366 {
2367     STUB(D3DERR_INVALIDCALL);
2368 }
2369
2370 HRESULT WINAPI
2371 NineDevice9_GetTexture( struct NineDevice9 *This,
2372                         DWORD Stage,
2373                         IDirect3DBaseTexture9 **ppTexture )
2374 {
2375     user_assert(Stage < This->caps.MaxSimultaneousTextures ||
2376                 Stage == D3DDMAPSAMPLER ||
2377                 (Stage >= D3DVERTEXTEXTURESAMPLER0 &&
2378                  Stage <= D3DVERTEXTEXTURESAMPLER3), D3DERR_INVALIDCALL);
2379     user_assert(ppTexture, D3DERR_INVALIDCALL);
2380
2381     if (Stage >= D3DDMAPSAMPLER)
2382         Stage = Stage - D3DDMAPSAMPLER + NINE_MAX_SAMPLERS_PS;
2383
2384     *ppTexture = (IDirect3DBaseTexture9 *)This->state.texture[Stage];
2385
2386     if (This->state.texture[Stage])
2387         NineUnknown_AddRef(NineUnknown(This->state.texture[Stage]));
2388     return D3D_OK;
2389 }
2390
2391 HRESULT WINAPI
2392 NineDevice9_SetTexture( struct NineDevice9 *This,
2393                         DWORD Stage,
2394                         IDirect3DBaseTexture9 *pTexture )
2395 {
2396     struct nine_state *state = This->update;
2397     struct NineBaseTexture9 *tex = NineBaseTexture9(pTexture);
2398
2399     DBG("This=%p Stage=%u pTexture=%p\n", This, Stage, pTexture);
2400
2401     user_assert(Stage < This->caps.MaxSimultaneousTextures ||
2402                 Stage == D3DDMAPSAMPLER ||
2403                 (Stage >= D3DVERTEXTEXTURESAMPLER0 &&
2404                  Stage <= D3DVERTEXTEXTURESAMPLER3), D3DERR_INVALIDCALL);
2405     user_assert(!tex || tex->base.pool != D3DPOOL_SCRATCH, D3DERR_INVALIDCALL);
2406
2407     if (unlikely(tex && tex->base.pool == D3DPOOL_SYSTEMMEM)) {
2408         /* TODO: Currently not implemented. Better return error
2409          * with message telling what's wrong */
2410         ERR("This=%p D3DPOOL_SYSTEMMEM not implemented for SetTexture\n", This);
2411         user_assert(tex->base.pool != D3DPOOL_SYSTEMMEM, D3DERR_INVALIDCALL);
2412     }
2413
2414     if (Stage >= D3DDMAPSAMPLER)
2415         Stage = Stage - D3DDMAPSAMPLER + NINE_MAX_SAMPLERS_PS;
2416
2417     if (!This->is_recording) {
2418         struct NineBaseTexture9 *old = state->texture[Stage];
2419         if (old == tex)
2420             return D3D_OK;
2421
2422         state->samplers_shadow &= ~(1 << Stage);
2423         if (tex) {
2424             state->samplers_shadow |= tex->shadow << Stage;
2425
2426             if ((tex->dirty | tex->dirty_mip) && LIST_IS_EMPTY(&tex->list))
2427                 list_add(&tex->list, &This->update_textures);
2428
2429             tex->bind_count++;
2430         }
2431         if (old)
2432             old->bind_count--;
2433     }
2434     nine_bind(&state->texture[Stage], pTexture);
2435
2436     state->changed.texture |= 1 << Stage;
2437     state->changed.group |= NINE_STATE_TEXTURE;
2438
2439     return D3D_OK;
2440 }
2441
2442 HRESULT WINAPI
2443 NineDevice9_GetTextureStageState( struct NineDevice9 *This,
2444                                   DWORD Stage,
2445                                   D3DTEXTURESTAGESTATETYPE Type,
2446                                   DWORD *pValue )
2447 {
2448     const struct nine_state *state = &This->state;
2449
2450     user_assert(Stage < Elements(state->ff.tex_stage), D3DERR_INVALIDCALL);
2451     user_assert(Type < Elements(state->ff.tex_stage[0]), D3DERR_INVALIDCALL);
2452
2453     *pValue = state->ff.tex_stage[Stage][Type];
2454
2455     return D3D_OK;
2456 }
2457
2458 HRESULT WINAPI
2459 NineDevice9_SetTextureStageState( struct NineDevice9 *This,
2460                                   DWORD Stage,
2461                                   D3DTEXTURESTAGESTATETYPE Type,
2462                                   DWORD Value )
2463 {
2464     struct nine_state *state = This->update;
2465
2466     DBG("Stage=%u Type=%u Value=%08x\n", Stage, Type, Value);
2467     nine_dump_D3DTSS_value(DBG_FF, Type, Value);
2468
2469     user_assert(Stage < Elements(state->ff.tex_stage), D3DERR_INVALIDCALL);
2470     user_assert(Type < Elements(state->ff.tex_stage[0]), D3DERR_INVALIDCALL);
2471
2472     state->ff.tex_stage[Stage][Type] = Value;
2473
2474     state->changed.group |= NINE_STATE_FF_PSSTAGES;
2475     state->ff.changed.tex_stage[Stage][Type / 32] |= 1 << (Type % 32);
2476
2477     return D3D_OK;
2478 }
2479
2480 HRESULT WINAPI
2481 NineDevice9_GetSamplerState( struct NineDevice9 *This,
2482                              DWORD Sampler,
2483                              D3DSAMPLERSTATETYPE Type,
2484                              DWORD *pValue )
2485 {
2486     user_assert(Sampler < This->caps.MaxSimultaneousTextures ||
2487                 Sampler == D3DDMAPSAMPLER ||
2488                 (Sampler >= D3DVERTEXTEXTURESAMPLER0 &&
2489                  Sampler <= D3DVERTEXTEXTURESAMPLER3), D3DERR_INVALIDCALL);
2490
2491     if (Sampler >= D3DDMAPSAMPLER)
2492         Sampler = Sampler - D3DDMAPSAMPLER + NINE_MAX_SAMPLERS_PS;
2493
2494     *pValue = This->state.samp[Sampler][Type];
2495     return D3D_OK;
2496 }
2497
2498 HRESULT WINAPI
2499 NineDevice9_SetSamplerState( struct NineDevice9 *This,
2500                              DWORD Sampler,
2501                              D3DSAMPLERSTATETYPE Type,
2502                              DWORD Value )
2503 {
2504     struct nine_state *state = This->update;
2505
2506     DBG("This=%p Sampler=%u Type=%s Value=%08x\n", This,
2507         Sampler, nine_D3DSAMP_to_str(Type), Value);
2508
2509     user_assert(Sampler < This->caps.MaxSimultaneousTextures ||
2510                 Sampler == D3DDMAPSAMPLER ||
2511                 (Sampler >= D3DVERTEXTEXTURESAMPLER0 &&
2512                  Sampler <= D3DVERTEXTEXTURESAMPLER3), D3DERR_INVALIDCALL);
2513
2514     if (Sampler >= D3DDMAPSAMPLER)
2515         Sampler = Sampler - D3DDMAPSAMPLER + NINE_MAX_SAMPLERS_PS;
2516
2517     state->samp[Sampler][Type] = Value;
2518     state->changed.group |= NINE_STATE_SAMPLER;
2519     state->changed.sampler[Sampler] |= 1 << Type;
2520
2521     if (Type == D3DSAMP_SRGBTEXTURE)
2522         state->changed.srgb = TRUE;
2523
2524     return D3D_OK;
2525 }
2526
2527 HRESULT WINAPI
2528 NineDevice9_ValidateDevice( struct NineDevice9 *This,
2529                             DWORD *pNumPasses )
2530 {
2531     const struct nine_state *state = &This->state;
2532     unsigned i;
2533     unsigned w = 0, h = 0;
2534
2535     DBG("This=%p pNumPasses=%p\n", This, pNumPasses);
2536
2537     for (i = 0; i < Elements(state->samp); ++i) {
2538         if (state->samp[i][D3DSAMP_MINFILTER] == D3DTEXF_NONE ||
2539             state->samp[i][D3DSAMP_MAGFILTER] == D3DTEXF_NONE)
2540             return D3DERR_UNSUPPORTEDTEXTUREFILTER;
2541     }
2542
2543     for (i = 0; i < This->caps.NumSimultaneousRTs; ++i) {
2544         if (!state->rt[i])
2545             continue;
2546         if (w == 0) {
2547             w = state->rt[i]->desc.Width;
2548             h = state->rt[i]->desc.Height;
2549         } else
2550         if (state->rt[i]->desc.Width != w || state->rt[i]->desc.Height != h) {
2551             return D3DERR_CONFLICTINGRENDERSTATE;
2552         }
2553     }
2554     if (state->ds &&
2555         (state->rs[D3DRS_ZENABLE] || state->rs[D3DRS_STENCILENABLE])) {
2556         if (w != 0 &&
2557             (state->ds->desc.Width != w || state->ds->desc.Height != h))
2558             return D3DERR_CONFLICTINGRENDERSTATE;
2559     }
2560
2561     if (pNumPasses)
2562         *pNumPasses = 1;
2563
2564     return D3D_OK;
2565 }
2566
2567 HRESULT WINAPI
2568 NineDevice9_SetPaletteEntries( struct NineDevice9 *This,
2569                                UINT PaletteNumber,
2570                                const PALETTEENTRY *pEntries )
2571 {
2572     STUB(D3D_OK); /* like wine */
2573 }
2574
2575 HRESULT WINAPI
2576 NineDevice9_GetPaletteEntries( struct NineDevice9 *This,
2577                                UINT PaletteNumber,
2578                                PALETTEENTRY *pEntries )
2579 {
2580     STUB(D3DERR_INVALIDCALL);
2581 }
2582
2583 HRESULT WINAPI
2584 NineDevice9_SetCurrentTexturePalette( struct NineDevice9 *This,
2585                                       UINT PaletteNumber )
2586 {
2587     STUB(D3D_OK); /* like wine */
2588 }
2589
2590 HRESULT WINAPI
2591 NineDevice9_GetCurrentTexturePalette( struct NineDevice9 *This,
2592                                       UINT *PaletteNumber )
2593 {
2594     STUB(D3DERR_INVALIDCALL);
2595 }
2596
2597 HRESULT WINAPI
2598 NineDevice9_SetScissorRect( struct NineDevice9 *This,
2599                             const RECT *pRect )
2600 {
2601     struct nine_state *state = This->update;
2602
2603     DBG("x=(%u..%u) y=(%u..%u)\n",
2604         pRect->left, pRect->top, pRect->right, pRect->bottom);
2605
2606     state->scissor.minx = pRect->left;
2607     state->scissor.miny = pRect->top;
2608     state->scissor.maxx = pRect->right;
2609     state->scissor.maxy = pRect->bottom;
2610
2611     state->changed.group |= NINE_STATE_SCISSOR;
2612
2613     return D3D_OK;
2614 }
2615
2616 HRESULT WINAPI
2617 NineDevice9_GetScissorRect( struct NineDevice9 *This,
2618                             RECT *pRect )
2619 {
2620     pRect->left   = This->state.scissor.minx;
2621     pRect->top    = This->state.scissor.miny;
2622     pRect->right  = This->state.scissor.maxx;
2623     pRect->bottom = This->state.scissor.maxy;
2624
2625     return D3D_OK;
2626 }
2627
2628 HRESULT WINAPI
2629 NineDevice9_SetSoftwareVertexProcessing( struct NineDevice9 *This,
2630                                          BOOL bSoftware )
2631 {
2632     STUB(D3DERR_INVALIDCALL);
2633 }
2634
2635 BOOL WINAPI
2636 NineDevice9_GetSoftwareVertexProcessing( struct NineDevice9 *This )
2637 {
2638     return !!(This->params.BehaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING);
2639 }
2640
2641 HRESULT WINAPI
2642 NineDevice9_SetNPatchMode( struct NineDevice9 *This,
2643                            float nSegments )
2644 {
2645     STUB(D3DERR_INVALIDCALL);
2646 }
2647
2648 float WINAPI
2649 NineDevice9_GetNPatchMode( struct NineDevice9 *This )
2650 {
2651     STUB(0);
2652 }
2653
2654 static INLINE void
2655 init_draw_info(struct pipe_draw_info *info,
2656                struct NineDevice9 *dev, D3DPRIMITIVETYPE type, UINT count)
2657 {
2658     info->mode = d3dprimitivetype_to_pipe_prim(type);
2659     info->count = prim_count_to_vertex_count(type, count);
2660     info->start_instance = 0;
2661     info->instance_count = 1;
2662     if (dev->state.stream_instancedata_mask & dev->state.stream_usage_mask)
2663         info->instance_count = MAX2(dev->state.stream_freq[0] & 0x7FFFFF, 1);
2664     info->primitive_restart = FALSE;
2665     info->restart_index = 0;
2666     info->count_from_stream_output = NULL;
2667     info->indirect = NULL;
2668 }
2669
2670 HRESULT WINAPI
2671 NineDevice9_DrawPrimitive( struct NineDevice9 *This,
2672                            D3DPRIMITIVETYPE PrimitiveType,
2673                            UINT StartVertex,
2674                            UINT PrimitiveCount )
2675 {
2676     struct pipe_draw_info info;
2677
2678     DBG("iface %p, PrimitiveType %u, StartVertex %u, PrimitiveCount %u\n",
2679         This, PrimitiveType, StartVertex, PrimitiveCount);
2680
2681     nine_update_state(This, ~0);
2682
2683     init_draw_info(&info, This, PrimitiveType, PrimitiveCount);
2684     info.indexed = FALSE;
2685     info.start = StartVertex;
2686     info.index_bias = 0;
2687     info.min_index = info.start;
2688     info.max_index = info.count - 1;
2689
2690     This->pipe->draw_vbo(This->pipe, &info);
2691
2692     return D3D_OK;
2693 }
2694
2695 HRESULT WINAPI
2696 NineDevice9_DrawIndexedPrimitive( struct NineDevice9 *This,
2697                                   D3DPRIMITIVETYPE PrimitiveType,
2698                                   INT BaseVertexIndex,
2699                                   UINT MinVertexIndex,
2700                                   UINT NumVertices,
2701                                   UINT StartIndex,
2702                                   UINT PrimitiveCount )
2703 {
2704     struct pipe_draw_info info;
2705
2706     DBG("iface %p, PrimitiveType %u, BaseVertexIndex %u, MinVertexIndex %u "
2707         "NumVertices %u, StartIndex %u, PrimitiveCount %u\n",
2708         This, PrimitiveType, BaseVertexIndex, MinVertexIndex, NumVertices,
2709         StartIndex, PrimitiveCount);
2710
2711     user_assert(This->state.idxbuf, D3DERR_INVALIDCALL);
2712     user_assert(This->state.vdecl, D3DERR_INVALIDCALL);
2713
2714     nine_update_state(This, ~0);
2715
2716     init_draw_info(&info, This, PrimitiveType, PrimitiveCount);
2717     info.indexed = TRUE;
2718     info.start = StartIndex;
2719     info.index_bias = BaseVertexIndex;
2720     /* These don't include index bias: */
2721     info.min_index = MinVertexIndex;
2722     info.max_index = MinVertexIndex + NumVertices - 1;
2723
2724     This->pipe->draw_vbo(This->pipe, &info);
2725
2726     return D3D_OK;
2727 }
2728
2729 HRESULT WINAPI
2730 NineDevice9_DrawPrimitiveUP( struct NineDevice9 *This,
2731                              D3DPRIMITIVETYPE PrimitiveType,
2732                              UINT PrimitiveCount,
2733                              const void *pVertexStreamZeroData,
2734                              UINT VertexStreamZeroStride )
2735 {
2736     struct pipe_vertex_buffer vtxbuf;
2737     struct pipe_draw_info info;
2738
2739     DBG("iface %p, PrimitiveType %u, PrimitiveCount %u, data %p, stride %u\n",
2740         This, PrimitiveType, PrimitiveCount,
2741         pVertexStreamZeroData, VertexStreamZeroStride);
2742
2743     user_assert(pVertexStreamZeroData && VertexStreamZeroStride,
2744                 D3DERR_INVALIDCALL);
2745
2746     nine_update_state(This, ~0);
2747
2748     init_draw_info(&info, This, PrimitiveType, PrimitiveCount);
2749     info.indexed = FALSE;
2750     info.start = 0;
2751     info.index_bias = 0;
2752     info.min_index = 0;
2753     info.max_index = info.count - 1;
2754
2755     vtxbuf.stride = VertexStreamZeroStride;
2756     vtxbuf.buffer_offset = 0;
2757     vtxbuf.buffer = NULL;
2758     vtxbuf.user_buffer = pVertexStreamZeroData;
2759
2760     if (!This->driver_caps.user_vbufs)
2761         u_upload_data(This->upload,
2762                       0,
2763                       (info.max_index + 1) * VertexStreamZeroStride, /* XXX */
2764                       vtxbuf.user_buffer,
2765                       &vtxbuf.buffer_offset,
2766                       &vtxbuf.buffer);
2767
2768     This->pipe->set_vertex_buffers(This->pipe, 0, 1, &vtxbuf);
2769
2770     This->pipe->draw_vbo(This->pipe, &info);
2771
2772     NineDevice9_PauseRecording(This);
2773     NineDevice9_SetStreamSource(This, 0, NULL, 0, 0);
2774     NineDevice9_ResumeRecording(This);
2775
2776     pipe_resource_reference(&vtxbuf.buffer, NULL);
2777
2778     return D3D_OK;
2779 }
2780
2781 HRESULT WINAPI
2782 NineDevice9_DrawIndexedPrimitiveUP( struct NineDevice9 *This,
2783                                     D3DPRIMITIVETYPE PrimitiveType,
2784                                     UINT MinVertexIndex,
2785                                     UINT NumVertices,
2786                                     UINT PrimitiveCount,
2787                                     const void *pIndexData,
2788                                     D3DFORMAT IndexDataFormat,
2789                                     const void *pVertexStreamZeroData,
2790                                     UINT VertexStreamZeroStride )
2791 {
2792     struct pipe_draw_info info;
2793     struct pipe_vertex_buffer vbuf;
2794     struct pipe_index_buffer ibuf;
2795
2796     DBG("iface %p, PrimitiveType %u, MinVertexIndex %u, NumVertices %u "
2797         "PrimitiveCount %u, pIndexData %p, IndexDataFormat %u "
2798         "pVertexStreamZeroData %p, VertexStreamZeroStride %u\n",
2799         This, PrimitiveType, MinVertexIndex, NumVertices, PrimitiveCount,
2800         pIndexData, IndexDataFormat,
2801         pVertexStreamZeroData, VertexStreamZeroStride);
2802
2803     user_assert(pIndexData && pVertexStreamZeroData, D3DERR_INVALIDCALL);
2804     user_assert(VertexStreamZeroStride, D3DERR_INVALIDCALL);
2805     user_assert(IndexDataFormat == D3DFMT_INDEX16 ||
2806                 IndexDataFormat == D3DFMT_INDEX32, D3DERR_INVALIDCALL);
2807
2808     nine_update_state(This, ~0);
2809
2810     init_draw_info(&info, This, PrimitiveType, PrimitiveCount);
2811     info.indexed = TRUE;
2812     info.start = 0;
2813     info.index_bias = 0;
2814     info.min_index = MinVertexIndex;
2815     info.max_index = MinVertexIndex + NumVertices - 1;
2816
2817     vbuf.stride = VertexStreamZeroStride;
2818     vbuf.buffer_offset = 0;
2819     vbuf.buffer = NULL;
2820     vbuf.user_buffer = pVertexStreamZeroData;
2821
2822     ibuf.index_size = (IndexDataFormat == D3DFMT_INDEX16) ? 2 : 4;
2823     ibuf.offset = 0;
2824     ibuf.buffer = NULL;
2825     ibuf.user_buffer = pIndexData;
2826
2827     if (!This->driver_caps.user_vbufs) {
2828         const unsigned base = info.min_index * VertexStreamZeroStride;
2829         u_upload_data(This->upload,
2830                       base,
2831                       (info.max_index -
2832                        info.min_index + 1) * VertexStreamZeroStride, /* XXX */
2833                       (const uint8_t *)vbuf.user_buffer + base,
2834                       &vbuf.buffer_offset,
2835                       &vbuf.buffer);
2836         /* Won't be used: */
2837         vbuf.buffer_offset -= base;
2838     }
2839     if (!This->driver_caps.user_ibufs)
2840         u_upload_data(This->upload,
2841                       0,
2842                       info.count * ibuf.index_size,
2843                       ibuf.user_buffer,
2844                       &ibuf.offset,
2845                       &ibuf.buffer);
2846
2847     This->pipe->set_vertex_buffers(This->pipe, 0, 1, &vbuf);
2848     This->pipe->set_index_buffer(This->pipe, &ibuf);
2849
2850     This->pipe->draw_vbo(This->pipe, &info);
2851
2852     pipe_resource_reference(&vbuf.buffer, NULL);
2853     pipe_resource_reference(&ibuf.buffer, NULL);
2854
2855     NineDevice9_PauseRecording(This);
2856     NineDevice9_SetIndices(This, NULL);
2857     NineDevice9_SetStreamSource(This, 0, NULL, 0, 0);
2858     NineDevice9_ResumeRecording(This);
2859
2860     return D3D_OK;
2861 }
2862
2863 /* TODO: Write to pDestBuffer directly if vertex declaration contains
2864  * only f32 formats.
2865  */
2866 HRESULT WINAPI
2867 NineDevice9_ProcessVertices( struct NineDevice9 *This,
2868                              UINT SrcStartIndex,
2869                              UINT DestIndex,
2870                              UINT VertexCount,
2871                              IDirect3DVertexBuffer9 *pDestBuffer,
2872                              IDirect3DVertexDeclaration9 *pVertexDecl,
2873                              DWORD Flags )
2874 {
2875     struct pipe_screen *screen = This->screen;
2876     struct NineVertexDeclaration9 *vdecl = NineVertexDeclaration9(pVertexDecl);
2877     struct NineVertexShader9 *vs;
2878     struct pipe_resource *resource;
2879     struct pipe_stream_output_target *target;
2880     struct pipe_draw_info draw;
2881     HRESULT hr;
2882     unsigned buffer_offset, buffer_size;
2883
2884     DBG("This=%p SrcStartIndex=%u DestIndex=%u VertexCount=%u "
2885         "pDestBuffer=%p pVertexDecl=%p Flags=%d\n",
2886         This, SrcStartIndex, DestIndex, VertexCount, pDestBuffer,
2887         pVertexDecl, Flags);
2888
2889     if (!screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS))
2890         STUB(D3DERR_INVALIDCALL);
2891
2892     nine_update_state(This, ~0);
2893
2894     /* TODO: Create shader with stream output. */
2895     STUB(D3DERR_INVALIDCALL);
2896     struct NineVertexBuffer9 *dst = NineVertexBuffer9(pDestBuffer);
2897
2898     vs = This->state.vs ? This->state.vs : This->ff.vs;
2899
2900     buffer_size = VertexCount * vs->so->stride[0];
2901     if (1) {
2902         struct pipe_resource templ;
2903
2904         templ.target = PIPE_BUFFER;
2905         templ.format = PIPE_FORMAT_R8_UNORM;
2906         templ.width0 = buffer_size;
2907         templ.flags = 0;
2908         templ.bind = PIPE_BIND_STREAM_OUTPUT;
2909         templ.usage = PIPE_USAGE_STREAM;
2910         templ.height0 = templ.depth0 = templ.array_size = 1;
2911         templ.last_level = templ.nr_samples = 0;
2912
2913         resource = This->screen->resource_create(This->screen, &templ);
2914         if (!resource)
2915             return E_OUTOFMEMORY;
2916         buffer_offset = 0;
2917     } else {
2918         /* SO matches vertex declaration */
2919         resource = dst->base.resource;
2920         buffer_offset = DestIndex * vs->so->stride[0];
2921     }
2922     target = This->pipe->create_stream_output_target(This->pipe, resource,
2923                                                      buffer_offset,
2924                                                      buffer_size);
2925     if (!target) {
2926         pipe_resource_reference(&resource, NULL);
2927         return D3DERR_DRIVERINTERNALERROR;
2928     }
2929
2930     if (!vdecl) {
2931         hr = NineVertexDeclaration9_new_from_fvf(This, dst->desc.FVF, &vdecl);
2932         if (FAILED(hr))
2933             goto out;
2934     }
2935
2936     init_draw_info(&draw, This, D3DPT_POINTLIST, VertexCount);
2937     draw.instance_count = 1;
2938     draw.indexed = FALSE;
2939     draw.start = SrcStartIndex;
2940     draw.index_bias = 0;
2941     draw.min_index = SrcStartIndex;
2942     draw.max_index = SrcStartIndex + VertexCount - 1;
2943
2944     This->pipe->set_stream_output_targets(This->pipe, 1, &target, 0);
2945     This->pipe->draw_vbo(This->pipe, &draw);
2946     This->pipe->set_stream_output_targets(This->pipe, 0, NULL, 0);
2947     This->pipe->stream_output_target_destroy(This->pipe, target);
2948
2949     hr = NineVertexDeclaration9_ConvertStreamOutput(vdecl,
2950                                                     dst, DestIndex, VertexCount,
2951                                                     resource, vs->so);
2952 out:
2953     pipe_resource_reference(&resource, NULL);
2954     if (!pVertexDecl)
2955         NineUnknown_Release(NineUnknown(vdecl));
2956     return hr;
2957 }
2958
2959 HRESULT WINAPI
2960 NineDevice9_CreateVertexDeclaration( struct NineDevice9 *This,
2961                                      const D3DVERTEXELEMENT9 *pVertexElements,
2962                                      IDirect3DVertexDeclaration9 **ppDecl )
2963 {
2964     struct NineVertexDeclaration9 *vdecl;
2965
2966     DBG("This=%p pVertexElements=%p ppDecl=%p\n",
2967         This, pVertexElements, ppDecl);
2968
2969     HRESULT hr = NineVertexDeclaration9_new(This, pVertexElements, &vdecl);
2970     if (SUCCEEDED(hr))
2971         *ppDecl = (IDirect3DVertexDeclaration9 *)vdecl;
2972
2973     return hr;
2974 }
2975
2976 HRESULT WINAPI
2977 NineDevice9_SetVertexDeclaration( struct NineDevice9 *This,
2978                                   IDirect3DVertexDeclaration9 *pDecl )
2979 {
2980     struct nine_state *state = This->update;
2981
2982     DBG("This=%p pDecl=%p\n", This, pDecl);
2983
2984     if (likely(!This->is_recording) && state->vdecl == NineVertexDeclaration9(pDecl))
2985         return D3D_OK;
2986     nine_bind(&state->vdecl, pDecl);
2987
2988     state->changed.group |= NINE_STATE_VDECL;
2989
2990     return D3D_OK;
2991 }
2992
2993 HRESULT WINAPI
2994 NineDevice9_GetVertexDeclaration( struct NineDevice9 *This,
2995                                   IDirect3DVertexDeclaration9 **ppDecl )
2996 {
2997     user_assert(ppDecl, D3DERR_INVALIDCALL);
2998
2999     *ppDecl = (IDirect3DVertexDeclaration9 *)This->state.vdecl;
3000     if (*ppDecl)
3001         NineUnknown_AddRef(NineUnknown(*ppDecl));
3002     return D3D_OK;
3003 }
3004
3005 HRESULT WINAPI
3006 NineDevice9_SetFVF( struct NineDevice9 *This,
3007                     DWORD FVF )
3008 {
3009     struct NineVertexDeclaration9 *vdecl;
3010     HRESULT hr;
3011
3012     DBG("FVF = %08x\n", FVF);
3013     if (!FVF)
3014         return D3D_OK; /* like wine */
3015
3016     vdecl = util_hash_table_get(This->ff.ht_fvf, &FVF);
3017     if (!vdecl) {
3018         hr = NineVertexDeclaration9_new_from_fvf(This, FVF, &vdecl);
3019         if (FAILED(hr))
3020             return hr;
3021         vdecl->fvf = FVF;
3022         util_hash_table_set(This->ff.ht_fvf, &vdecl->fvf, vdecl);
3023         NineUnknown_ConvertRefToBind(NineUnknown(vdecl));
3024     }
3025     return NineDevice9_SetVertexDeclaration(
3026         This, (IDirect3DVertexDeclaration9 *)vdecl);
3027 }
3028
3029 HRESULT WINAPI
3030 NineDevice9_GetFVF( struct NineDevice9 *This,
3031                     DWORD *pFVF )
3032 {
3033     *pFVF = This->state.vdecl ? This->state.vdecl->fvf : 0;
3034     return D3D_OK;
3035 }
3036
3037 HRESULT WINAPI
3038 NineDevice9_CreateVertexShader( struct NineDevice9 *This,
3039                                 const DWORD *pFunction,
3040                                 IDirect3DVertexShader9 **ppShader )
3041 {
3042     struct NineVertexShader9 *vs;
3043     HRESULT hr;
3044
3045     DBG("This=%p pFunction=%p ppShader=%p\n", This, pFunction, ppShader);
3046
3047     hr = NineVertexShader9_new(This, &vs, pFunction, NULL);
3048     if (FAILED(hr))
3049         return hr;
3050     *ppShader = (IDirect3DVertexShader9 *)vs;
3051     return D3D_OK;
3052 }
3053
3054 HRESULT WINAPI
3055 NineDevice9_SetVertexShader( struct NineDevice9 *This,
3056                              IDirect3DVertexShader9 *pShader )
3057 {
3058     struct nine_state *state = This->update;
3059
3060     DBG("This=%p pShader=%p\n", This, pShader);
3061
3062     nine_bind(&state->vs, pShader);
3063
3064     state->changed.group |= NINE_STATE_VS;
3065
3066     return D3D_OK;
3067 }
3068
3069 HRESULT WINAPI
3070 NineDevice9_GetVertexShader( struct NineDevice9 *This,
3071                              IDirect3DVertexShader9 **ppShader )
3072 {
3073     user_assert(ppShader, D3DERR_INVALIDCALL);
3074     nine_reference_set(ppShader, This->state.vs);
3075     return D3D_OK;
3076 }
3077
3078 HRESULT WINAPI
3079 NineDevice9_SetVertexShaderConstantF( struct NineDevice9 *This,
3080                                       UINT StartRegister,
3081                                       const float *pConstantData,
3082                                       UINT Vector4fCount )
3083 {
3084     struct nine_state *state = This->update;
3085
3086     DBG("This=%p StartRegister=%u pConstantData=%p Vector4fCount=%u\n",
3087         This, StartRegister, pConstantData, Vector4fCount);
3088
3089     user_assert(StartRegister                  < This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
3090     user_assert(StartRegister + Vector4fCount <= This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
3091
3092     if (!Vector4fCount)
3093        return D3D_OK;
3094     user_assert(pConstantData, D3DERR_INVALIDCALL);
3095
3096     memcpy(&state->vs_const_f[StartRegister * 4],
3097            pConstantData,
3098            Vector4fCount * 4 * sizeof(state->vs_const_f[0]));
3099
3100     nine_ranges_insert(&state->changed.vs_const_f,
3101                        StartRegister, StartRegister + Vector4fCount,
3102                        &This->range_pool);
3103
3104     state->changed.group |= NINE_STATE_VS_CONST;
3105
3106     return D3D_OK;
3107 }
3108
3109 HRESULT WINAPI
3110 NineDevice9_GetVertexShaderConstantF( struct NineDevice9 *This,
3111                                       UINT StartRegister,
3112                                       float *pConstantData,
3113                                       UINT Vector4fCount )
3114 {
3115     const struct nine_state *state = &This->state;
3116
3117     user_assert(StartRegister                  < This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
3118     user_assert(StartRegister + Vector4fCount <= This->caps.MaxVertexShaderConst, D3DERR_INVALIDCALL);
3119     user_assert(pConstantData, D3DERR_INVALIDCALL);
3120
3121     memcpy(pConstantData,
3122            &state->vs_const_f[StartRegister * 4],
3123            Vector4fCount * 4 * sizeof(state->vs_const_f[0]));
3124
3125     return D3D_OK;
3126 }
3127
3128 HRESULT WINAPI
3129 NineDevice9_SetVertexShaderConstantI( struct NineDevice9 *This,
3130                                       UINT StartRegister,
3131                                       const int *pConstantData,
3132                                       UINT Vector4iCount )
3133 {
3134     struct nine_state *state = This->update;
3135     int i;
3136
3137     DBG("This=%p StartRegister=%u pConstantData=%p Vector4iCount=%u\n",
3138         This, StartRegister, pConstantData, Vector4iCount);
3139
3140     user_assert(StartRegister                  < NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
3141     user_assert(StartRegister + Vector4iCount <= NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
3142     user_assert(pConstantData, D3DERR_INVALIDCALL);
3143
3144     if (This->driver_caps.vs_integer) {
3145         memcpy(&state->vs_const_i[StartRegister][0],
3146                pConstantData,
3147                Vector4iCount * sizeof(state->vs_const_i[0]));
3148     } else {
3149         for (i = 0; i < Vector4iCount; i++) {
3150             state->vs_const_i[StartRegister+i][0] = fui((float)(pConstantData[4*i]));
3151             state->vs_const_i[StartRegister+i][1] = fui((float)(pConstantData[4*i+1]));
3152             state->vs_const_i[StartRegister+i][2] = fui((float)(pConstantData[4*i+2]));
3153             state->vs_const_i[StartRegister+i][3] = fui((float)(pConstantData[4*i+3]));
3154         }
3155     }
3156
3157     state->changed.vs_const_i |= ((1 << Vector4iCount) - 1) << StartRegister;
3158     state->changed.group |= NINE_STATE_VS_CONST;
3159
3160     return D3D_OK;
3161 }
3162
3163 HRESULT WINAPI
3164 NineDevice9_GetVertexShaderConstantI( struct NineDevice9 *This,
3165                                       UINT StartRegister,
3166                                       int *pConstantData,
3167                                       UINT Vector4iCount )
3168 {
3169     const struct nine_state *state = &This->state;
3170     int i;
3171
3172     user_assert(StartRegister                  < NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
3173     user_assert(StartRegister + Vector4iCount <= NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
3174     user_assert(pConstantData, D3DERR_INVALIDCALL);
3175
3176     if (This->driver_caps.vs_integer) {
3177         memcpy(pConstantData,
3178                &state->vs_const_i[StartRegister][0],
3179                Vector4iCount * sizeof(state->vs_const_i[0]));
3180     } else {
3181         for (i = 0; i < Vector4iCount; i++) {
3182             pConstantData[4*i] = (int32_t) uif(state->vs_const_i[StartRegister+i][0]);
3183             pConstantData[4*i+1] = (int32_t) uif(state->vs_const_i[StartRegister+i][1]);
3184             pConstantData[4*i+2] = (int32_t) uif(state->vs_const_i[StartRegister+i][2]);
3185             pConstantData[4*i+3] = (int32_t) uif(state->vs_const_i[StartRegister+i][3]);
3186         }
3187     }
3188
3189     return D3D_OK;
3190 }
3191
3192 HRESULT WINAPI
3193 NineDevice9_SetVertexShaderConstantB( struct NineDevice9 *This,
3194                                       UINT StartRegister,
3195                                       const BOOL *pConstantData,
3196                                       UINT BoolCount )
3197 {
3198     struct nine_state *state = This->update;
3199     int i;
3200     uint32_t bool_true = This->driver_caps.vs_integer ? 0xFFFFFFFF : fui(1.0f);
3201
3202     DBG("This=%p StartRegister=%u pConstantData=%p BoolCount=%u\n",
3203         This, StartRegister, pConstantData, BoolCount);
3204
3205     user_assert(StartRegister              < NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
3206     user_assert(StartRegister + BoolCount <= NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
3207     user_assert(pConstantData, D3DERR_INVALIDCALL);
3208
3209     for (i = 0; i < BoolCount; i++)
3210         state->vs_const_b[StartRegister + i] = pConstantData[i] ? bool_true : 0;
3211
3212     state->changed.vs_const_b |= ((1 << BoolCount) - 1) << StartRegister;
3213     state->changed.group |= NINE_STATE_VS_CONST;
3214
3215     return D3D_OK;
3216 }
3217
3218 HRESULT WINAPI
3219 NineDevice9_GetVertexShaderConstantB( struct NineDevice9 *This,
3220                                       UINT StartRegister,
3221                                       BOOL *pConstantData,
3222                                       UINT BoolCount )
3223 {
3224     const struct nine_state *state = &This->state;
3225     int i;
3226
3227     user_assert(StartRegister              < NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
3228     user_assert(StartRegister + BoolCount <= NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
3229     user_assert(pConstantData, D3DERR_INVALIDCALL);
3230
3231     for (i = 0; i < BoolCount; i++)
3232         pConstantData[i] = state->vs_const_b[StartRegister + i] != 0 ? TRUE : FALSE;
3233
3234     return D3D_OK;
3235 }
3236
3237 HRESULT WINAPI
3238 NineDevice9_SetStreamSource( struct NineDevice9 *This,
3239                              UINT StreamNumber,
3240                              IDirect3DVertexBuffer9 *pStreamData,
3241                              UINT OffsetInBytes,
3242                              UINT Stride )
3243 {
3244     struct nine_state *state = This->update;
3245     struct NineVertexBuffer9 *pVBuf9 = NineVertexBuffer9(pStreamData);
3246     const unsigned i = StreamNumber;
3247
3248     DBG("This=%p StreamNumber=%u pStreamData=%p OffsetInBytes=%u Stride=%u\n",
3249         This, StreamNumber, pStreamData, OffsetInBytes, Stride);
3250
3251     user_assert(StreamNumber < This->caps.MaxStreams, D3DERR_INVALIDCALL);
3252     user_assert(Stride <= This->caps.MaxStreamStride, D3DERR_INVALIDCALL);
3253
3254     if (likely(!This->is_recording)) {
3255         if (state->stream[i] == NineVertexBuffer9(pStreamData) &&
3256             state->vtxbuf[i].stride == Stride &&
3257             state->vtxbuf[i].buffer_offset == OffsetInBytes)
3258             return D3D_OK;
3259     }
3260     nine_bind(&state->stream[i], pStreamData);
3261
3262     state->changed.vtxbuf |= 1 << StreamNumber;
3263
3264     if (pStreamData) {
3265         state->vtxbuf[i].stride = Stride;
3266         state->vtxbuf[i].buffer_offset = OffsetInBytes;
3267     }
3268     state->vtxbuf[i].buffer = pStreamData ? pVBuf9->base.resource : NULL;
3269
3270     return D3D_OK;
3271 }
3272
3273 HRESULT WINAPI
3274 NineDevice9_GetStreamSource( struct NineDevice9 *This,
3275                              UINT StreamNumber,
3276                              IDirect3DVertexBuffer9 **ppStreamData,
3277                              UINT *pOffsetInBytes,
3278                              UINT *pStride )
3279 {
3280     const struct nine_state *state = &This->state;
3281     const unsigned i = StreamNumber;
3282
3283     user_assert(StreamNumber < This->caps.MaxStreams, D3DERR_INVALIDCALL);
3284     user_assert(ppStreamData, D3DERR_INVALIDCALL);
3285
3286     nine_reference_set(ppStreamData, state->stream[i]);
3287     *pStride = state->vtxbuf[i].stride;
3288     *pOffsetInBytes = state->vtxbuf[i].buffer_offset;
3289
3290     return D3D_OK;
3291 }
3292
3293 HRESULT WINAPI
3294 NineDevice9_SetStreamSourceFreq( struct NineDevice9 *This,
3295                                  UINT StreamNumber,
3296                                  UINT Setting )
3297 {
3298     struct nine_state *state = This->update;
3299     /* const UINT freq = Setting & 0x7FFFFF; */
3300
3301     DBG("This=%p StreamNumber=%u FrequencyParameter=0x%x\n", This,
3302         StreamNumber, Setting);
3303
3304     user_assert(StreamNumber < This->caps.MaxStreams, D3DERR_INVALIDCALL);
3305     user_assert(StreamNumber != 0 || !(Setting & D3DSTREAMSOURCE_INSTANCEDATA),
3306                 D3DERR_INVALIDCALL);
3307     user_assert(!((Setting & D3DSTREAMSOURCE_INSTANCEDATA) &&
3308                   (Setting & D3DSTREAMSOURCE_INDEXEDDATA)), D3DERR_INVALIDCALL);
3309     user_assert(Setting, D3DERR_INVALIDCALL);
3310
3311     state->stream_freq[StreamNumber] = Setting;
3312
3313     if (Setting & D3DSTREAMSOURCE_INSTANCEDATA)
3314         state->stream_instancedata_mask |= 1 << StreamNumber;
3315     else
3316         state->stream_instancedata_mask &= ~(1 << StreamNumber);
3317
3318     state->changed.stream_freq |= 1 << StreamNumber;
3319     return D3D_OK;
3320 }
3321
3322 HRESULT WINAPI
3323 NineDevice9_GetStreamSourceFreq( struct NineDevice9 *This,
3324                                  UINT StreamNumber,
3325                                  UINT *pSetting )
3326 {
3327     user_assert(StreamNumber < This->caps.MaxStreams, D3DERR_INVALIDCALL);
3328     *pSetting = This->state.stream_freq[StreamNumber];
3329     return D3D_OK;
3330 }
3331
3332 HRESULT WINAPI
3333 NineDevice9_SetIndices( struct NineDevice9 *This,
3334                         IDirect3DIndexBuffer9 *pIndexData )
3335 {
3336     struct nine_state *state = This->update;
3337
3338     DBG("This=%p pIndexData=%p\n", This, pIndexData);
3339
3340     if (likely(!This->is_recording))
3341         if (state->idxbuf == NineIndexBuffer9(pIndexData))
3342             return D3D_OK;
3343     nine_bind(&state->idxbuf, pIndexData);
3344
3345     state->changed.group |= NINE_STATE_IDXBUF;
3346
3347     return D3D_OK;
3348 }
3349
3350 /* XXX: wine/d3d9 doesn't have pBaseVertexIndex, and it doesn't make sense
3351  * here because it's an argument passed to the Draw calls.
3352  */
3353 HRESULT WINAPI
3354 NineDevice9_GetIndices( struct NineDevice9 *This,
3355                         IDirect3DIndexBuffer9 **ppIndexData /*,
3356                         UINT *pBaseVertexIndex */ )
3357 {
3358     user_assert(ppIndexData, D3DERR_INVALIDCALL);
3359     nine_reference_set(ppIndexData, This->state.idxbuf);
3360     return D3D_OK;
3361 }
3362
3363 HRESULT WINAPI
3364 NineDevice9_CreatePixelShader( struct NineDevice9 *This,
3365                                const DWORD *pFunction,
3366                                IDirect3DPixelShader9 **ppShader )
3367 {
3368     struct NinePixelShader9 *ps;
3369     HRESULT hr;
3370
3371     DBG("This=%p pFunction=%p ppShader=%p\n", This, pFunction, ppShader);
3372
3373     hr = NinePixelShader9_new(This, &ps, pFunction, NULL);
3374     if (FAILED(hr))
3375         return hr;
3376     *ppShader = (IDirect3DPixelShader9 *)ps;
3377     return D3D_OK;
3378 }
3379
3380 HRESULT WINAPI
3381 NineDevice9_SetPixelShader( struct NineDevice9 *This,
3382                             IDirect3DPixelShader9 *pShader )
3383 {
3384     struct nine_state *state = This->update;
3385     unsigned old_mask = state->ps ? state->ps->rt_mask : 1;
3386     unsigned mask;
3387
3388     DBG("This=%p pShader=%p\n", This, pShader);
3389
3390     nine_bind(&state->ps, pShader);
3391
3392     state->changed.group |= NINE_STATE_PS;
3393
3394     mask = state->ps ? state->ps->rt_mask : 1;
3395     /* We need to update cbufs if the pixel shader would
3396      * write to different render targets */
3397     if (mask != old_mask)
3398         state->changed.group |= NINE_STATE_FB;
3399
3400     return D3D_OK;
3401 }
3402
3403 HRESULT WINAPI
3404 NineDevice9_GetPixelShader( struct NineDevice9 *This,
3405                             IDirect3DPixelShader9 **ppShader )
3406 {
3407     user_assert(ppShader, D3DERR_INVALIDCALL);
3408     nine_reference_set(ppShader, This->state.ps);
3409     return D3D_OK;
3410 }
3411
3412 HRESULT WINAPI
3413 NineDevice9_SetPixelShaderConstantF( struct NineDevice9 *This,
3414                                      UINT StartRegister,
3415                                      const float *pConstantData,
3416                                      UINT Vector4fCount )
3417 {
3418     struct nine_state *state = This->update;
3419
3420     DBG("This=%p StartRegister=%u pConstantData=%p Vector4fCount=%u\n",
3421         This, StartRegister, pConstantData, Vector4fCount);
3422
3423     user_assert(StartRegister                  < NINE_MAX_CONST_F_PS3, D3DERR_INVALIDCALL);
3424     user_assert(StartRegister + Vector4fCount <= NINE_MAX_CONST_F_PS3, D3DERR_INVALIDCALL);
3425
3426     if (!Vector4fCount)
3427        return D3D_OK;
3428     user_assert(pConstantData, D3DERR_INVALIDCALL);
3429
3430     memcpy(&state->ps_const_f[StartRegister * 4],
3431            pConstantData,
3432            Vector4fCount * 4 * sizeof(state->ps_const_f[0]));
3433
3434     nine_ranges_insert(&state->changed.ps_const_f,
3435                        StartRegister, StartRegister + Vector4fCount,
3436                        &This->range_pool);
3437
3438     state->changed.group |= NINE_STATE_PS_CONST;
3439
3440     return D3D_OK;
3441 }
3442
3443 HRESULT WINAPI
3444 NineDevice9_GetPixelShaderConstantF( struct NineDevice9 *This,
3445                                      UINT StartRegister,
3446                                      float *pConstantData,
3447                                      UINT Vector4fCount )
3448 {
3449     const struct nine_state *state = &This->state;
3450
3451     user_assert(StartRegister                  < NINE_MAX_CONST_F_PS3, D3DERR_INVALIDCALL);
3452     user_assert(StartRegister + Vector4fCount <= NINE_MAX_CONST_F_PS3, D3DERR_INVALIDCALL);
3453     user_assert(pConstantData, D3DERR_INVALIDCALL);
3454
3455     memcpy(pConstantData,
3456            &state->ps_const_f[StartRegister * 4],
3457            Vector4fCount * 4 * sizeof(state->ps_const_f[0]));
3458
3459     return D3D_OK;
3460 }
3461
3462 HRESULT WINAPI
3463 NineDevice9_SetPixelShaderConstantI( struct NineDevice9 *This,
3464                                      UINT StartRegister,
3465                                      const int *pConstantData,
3466                                      UINT Vector4iCount )
3467 {
3468     struct nine_state *state = This->update;
3469     int i;
3470
3471     DBG("This=%p StartRegister=%u pConstantData=%p Vector4iCount=%u\n",
3472         This, StartRegister, pConstantData, Vector4iCount);
3473
3474     user_assert(StartRegister                  < NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
3475     user_assert(StartRegister + Vector4iCount <= NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
3476     user_assert(pConstantData, D3DERR_INVALIDCALL);
3477
3478     if (This->driver_caps.ps_integer) {
3479         memcpy(&state->ps_const_i[StartRegister][0],
3480                pConstantData,
3481                Vector4iCount * sizeof(state->ps_const_i[0]));
3482     } else {
3483         for (i = 0; i < Vector4iCount; i++) {
3484             state->ps_const_i[StartRegister+i][0] = fui((float)(pConstantData[4*i]));
3485             state->ps_const_i[StartRegister+i][1] = fui((float)(pConstantData[4*i+1]));
3486             state->ps_const_i[StartRegister+i][2] = fui((float)(pConstantData[4*i+2]));
3487             state->ps_const_i[StartRegister+i][3] = fui((float)(pConstantData[4*i+3]));
3488         }
3489     }
3490     state->changed.ps_const_i |= ((1 << Vector4iCount) - 1) << StartRegister;
3491     state->changed.group |= NINE_STATE_PS_CONST;
3492
3493     return D3D_OK;
3494 }
3495
3496 HRESULT WINAPI
3497 NineDevice9_GetPixelShaderConstantI( struct NineDevice9 *This,
3498                                      UINT StartRegister,
3499                                      int *pConstantData,
3500                                      UINT Vector4iCount )
3501 {
3502     const struct nine_state *state = &This->state;
3503     int i;
3504
3505     user_assert(StartRegister                  < NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
3506     user_assert(StartRegister + Vector4iCount <= NINE_MAX_CONST_I, D3DERR_INVALIDCALL);
3507     user_assert(pConstantData, D3DERR_INVALIDCALL);
3508
3509     if (This->driver_caps.ps_integer) {
3510         memcpy(pConstantData,
3511                &state->ps_const_i[StartRegister][0],
3512                Vector4iCount * sizeof(state->ps_const_i[0]));
3513     } else {
3514         for (i = 0; i < Vector4iCount; i++) {
3515             pConstantData[4*i] = (int32_t) uif(state->ps_const_i[StartRegister+i][0]);
3516             pConstantData[4*i+1] = (int32_t) uif(state->ps_const_i[StartRegister+i][1]);
3517             pConstantData[4*i+2] = (int32_t) uif(state->ps_const_i[StartRegister+i][2]);
3518             pConstantData[4*i+3] = (int32_t) uif(state->ps_const_i[StartRegister+i][3]);
3519         }
3520     }
3521
3522     return D3D_OK;
3523 }
3524
3525 HRESULT WINAPI
3526 NineDevice9_SetPixelShaderConstantB( struct NineDevice9 *This,
3527                                      UINT StartRegister,
3528                                      const BOOL *pConstantData,
3529                                      UINT BoolCount )
3530 {
3531     struct nine_state *state = This->update;
3532     int i;
3533     uint32_t bool_true = This->driver_caps.ps_integer ? 0xFFFFFFFF : fui(1.0f);
3534
3535     DBG("This=%p StartRegister=%u pConstantData=%p BoolCount=%u\n",
3536         This, StartRegister, pConstantData, BoolCount);
3537
3538     user_assert(StartRegister              < NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
3539     user_assert(StartRegister + BoolCount <= NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
3540     user_assert(pConstantData, D3DERR_INVALIDCALL);
3541
3542     for (i = 0; i < BoolCount; i++)
3543         state->ps_const_b[StartRegister + i] = pConstantData[i] ? bool_true : 0;
3544
3545     state->changed.ps_const_b |= ((1 << BoolCount) - 1) << StartRegister;
3546     state->changed.group |= NINE_STATE_PS_CONST;
3547
3548     return D3D_OK;
3549 }
3550
3551 HRESULT WINAPI
3552 NineDevice9_GetPixelShaderConstantB( struct NineDevice9 *This,
3553                                      UINT StartRegister,
3554                                      BOOL *pConstantData,
3555                                      UINT BoolCount )
3556 {
3557     const struct nine_state *state = &This->state;
3558     int i;
3559
3560     user_assert(StartRegister              < NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
3561     user_assert(StartRegister + BoolCount <= NINE_MAX_CONST_B, D3DERR_INVALIDCALL);
3562     user_assert(pConstantData, D3DERR_INVALIDCALL);
3563
3564     for (i = 0; i < BoolCount; i++)
3565         pConstantData[i] = state->ps_const_b[StartRegister + i] ? TRUE : FALSE;
3566
3567     return D3D_OK;
3568 }
3569
3570 HRESULT WINAPI
3571 NineDevice9_DrawRectPatch( struct NineDevice9 *This,
3572                            UINT Handle,
3573                            const float *pNumSegs,
3574                            const D3DRECTPATCH_INFO *pRectPatchInfo )
3575 {
3576     STUB(D3DERR_INVALIDCALL);
3577 }
3578
3579 HRESULT WINAPI
3580 NineDevice9_DrawTriPatch( struct NineDevice9 *This,
3581                           UINT Handle,
3582                           const float *pNumSegs,
3583                           const D3DTRIPATCH_INFO *pTriPatchInfo )
3584 {
3585     STUB(D3DERR_INVALIDCALL);
3586 }
3587
3588 HRESULT WINAPI
3589 NineDevice9_DeletePatch( struct NineDevice9 *This,
3590                          UINT Handle )
3591 {
3592     STUB(D3DERR_INVALIDCALL);
3593 }
3594
3595 HRESULT WINAPI
3596 NineDevice9_CreateQuery( struct NineDevice9 *This,
3597                          D3DQUERYTYPE Type,
3598                          IDirect3DQuery9 **ppQuery )
3599 {
3600     struct NineQuery9 *query;
3601     HRESULT hr;
3602
3603     DBG("This=%p Type=%d ppQuery=%p\n", This, Type, ppQuery);
3604
3605     hr = nine_is_query_supported(This->screen, Type);
3606     if (!ppQuery || hr != D3D_OK)
3607         return hr;
3608
3609     hr = NineQuery9_new(This, &query, Type);
3610     if (FAILED(hr))
3611         return hr;
3612     *ppQuery = (IDirect3DQuery9 *)query;
3613     return D3D_OK;
3614 }
3615
3616 IDirect3DDevice9Vtbl NineDevice9_vtable = {
3617     (void *)NineUnknown_QueryInterface,
3618     (void *)NineUnknown_AddRef,
3619     (void *)NineUnknown_Release,
3620     (void *)NineDevice9_TestCooperativeLevel,
3621     (void *)NineDevice9_GetAvailableTextureMem,
3622     (void *)NineDevice9_EvictManagedResources,
3623     (void *)NineDevice9_GetDirect3D,
3624     (void *)NineDevice9_GetDeviceCaps,
3625     (void *)NineDevice9_GetDisplayMode,
3626     (void *)NineDevice9_GetCreationParameters,
3627     (void *)NineDevice9_SetCursorProperties,
3628     (void *)NineDevice9_SetCursorPosition,
3629     (void *)NineDevice9_ShowCursor,
3630     (void *)NineDevice9_CreateAdditionalSwapChain,
3631     (void *)NineDevice9_GetSwapChain,
3632     (void *)NineDevice9_GetNumberOfSwapChains,
3633     (void *)NineDevice9_Reset,
3634     (void *)NineDevice9_Present,
3635     (void *)NineDevice9_GetBackBuffer,
3636     (void *)NineDevice9_GetRasterStatus,
3637     (void *)NineDevice9_SetDialogBoxMode,
3638     (void *)NineDevice9_SetGammaRamp,
3639     (void *)NineDevice9_GetGammaRamp,
3640     (void *)NineDevice9_CreateTexture,
3641     (void *)NineDevice9_CreateVolumeTexture,
3642     (void *)NineDevice9_CreateCubeTexture,
3643     (void *)NineDevice9_CreateVertexBuffer,
3644     (void *)NineDevice9_CreateIndexBuffer,
3645     (void *)NineDevice9_CreateRenderTarget,
3646     (void *)NineDevice9_CreateDepthStencilSurface,
3647     (void *)NineDevice9_UpdateSurface,
3648     (void *)NineDevice9_UpdateTexture,
3649     (void *)NineDevice9_GetRenderTargetData,
3650     (void *)NineDevice9_GetFrontBufferData,
3651     (void *)NineDevice9_StretchRect,
3652     (void *)NineDevice9_ColorFill,
3653     (void *)NineDevice9_CreateOffscreenPlainSurface,
3654     (void *)NineDevice9_SetRenderTarget,
3655     (void *)NineDevice9_GetRenderTarget,
3656     (void *)NineDevice9_SetDepthStencilSurface,
3657     (void *)NineDevice9_GetDepthStencilSurface,
3658     (void *)NineDevice9_BeginScene,
3659     (void *)NineDevice9_EndScene,
3660     (void *)NineDevice9_Clear,
3661     (void *)NineDevice9_SetTransform,
3662     (void *)NineDevice9_GetTransform,
3663     (void *)NineDevice9_MultiplyTransform,
3664     (void *)NineDevice9_SetViewport,
3665     (void *)NineDevice9_GetViewport,
3666     (void *)NineDevice9_SetMaterial,
3667     (void *)NineDevice9_GetMaterial,
3668     (void *)NineDevice9_SetLight,
3669     (void *)NineDevice9_GetLight,
3670     (void *)NineDevice9_LightEnable,
3671     (void *)NineDevice9_GetLightEnable,
3672     (void *)NineDevice9_SetClipPlane,
3673     (void *)NineDevice9_GetClipPlane,
3674     (void *)NineDevice9_SetRenderState,
3675     (void *)NineDevice9_GetRenderState,
3676     (void *)NineDevice9_CreateStateBlock,
3677     (void *)NineDevice9_BeginStateBlock,
3678     (void *)NineDevice9_EndStateBlock,
3679     (void *)NineDevice9_SetClipStatus,
3680     (void *)NineDevice9_GetClipStatus,
3681     (void *)NineDevice9_GetTexture,
3682     (void *)NineDevice9_SetTexture,
3683     (void *)NineDevice9_GetTextureStageState,
3684     (void *)NineDevice9_SetTextureStageState,
3685     (void *)NineDevice9_GetSamplerState,
3686     (void *)NineDevice9_SetSamplerState,
3687     (void *)NineDevice9_ValidateDevice,
3688     (void *)NineDevice9_SetPaletteEntries,
3689     (void *)NineDevice9_GetPaletteEntries,
3690     (void *)NineDevice9_SetCurrentTexturePalette,
3691     (void *)NineDevice9_GetCurrentTexturePalette,
3692     (void *)NineDevice9_SetScissorRect,
3693     (void *)NineDevice9_GetScissorRect,
3694     (void *)NineDevice9_SetSoftwareVertexProcessing,
3695     (void *)NineDevice9_GetSoftwareVertexProcessing,
3696     (void *)NineDevice9_SetNPatchMode,
3697     (void *)NineDevice9_GetNPatchMode,
3698     (void *)NineDevice9_DrawPrimitive,
3699     (void *)NineDevice9_DrawIndexedPrimitive,
3700     (void *)NineDevice9_DrawPrimitiveUP,
3701     (void *)NineDevice9_DrawIndexedPrimitiveUP,
3702     (void *)NineDevice9_ProcessVertices,
3703     (void *)NineDevice9_CreateVertexDeclaration,
3704     (void *)NineDevice9_SetVertexDeclaration,
3705     (void *)NineDevice9_GetVertexDeclaration,
3706     (void *)NineDevice9_SetFVF,
3707     (void *)NineDevice9_GetFVF,
3708     (void *)NineDevice9_CreateVertexShader,
3709     (void *)NineDevice9_SetVertexShader,
3710     (void *)NineDevice9_GetVertexShader,
3711     (void *)NineDevice9_SetVertexShaderConstantF,
3712     (void *)NineDevice9_GetVertexShaderConstantF,
3713     (void *)NineDevice9_SetVertexShaderConstantI,
3714     (void *)NineDevice9_GetVertexShaderConstantI,
3715     (void *)NineDevice9_SetVertexShaderConstantB,
3716     (void *)NineDevice9_GetVertexShaderConstantB,
3717     (void *)NineDevice9_SetStreamSource,
3718     (void *)NineDevice9_GetStreamSource,
3719     (void *)NineDevice9_SetStreamSourceFreq,
3720     (void *)NineDevice9_GetStreamSourceFreq,
3721     (void *)NineDevice9_SetIndices,
3722     (void *)NineDevice9_GetIndices,
3723     (void *)NineDevice9_CreatePixelShader,
3724     (void *)NineDevice9_SetPixelShader,
3725     (void *)NineDevice9_GetPixelShader,
3726     (void *)NineDevice9_SetPixelShaderConstantF,
3727     (void *)NineDevice9_GetPixelShaderConstantF,
3728     (void *)NineDevice9_SetPixelShaderConstantI,
3729     (void *)NineDevice9_GetPixelShaderConstantI,
3730     (void *)NineDevice9_SetPixelShaderConstantB,
3731     (void *)NineDevice9_GetPixelShaderConstantB,
3732     (void *)NineDevice9_DrawRectPatch,
3733     (void *)NineDevice9_DrawTriPatch,
3734     (void *)NineDevice9_DeletePatch,
3735     (void *)NineDevice9_CreateQuery
3736 };
3737
3738 static const GUID *NineDevice9_IIDs[] = {
3739     &IID_IDirect3DDevice9,
3740     &IID_IUnknown,
3741     NULL
3742 };
3743
3744 HRESULT
3745 NineDevice9_new( struct pipe_screen *pScreen,
3746                  D3DDEVICE_CREATION_PARAMETERS *pCreationParameters,
3747                  D3DCAPS9 *pCaps,
3748                  D3DPRESENT_PARAMETERS *pPresentationParameters,
3749                  IDirect3D9 *pD3D9,
3750                  ID3DPresentGroup *pPresentationGroup,
3751                  struct d3dadapter9_context *pCTX,
3752                  boolean ex,
3753                  D3DDISPLAYMODEEX *pFullscreenDisplayMode,
3754                  struct NineDevice9 **ppOut )
3755 {
3756     BOOL lock;
3757     lock = !!(pCreationParameters->BehaviorFlags & D3DCREATE_MULTITHREADED);
3758
3759     NINE_NEW(Device9, ppOut, lock, /* args */
3760              pScreen, pCreationParameters, pCaps,
3761              pPresentationParameters, pD3D9, pPresentationGroup, pCTX,
3762              ex, pFullscreenDisplayMode);
3763 }