dlls/d3dx9_36/render.c

   1 /*
   2  * Copyright (C) 2012 Józef Kucia
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20
  21 #include "d3dx9_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  24
  25 struct device_state
  26 {
  27     DWORD num_render_targets;
  28     IDirect3DSurface9 **render_targets;
  29     IDirect3DSurface9 *depth_stencil;
  30     D3DVIEWPORT9 viewport;
  31 };
  32
  33 static HRESULT device_state_init(IDirect3DDevice9 *device, struct device_state *state)
  34 {
  35     HRESULT hr;
  36     D3DCAPS9 caps;
  37     unsigned int i;
  38
  39     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
  40     if (FAILED(hr)) return hr;
  41
  42     state->num_render_targets = caps.NumSimultaneousRTs;
  43     state->render_targets = HeapAlloc(GetProcessHeap(), 0,
  44         state->num_render_targets * sizeof(IDirect3DSurface9 *));
  45     if (!state->render_targets)
  46         return E_OUTOFMEMORY;
  47
  48     for (i = 0; i < state->num_render_targets; i++)
  49         state->render_targets[i] = NULL;
  50     state->depth_stencil = NULL;
  51     return D3D_OK;
  52 }
  53
  54 static void device_state_capture(IDirect3DDevice9 *device, struct device_state *state)
  55 {
  56     HRESULT hr;
  57     unsigned int i;
  58
  59     IDirect3DDevice9_GetViewport(device, &state->viewport);
  60
  61     for (i = 0; i < state->num_render_targets; i++)
  62     {
  63         hr = IDirect3DDevice9_GetRenderTarget(device, i, &state->render_targets[i]);
  64         if (FAILED(hr)) state->render_targets[i] = NULL;
  65     }
  66
  67     hr = IDirect3DDevice9_GetDepthStencilSurface(device, &state->depth_stencil);
  68     if (FAILED(hr)) state->depth_stencil = NULL;
  69 }
  70
  71 static void device_state_restore(IDirect3DDevice9 *device, struct device_state *state)
  72 {
  73     unsigned int i;
  74
  75     for (i = 0; i < state->num_render_targets; i++)
  76     {
  77         IDirect3DDevice9_SetRenderTarget(device, i, state->render_targets[i]);
  78         if (state->render_targets[i])
  79             IDirect3DSurface9_Release(state->render_targets[i]);
  80         state->render_targets[i] = NULL;
  81     }
  82
  83     IDirect3DDevice9_SetDepthStencilSurface(device, state->depth_stencil);
  84     if (state->depth_stencil)
  85     {
  86         IDirect3DSurface9_Release(state->depth_stencil);
  87         state->depth_stencil = NULL;
  88     }
  89
  90     IDirect3DDevice9_SetViewport(device, &state->viewport);
  91 }
  92
  93 static void device_state_release(struct device_state *state)
  94 {
  95     unsigned int i;
  96
  97     for (i = 0; i < state->num_render_targets; i++)
  98     {
  99         if (state->render_targets[i])
 100             IDirect3DSurface9_Release(state->render_targets[i]);
 101     }
 102
 103     HeapFree(GetProcessHeap(), 0, state->render_targets);
 104
 105     if (state->depth_stencil) IDirect3DSurface9_Release(state->depth_stencil);
 106 }
 107
 108 struct render_to_surface
 109 {
 110     ID3DXRenderToSurface ID3DXRenderToSurface_iface;
 111     LONG ref;
 112
 113     IDirect3DDevice9 *device;
 114     D3DXRTS_DESC desc;
 115
 116     IDirect3DSurface9 *dst_surface;
 117
 118     IDirect3DSurface9 *render_target;
 119     IDirect3DSurface9 *depth_stencil;
 120
 121     struct device_state previous_state;
 122 };
 123
 124 static inline struct render_to_surface *impl_from_ID3DXRenderToSurface(ID3DXRenderToSurface *iface)
 125 {
 126     return CONTAINING_RECORD(iface, struct render_to_surface, ID3DXRenderToSurface_iface);
 127 }
 128
 129 static HRESULT WINAPI D3DXRenderToSurface_QueryInterface(ID3DXRenderToSurface *iface,
 130                                                          REFIID riid,
 131                                                          void **out)
 132 {
 133     TRACE("iface %p, riid %s, out %p\n", iface, debugstr_guid(riid), out);
 134
 135     if (IsEqualGUID(riid, &IID_ID3DXRenderToSurface)
 136             || IsEqualGUID(riid, &IID_IUnknown))
 137     {
 138         IUnknown_AddRef(iface);
 139         *out = iface;
 140         return S_OK;
 141     }
 142
 143     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 144
 145     *out = NULL;
 146     return E_NOINTERFACE;
 147 }
 148
 149 static ULONG WINAPI D3DXRenderToSurface_AddRef(ID3DXRenderToSurface *iface)
 150 {
 151     struct render_to_surface *render = impl_from_ID3DXRenderToSurface(iface);
 152     ULONG ref = InterlockedIncrement(&render->ref);
 153
 154     TRACE("%p increasing refcount to %lu.\n", iface, ref);
 155
 156     return ref;
 157 }
 158
 159 static ULONG WINAPI D3DXRenderToSurface_Release(ID3DXRenderToSurface *iface)
 160 {
 161     struct render_to_surface *render = impl_from_ID3DXRenderToSurface(iface);
 162     ULONG ref = InterlockedDecrement(&render->ref);
 163
 164     TRACE("%p decreasing refcount to %lu.\n", iface, ref);
 165
 166     if (!ref)
 167     {
 168         if (render->dst_surface) IDirect3DSurface9_Release(render->dst_surface);
 169
 170         if (render->render_target) IDirect3DSurface9_Release(render->render_target);
 171         if (render->depth_stencil) IDirect3DSurface9_Release(render->depth_stencil);
 172
 173         device_state_release(&render->previous_state);
 174
 175         IDirect3DDevice9_Release(render->device);
 176
 177         HeapFree(GetProcessHeap(), 0, render);
 178     }
 179
 180     return ref;
 181 }
 182
 183 static HRESULT WINAPI D3DXRenderToSurface_GetDevice(ID3DXRenderToSurface *iface,
 184                                                     IDirect3DDevice9 **device)
 185 {
 186     struct render_to_surface *render = impl_from_ID3DXRenderToSurface(iface);
 187
 188     TRACE("iface %p, device %p.\n", iface, device);
 189
 190     if (!device) return D3DERR_INVALIDCALL;
 191
 192     IDirect3DDevice9_AddRef(render->device);
 193     *device = render->device;
 194     return D3D_OK;
 195 }
 196
 197 static HRESULT WINAPI D3DXRenderToSurface_GetDesc(ID3DXRenderToSurface *iface,
 198                                                   D3DXRTS_DESC *desc)
 199 {
 200     struct render_to_surface *render = impl_from_ID3DXRenderToSurface(iface);
 201
 202     TRACE("iface %p, desc %p.\n", iface, desc);
 203
 204     if (!desc) return D3DERR_INVALIDCALL;
 205
 206     *desc = render->desc;
 207     return D3D_OK;
 208 }
 209
 210 static HRESULT WINAPI D3DXRenderToSurface_BeginScene(ID3DXRenderToSurface *iface,
 211                                                      IDirect3DSurface9 *surface,
 212                                                      const D3DVIEWPORT9 *viewport)
 213 {
 214     struct render_to_surface *render = impl_from_ID3DXRenderToSurface(iface);
 215     unsigned int i;
 216     IDirect3DDevice9 *device;
 217     D3DSURFACE_DESC surface_desc;
 218     HRESULT hr = D3DERR_INVALIDCALL;
 219     D3DMULTISAMPLE_TYPE multi_sample_type = D3DMULTISAMPLE_NONE;
 220     DWORD multi_sample_quality = 0;
 221
 222     TRACE("iface %p, surface %p, viewport %p.\n", iface, surface, viewport);
 223
 224     if (!surface || render->dst_surface) return D3DERR_INVALIDCALL;
 225
 226     IDirect3DSurface9_GetDesc(surface, &surface_desc);
 227     if (surface_desc.Format != render->desc.Format
 228             || surface_desc.Width != render->desc.Width
 229             || surface_desc.Height != render->desc.Height)
 230         return D3DERR_INVALIDCALL;
 231
 232     if (viewport)
 233     {
 234         if (viewport->X > render->desc.Width || viewport->Y > render->desc.Height
 235                 || viewport->X + viewport->Width > render->desc.Width
 236                 || viewport->Y + viewport->Height > render->desc.Height)
 237             return D3DERR_INVALIDCALL;
 238
 239         if (!(surface_desc.Usage & D3DUSAGE_RENDERTARGET)
 240                 && (viewport->X != 0 || viewport->Y != 0
 241                 || viewport->Width != render->desc.Width
 242                 || viewport->Height != render->desc.Height))
 243             return D3DERR_INVALIDCALL;
 244     }
 245
 246     device = render->device;
 247
 248     device_state_capture(device, &render->previous_state);
 249
 250     /* prepare for rendering to surface */
 251     for (i = 1; i < render->previous_state.num_render_targets; i++)
 252         IDirect3DDevice9_SetRenderTarget(device, i, NULL);
 253
 254     if (surface_desc.Usage & D3DUSAGE_RENDERTARGET)
 255     {
 256         hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
 257         multi_sample_type = surface_desc.MultiSampleType;
 258         multi_sample_quality = surface_desc.MultiSampleQuality;
 259     }
 260     else
 261     {
 262         hr = IDirect3DDevice9_CreateRenderTarget(device, render->desc.Width, render->desc.Height,
 263                 render->desc.Format, multi_sample_type, multi_sample_quality, FALSE,
 264                 &render->render_target, NULL);
 265         if (FAILED(hr)) goto cleanup;
 266         hr = IDirect3DDevice9_SetRenderTarget(device, 0, render->render_target);
 267     }
 268
 269     if (FAILED(hr)) goto cleanup;
 270
 271     if (render->desc.DepthStencil)
 272     {
 273         hr = IDirect3DDevice9_CreateDepthStencilSurface(device, render->desc.Width, render->desc.Height,
 274                 render->desc.DepthStencilFormat, multi_sample_type, multi_sample_quality, TRUE,
 275                 &render->depth_stencil, NULL);
 276     }
 277     else render->depth_stencil = NULL;
 278
 279     if (FAILED(hr)) goto cleanup;
 280
 281     hr = IDirect3DDevice9_SetDepthStencilSurface(device, render->depth_stencil);
 282     if (FAILED(hr)) goto cleanup;
 283
 284     if (viewport) IDirect3DDevice9_SetViewport(device, viewport);
 285
 286     IDirect3DSurface9_AddRef(surface);
 287     render->dst_surface = surface;
 288     return IDirect3DDevice9_BeginScene(device);
 289
 290 cleanup:
 291     device_state_restore(device, &render->previous_state);
 292
 293     if (render->dst_surface) IDirect3DSurface9_Release(render->dst_surface);
 294     render->dst_surface = NULL;
 295
 296     if (render->render_target) IDirect3DSurface9_Release(render->render_target);
 297     render->render_target = NULL;
 298     if (render->depth_stencil) IDirect3DSurface9_Release(render->depth_stencil);
 299     render->depth_stencil = NULL;
 300
 301     return hr;
 302 }
 303
 304 static HRESULT WINAPI D3DXRenderToSurface_EndScene(ID3DXRenderToSurface *iface,
 305                                                    DWORD filter)
 306 {
 307     struct render_to_surface *render = impl_from_ID3DXRenderToSurface(iface);
 308     HRESULT hr;
 309
 310     TRACE("iface %p, filter %#lx.\n", iface, filter);
 311
 312     if (!render->dst_surface) return D3DERR_INVALIDCALL;
 313
 314     hr = IDirect3DDevice9_EndScene(render->device);
 315
 316     /* copy render target data to destination surface, if needed */
 317     if (render->render_target)
 318     {
 319         hr = D3DXLoadSurfaceFromSurface(render->dst_surface, NULL, NULL,
 320                 render->render_target, NULL, NULL, filter, 0);
 321         if (FAILED(hr))
 322             ERR("Copying render target data to surface failed, hr %#lx.\n", hr);
 323     }
 324
 325     device_state_restore(render->device, &render->previous_state);
 326
 327     /* release resources */
 328     if (render->render_target)
 329     {
 330         IDirect3DSurface9_Release(render->render_target);
 331         render->render_target = NULL;
 332     }
 333
 334     if (render->depth_stencil)
 335     {
 336         IDirect3DSurface9_Release(render->depth_stencil);
 337         render->depth_stencil = NULL;
 338     }
 339
 340     IDirect3DSurface9_Release(render->dst_surface);
 341     render->dst_surface = NULL;
 342
 343     return hr;
 344 }
 345
 346 static HRESULT WINAPI D3DXRenderToSurface_OnLostDevice(ID3DXRenderToSurface *iface)
 347 {
 348     FIXME("iface %p stub!\n", iface);
 349     return D3D_OK;
 350 }
 351
 352 static HRESULT WINAPI D3DXRenderToSurface_OnResetDevice(ID3DXRenderToSurface *iface)
 353 {
 354     FIXME("iface %p stub!\n", iface);
 355     return D3D_OK;
 356 }
 357
 358 static const ID3DXRenderToSurfaceVtbl render_to_surface_vtbl =
 359 {
 360     /* IUnknown methods */
 361     D3DXRenderToSurface_QueryInterface,
 362     D3DXRenderToSurface_AddRef,
 363     D3DXRenderToSurface_Release,
 364     /* ID3DXRenderToSurface methods */
 365     D3DXRenderToSurface_GetDevice,
 366     D3DXRenderToSurface_GetDesc,
 367     D3DXRenderToSurface_BeginScene,
 368     D3DXRenderToSurface_EndScene,
 369     D3DXRenderToSurface_OnLostDevice,
 370     D3DXRenderToSurface_OnResetDevice
 371 };
 372
 373 HRESULT WINAPI D3DXCreateRenderToSurface(IDirect3DDevice9 *device,
 374                                          UINT width,
 375                                          UINT height,
 376                                          D3DFORMAT format,
 377                                          BOOL depth_stencil,
 378                                          D3DFORMAT depth_stencil_format,
 379                                          ID3DXRenderToSurface **out)
 380 {
 381     HRESULT hr;
 382     struct render_to_surface *render;
 383
 384     TRACE("device %p, width %u, height %u, format %#x, depth_stencil %#x, depth_stencil_format %#x, out %p.\n",
 385             device, width, height, format, depth_stencil, depth_stencil_format, out);
 386
 387     if (!device || !out) return D3DERR_INVALIDCALL;
 388
 389     render = HeapAlloc(GetProcessHeap(), 0, sizeof(struct render_to_surface));
 390     if (!render) return E_OUTOFMEMORY;
 391
 392     render->ID3DXRenderToSurface_iface.lpVtbl = &render_to_surface_vtbl;
 393     render->ref = 1;
 394
 395     render->desc.Width = width;
 396     render->desc.Height = height;
 397     render->desc.Format = format;
 398     render->desc.DepthStencil = depth_stencil;
 399     render->desc.DepthStencilFormat = depth_stencil_format;
 400
 401     render->dst_surface = NULL;
 402     render->render_target = NULL;
 403     render->depth_stencil = NULL;
 404
 405     hr = device_state_init(device, &render->previous_state);
 406     if (FAILED(hr))
 407     {
 408         HeapFree(GetProcessHeap(), 0, render);
 409         return hr;
 410     }
 411
 412     IDirect3DDevice9_AddRef(device);
 413     render->device = device;
 414
 415     *out = &render->ID3DXRenderToSurface_iface;
 416     return D3D_OK;
 417 }
 418
 419
 420 enum render_state
 421 {
 422     INITIAL,
 423
 424     CUBE_BEGIN,
 425     CUBE_FACE
 426 };
 427
 428 struct render_to_envmap
 429 {
 430     ID3DXRenderToEnvMap ID3DXRenderToEnvMap_iface;
 431     LONG ref;
 432
 433     IDirect3DDevice9 *device;
 434     D3DXRTE_DESC desc;
 435
 436     enum render_state state;
 437     struct device_state previous_device_state;
 438
 439     D3DCUBEMAP_FACES face;
 440     DWORD filter;
 441
 442     IDirect3DSurface9 *render_target;
 443     IDirect3DSurface9 *depth_stencil;
 444
 445     IDirect3DCubeTexture9 *dst_cube_texture;
 446 };
 447
 448 static void copy_render_target_to_cube_texture_face(IDirect3DCubeTexture9 *cube_texture,
 449         D3DCUBEMAP_FACES face, IDirect3DSurface9 *render_target, DWORD filter)
 450 {
 451     HRESULT hr;
 452     IDirect3DSurface9 *cube_surface;
 453
 454     IDirect3DCubeTexture9_GetCubeMapSurface(cube_texture, face, 0, &cube_surface);
 455
 456     hr = D3DXLoadSurfaceFromSurface(cube_surface, NULL, NULL, render_target, NULL, NULL, filter, 0);
 457     if (FAILED(hr))
 458         ERR("Copying render target data to surface failed, hr %#lx.\n", hr);
 459
 460     IDirect3DSurface9_Release(cube_surface);
 461 }
 462
 463 static inline struct render_to_envmap *impl_from_ID3DXRenderToEnvMap(ID3DXRenderToEnvMap *iface)
 464 {
 465     return CONTAINING_RECORD(iface, struct render_to_envmap, ID3DXRenderToEnvMap_iface);
 466 }
 467
 468 static HRESULT WINAPI D3DXRenderToEnvMap_QueryInterface(ID3DXRenderToEnvMap *iface,
 469                                                         REFIID riid,
 470                                                         void **out)
 471 {
 472     TRACE("iface %p, riid %s, out %p\n", iface, debugstr_guid(riid), out);
 473
 474     if (IsEqualGUID(riid, &IID_ID3DXRenderToEnvMap)
 475             || IsEqualGUID(riid, &IID_IUnknown))
 476     {
 477         IUnknown_AddRef(iface);
 478         *out = iface;
 479         return S_OK;
 480     }
 481
 482     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 483
 484     *out = NULL;
 485     return E_NOINTERFACE;
 486 }
 487
 488 static ULONG WINAPI D3DXRenderToEnvMap_AddRef(ID3DXRenderToEnvMap *iface)
 489 {
 490     struct render_to_envmap *render = impl_from_ID3DXRenderToEnvMap(iface);
 491     ULONG ref = InterlockedIncrement(&render->ref);
 492
 493     TRACE("%p increasing refcount to %lu.\n", iface, ref);
 494
 495     return ref;
 496 }
 497
 498 static ULONG WINAPI D3DXRenderToEnvMap_Release(ID3DXRenderToEnvMap *iface)
 499 {
 500     struct render_to_envmap *render = impl_from_ID3DXRenderToEnvMap(iface);
 501     ULONG ref = InterlockedDecrement(&render->ref);
 502
 503     TRACE("%p decreasing refcount to %lu.\n", iface, ref);
 504
 505     if (!ref)
 506     {
 507         if (render->dst_cube_texture) IDirect3DSurface9_Release(render->dst_cube_texture);
 508
 509         if (render->render_target) IDirect3DSurface9_Release(render->render_target);
 510         if (render->depth_stencil) IDirect3DSurface9_Release(render->depth_stencil);
 511
 512         device_state_release(&render->previous_device_state);
 513
 514         IDirect3DDevice9_Release(render->device);
 515
 516         HeapFree(GetProcessHeap(), 0, render);
 517     }
 518
 519     return ref;
 520 }
 521
 522 static HRESULT WINAPI D3DXRenderToEnvMap_GetDevice(ID3DXRenderToEnvMap *iface,
 523                                                    IDirect3DDevice9 **device)
 524 {
 525     struct render_to_envmap *render = impl_from_ID3DXRenderToEnvMap(iface);
 526
 527     TRACE("iface %p, device %p.\n", iface, device);
 528
 529     if (!device) return D3DERR_INVALIDCALL;
 530
 531     IDirect3DDevice9_AddRef(render->device);
 532     *device = render->device;
 533     return D3D_OK;
 534 }
 535
 536 static HRESULT WINAPI D3DXRenderToEnvMap_GetDesc(ID3DXRenderToEnvMap *iface,
 537                                                  D3DXRTE_DESC *desc)
 538 {
 539     struct render_to_envmap *render = impl_from_ID3DXRenderToEnvMap(iface);
 540
 541     TRACE("iface %p, desc %p.\n", iface, desc);
 542
 543     if (!desc) return D3DERR_INVALIDCALL;
 544
 545     *desc = render->desc;
 546     return D3D_OK;
 547 }
 548
 549 static HRESULT WINAPI D3DXRenderToEnvMap_BeginCube(ID3DXRenderToEnvMap *iface,
 550                                                    IDirect3DCubeTexture9 *texture)
 551 {
 552     struct render_to_envmap *render = impl_from_ID3DXRenderToEnvMap(iface);
 553     HRESULT hr;
 554     D3DSURFACE_DESC level_desc;
 555
 556     TRACE("iface %p, texture %p.\n", iface, texture);
 557
 558     if (!texture) return D3DERR_INVALIDCALL;
 559
 560     if (render->state != INITIAL) return D3DERR_INVALIDCALL;
 561
 562     IDirect3DCubeTexture9_GetLevelDesc(texture, 0, &level_desc);
 563     if (level_desc.Format != render->desc.Format || level_desc.Width != render->desc.Size)
 564         return D3DERR_INVALIDCALL;
 565
 566     if (!(level_desc.Usage & D3DUSAGE_RENDERTARGET))
 567     {
 568         hr = IDirect3DDevice9_CreateRenderTarget(render->device, level_desc.Width, level_desc.Height,
 569                 level_desc.Format, level_desc.MultiSampleType, level_desc.MultiSampleQuality,
 570                 TRUE, &render->render_target, NULL);
 571         if (FAILED(hr)) goto cleanup;
 572         IDirect3DCubeTexture9_GetLevelDesc(texture, 0, &level_desc);
 573     }
 574
 575     if (render->desc.DepthStencil)
 576     {
 577         hr = IDirect3DDevice9_CreateDepthStencilSurface(render->device, level_desc.Width, level_desc.Height,
 578                 render->desc.DepthStencilFormat, level_desc.MultiSampleType, level_desc.MultiSampleQuality,
 579                 TRUE, &render->depth_stencil, NULL);
 580         if (FAILED(hr)) goto cleanup;
 581     }
 582
 583     IDirect3DCubeTexture9_AddRef(texture);
 584     render->dst_cube_texture = texture;
 585     render->state = CUBE_BEGIN;
 586     return D3D_OK;
 587
 588 cleanup:
 589     if (render->dst_cube_texture) IDirect3DSurface9_Release(render->dst_cube_texture);
 590     render->dst_cube_texture = NULL;
 591
 592     if (render->render_target) IDirect3DSurface9_Release(render->render_target);
 593     render->render_target = NULL;
 594     if (render->depth_stencil) IDirect3DSurface9_Release(render->depth_stencil);
 595     render->depth_stencil = NULL;
 596
 597     return hr;
 598 }
 599
 600 static HRESULT WINAPI D3DXRenderToEnvMap_BeginSphere(ID3DXRenderToEnvMap *iface,
 601                                                      IDirect3DTexture9 *texture)
 602 {
 603     FIXME("iface %p, texture %p stub!\n", iface, texture);
 604     return E_NOTIMPL;
 605 }
 606
 607 static HRESULT WINAPI D3DXRenderToEnvMap_BeginHemisphere(ID3DXRenderToEnvMap *iface,
 608                                                          IDirect3DTexture9 *pos_z_texture,
 609                                                          IDirect3DTexture9 *neg_z_texture)
 610 {
 611     FIXME("iface %p, pos_z_texture %p, neg_z_texture %p stub!\n", iface, pos_z_texture, neg_z_texture);
 612     return E_NOTIMPL;
 613 }
 614
 615 static HRESULT WINAPI D3DXRenderToEnvMap_BeginParabolic(ID3DXRenderToEnvMap *iface,
 616                                                         IDirect3DTexture9 *pos_z_texture,
 617                                                         IDirect3DTexture9 *neg_z_texture)
 618 {
 619     FIXME("iface %p, pos_z_texture %p, neg_z_texture %p stub!\n", iface, pos_z_texture, neg_z_texture);
 620     return E_NOTIMPL;
 621 }
 622
 623 static HRESULT WINAPI D3DXRenderToEnvMap_Face(ID3DXRenderToEnvMap *iface,
 624                                               D3DCUBEMAP_FACES face,
 625                                               DWORD filter)
 626 {
 627     struct render_to_envmap *render = impl_from_ID3DXRenderToEnvMap(iface);
 628     HRESULT hr;
 629     unsigned int i;
 630
 631     TRACE("iface %p, face %u, filter %#lx.\n", iface, face, filter);
 632
 633     if (render->state == CUBE_FACE)
 634     {
 635         IDirect3DDevice9_EndScene(render->device);
 636         if (render->render_target)
 637             copy_render_target_to_cube_texture_face(render->dst_cube_texture, render->face,
 638                     render->render_target, render->filter);
 639
 640         device_state_restore(render->device, &render->previous_device_state);
 641
 642         render->state = CUBE_BEGIN;
 643     }
 644     else if (render->state != CUBE_BEGIN)
 645         return D3DERR_INVALIDCALL;
 646
 647     device_state_capture(render->device, &render->previous_device_state);
 648
 649     for (i = 1; i < render->previous_device_state.num_render_targets; i++)
 650         IDirect3DDevice9_SetRenderTarget(render->device, i, NULL);
 651
 652     if (!render->render_target)
 653     {
 654         IDirect3DSurface9 *render_target;
 655         IDirect3DCubeTexture9_GetCubeMapSurface(render->dst_cube_texture, face, 0, &render_target);
 656         hr = IDirect3DDevice9_SetRenderTarget(render->device, 0, render_target);
 657         IDirect3DSurface9_Release(render_target);
 658     }
 659     else hr = IDirect3DDevice9_SetRenderTarget(render->device, 0, render->render_target);
 660
 661     if (FAILED(hr)) goto cleanup;
 662
 663     hr = IDirect3DDevice9_SetDepthStencilSurface(render->device, render->depth_stencil);
 664     if (FAILED(hr)) goto cleanup;
 665
 666     render->state = CUBE_FACE;
 667     render->face = face;
 668     render->filter = filter;
 669     return IDirect3DDevice9_BeginScene(render->device);
 670
 671 cleanup:
 672     device_state_restore(render->device, &render->previous_device_state);
 673     return hr;
 674 }
 675
 676 static HRESULT WINAPI D3DXRenderToEnvMap_End(ID3DXRenderToEnvMap *iface,
 677                                              DWORD filter)
 678 {
 679     struct render_to_envmap *render = impl_from_ID3DXRenderToEnvMap(iface);
 680
 681     TRACE("iface %p, filter %#lx.\n", iface, filter);
 682
 683     if (render->state == INITIAL) return D3DERR_INVALIDCALL;
 684
 685     if (render->state == CUBE_FACE)
 686     {
 687         IDirect3DDevice9_EndScene(render->device);
 688         if (render->render_target)
 689             copy_render_target_to_cube_texture_face(render->dst_cube_texture, render->face,
 690                     render->render_target, render->filter);
 691
 692         device_state_restore(render->device, &render->previous_device_state);
 693     }
 694
 695     D3DXFilterTexture((IDirect3DBaseTexture9 *)render->dst_cube_texture, NULL, 0, filter);
 696
 697     if (render->render_target)
 698     {
 699         IDirect3DSurface9_Release(render->render_target);
 700         render->render_target = NULL;
 701     }
 702
 703     if (render->depth_stencil)
 704     {
 705         IDirect3DSurface9_Release(render->depth_stencil);
 706         render->depth_stencil = NULL;
 707     }
 708
 709     IDirect3DSurface9_Release(render->dst_cube_texture);
 710     render->dst_cube_texture = NULL;
 711
 712     render->state = INITIAL;
 713     return D3D_OK;
 714 }
 715
 716 static HRESULT WINAPI D3DXRenderToEnvMap_OnLostDevice(ID3DXRenderToEnvMap *iface)
 717 {
 718     FIXME("iface %p stub!\n", iface);
 719     return D3D_OK;
 720 }
 721
 722 static HRESULT WINAPI D3DXRenderToEnvMap_OnResetDevice(ID3DXRenderToEnvMap *iface)
 723 {
 724     FIXME("iface %p stub!\n", iface);
 725     return D3D_OK;
 726 }
 727
 728 static const ID3DXRenderToEnvMapVtbl render_to_envmap_vtbl =
 729 {
 730     /* IUnknown methods */
 731     D3DXRenderToEnvMap_QueryInterface,
 732     D3DXRenderToEnvMap_AddRef,
 733     D3DXRenderToEnvMap_Release,
 734     /* ID3DXRenderToEnvMap methods */
 735     D3DXRenderToEnvMap_GetDevice,
 736     D3DXRenderToEnvMap_GetDesc,
 737     D3DXRenderToEnvMap_BeginCube,
 738     D3DXRenderToEnvMap_BeginSphere,
 739     D3DXRenderToEnvMap_BeginHemisphere,
 740     D3DXRenderToEnvMap_BeginParabolic,
 741     D3DXRenderToEnvMap_Face,
 742     D3DXRenderToEnvMap_End,
 743     D3DXRenderToEnvMap_OnLostDevice,
 744     D3DXRenderToEnvMap_OnResetDevice
 745 };
 746
 747 HRESULT WINAPI D3DXCreateRenderToEnvMap(IDirect3DDevice9 *device,
 748                                         UINT size,
 749                                         UINT mip_levels,
 750                                         D3DFORMAT format,
 751                                         BOOL depth_stencil,
 752                                         D3DFORMAT depth_stencil_format,
 753                                         ID3DXRenderToEnvMap **out)
 754 {
 755     HRESULT hr;
 756     struct render_to_envmap *render;
 757
 758     TRACE("(%p, %u, %u, %#x, %d, %#x, %p)\n", device, size, mip_levels,
 759             format, depth_stencil, depth_stencil_format, out);
 760
 761     if (!device || !out) return D3DERR_INVALIDCALL;
 762
 763     hr = D3DXCheckTextureRequirements(device, &size, &size, &mip_levels,
 764             D3DUSAGE_RENDERTARGET, &format, D3DPOOL_DEFAULT);
 765     if (FAILED(hr)) return hr;
 766
 767     render = HeapAlloc(GetProcessHeap(), 0, sizeof(struct render_to_envmap));
 768     if (!render) return E_OUTOFMEMORY;
 769
 770     render->ID3DXRenderToEnvMap_iface.lpVtbl = &render_to_envmap_vtbl;
 771     render->ref = 1;
 772
 773     render->desc.Size = size;
 774     render->desc.MipLevels = mip_levels;
 775     render->desc.Format = format;
 776     render->desc.DepthStencil = depth_stencil;
 777     render->desc.DepthStencilFormat = depth_stencil_format;
 778
 779     render->state = INITIAL;
 780     render->render_target = NULL;
 781     render->depth_stencil = NULL;
 782     render->dst_cube_texture = NULL;
 783
 784     hr = device_state_init(device, &render->previous_device_state);
 785     if (FAILED(hr))
 786     {
 787         HeapFree(GetProcessHeap(), 0, render);
 788         return hr;
 789     }
 790
 791     IDirect3DDevice9_AddRef(device);
 792     render->device = device;
 793
 794     *out = &render->ID3DXRenderToEnvMap_iface;
 795     return D3D_OK;
 796 }