dlls/ddraw/viewport.c

   1 /* Direct3D Viewport
   2  * Copyright (c) 1998 Lionel ULMER
   3  * Copyright (c) 2006-2007 Stefan DÖSINGER
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "ddraw_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  23
  24 /*****************************************************************************
  25  * Helper functions
  26  *****************************************************************************/
  27
  28 static void update_clip_space(struct d3d_device *device,
  29         struct wined3d_vec3 *scale, struct wined3d_vec3 *offset)
  30 {
  31     struct wined3d_matrix clip_space =
  32     {
  33         scale->x,  0.0f,      0.0f,      0.0f,
  34         0.0f,      scale->y,  0.0f,      0.0f,
  35         0.0f,      0.0f,      scale->z,  0.0f,
  36         offset->x, offset->y, offset->z, 1.0f,
  37     };
  38     struct wined3d_matrix projection;
  39
  40     multiply_matrix(&projection, &clip_space, &device->legacy_projection);
  41     wined3d_stateblock_set_transform(device->state, WINED3D_TS_PROJECTION, &projection);
  42     device->legacy_clipspace = clip_space;
  43 }
  44
  45 /*****************************************************************************
  46  * viewport_activate
  47  *
  48  * activates the viewport using IDirect3DDevice7::SetViewport
  49  *
  50  *****************************************************************************/
  51 void viewport_activate(struct d3d_viewport *This, BOOL ignore_lights)
  52 {
  53     struct wined3d_vec3 scale, offset;
  54     D3DVIEWPORT7 vp;
  55
  56     if (!ignore_lights)
  57     {
  58         struct d3d_light *light;
  59
  60         /* Activate all the lights associated with this context */
  61         LIST_FOR_EACH_ENTRY(light, &This->light_list, struct d3d_light, entry)
  62         {
  63             light_activate(light);
  64         }
  65     }
  66
  67     if (This->version == DDRAW_VIEWPORT_VERSION_NONE)
  68     {
  69         TRACE("Viewport data was not set.\n");
  70         return;
  71     }
  72
  73     /* And copy the values in the structure used by the device */
  74     if (This->version == DDRAW_VIEWPORT_VERSION_2)
  75     {
  76         vp.dwX = This->viewports.vp2.dwX;
  77         vp.dwY = This->viewports.vp2.dwY;
  78         vp.dwHeight = This->viewports.vp2.dwHeight;
  79         vp.dwWidth = This->viewports.vp2.dwWidth;
  80         vp.dvMinZ = 0.0f;
  81         vp.dvMaxZ = 1.0f;
  82
  83         scale.x = 2.0f / This->viewports.vp2.dvClipWidth;
  84         scale.y = 2.0f / This->viewports.vp2.dvClipHeight;
  85         scale.z = 1.0f / (This->viewports.vp2.dvMaxZ - This->viewports.vp2.dvMinZ);
  86         offset.x = -2.0f * This->viewports.vp2.dvClipX / This->viewports.vp2.dvClipWidth - 1.0f;
  87         offset.y = -2.0f * This->viewports.vp2.dvClipY / This->viewports.vp2.dvClipHeight + 1.0f;
  88         offset.z = -This->viewports.vp2.dvMinZ / (This->viewports.vp2.dvMaxZ - This->viewports.vp2.dvMinZ);
  89     }
  90     else
  91     {
  92         vp.dwX = This->viewports.vp1.dwX;
  93         vp.dwY = This->viewports.vp1.dwY;
  94         vp.dwHeight = This->viewports.vp1.dwHeight;
  95         vp.dwWidth = This->viewports.vp1.dwWidth;
  96         vp.dvMinZ = 0.0f;
  97         vp.dvMaxZ = 1.0f;
  98
  99         scale.x = 2.0f * This->viewports.vp1.dvScaleX / This->viewports.vp1.dwWidth;
 100         scale.y = 2.0f * This->viewports.vp1.dvScaleY / This->viewports.vp1.dwHeight;
 101         scale.z = 1.0f;
 102         offset.x = 0.0f;
 103         offset.y = 0.0f;
 104         offset.z = 0.0f;
 105     }
 106
 107     update_clip_space(This->active_device, &scale, &offset);
 108     IDirect3DDevice7_SetViewport(&This->active_device->IDirect3DDevice7_iface, &vp);
 109 }
 110
 111 void viewport_deactivate(struct d3d_viewport *viewport)
 112 {
 113     struct d3d_light *light;
 114
 115     LIST_FOR_EACH_ENTRY(light, &viewport->light_list, struct d3d_light, entry)
 116     {
 117         light_deactivate(light);
 118     }
 119 }
 120
 121 void viewport_alloc_active_light_index(struct d3d_light *light)
 122 {
 123     struct d3d_viewport *vp = light->active_viewport;
 124     unsigned int i;
 125     DWORD map;
 126
 127     TRACE("vp %p, light %p, index %u, active_lights_count %u.\n",
 128             vp, light, light->active_light_index, vp->active_lights_count);
 129
 130     if (light->active_light_index)
 131         return;
 132
 133     if (vp->active_lights_count >= DDRAW_MAX_ACTIVE_LIGHTS)
 134     {
 135         struct d3d_light *l;
 136
 137         LIST_FOR_EACH_ENTRY(l, &vp->light_list, struct d3d_light, entry)
 138         {
 139             if (l->active_light_index)
 140             {
 141                 WARN("Too many active lights, viewport %p, light %p, deactivating %p.\n", vp, light, l);
 142                 light_deactivate(l);
 143
 144                 /* Recycle active lights in a FIFO way. */
 145                 list_remove(&light->entry);
 146                 list_add_tail(&vp->light_list, &light->entry);
 147                 break;
 148             }
 149         }
 150     }
 151
 152     map = ~vp->map_lights;
 153     assert(vp->active_lights_count < DDRAW_MAX_ACTIVE_LIGHTS && map);
 154     i = wined3d_bit_scan(&map);
 155     light->active_light_index = i + 1;
 156     ++vp->active_lights_count;
 157     vp->map_lights |= 1u << i;
 158 }
 159
 160 void viewport_free_active_light_index(struct d3d_light *light)
 161 {
 162     struct d3d_viewport *vp = light->active_viewport;
 163
 164     TRACE("vp %p, light %p, index %u, active_lights_count %u, map_lights %#x.\n",
 165             vp, light, light->active_light_index, vp->active_lights_count, vp->map_lights);
 166
 167     if (!light->active_light_index)
 168         return;
 169
 170     assert(vp->map_lights & (1u << (light->active_light_index - 1)));
 171
 172     --vp->active_lights_count;
 173     vp->map_lights &= ~(1u << (light->active_light_index - 1));
 174     light->active_light_index = 0;
 175 }
 176
 177 /*****************************************************************************
 178  * _dump_D3DVIEWPORT, _dump_D3DVIEWPORT2
 179  *
 180  * Writes viewport information to TRACE
 181  *
 182  *****************************************************************************/
 183 static void _dump_D3DVIEWPORT(const D3DVIEWPORT *lpvp)
 184 {
 185     TRACE("    - dwSize = %d   dwX = %d   dwY = %d\n",
 186             lpvp->dwSize, lpvp->dwX, lpvp->dwY);
 187     TRACE("    - dwWidth = %d   dwHeight = %d\n",
 188             lpvp->dwWidth, lpvp->dwHeight);
 189     TRACE("    - dvScaleX = %f   dvScaleY = %f\n",
 190             lpvp->dvScaleX, lpvp->dvScaleY);
 191     TRACE("    - dvMaxX = %f   dvMaxY = %f\n",
 192             lpvp->dvMaxX, lpvp->dvMaxY);
 193     TRACE("    - dvMinZ = %f   dvMaxZ = %f\n",
 194             lpvp->dvMinZ, lpvp->dvMaxZ);
 195 }
 196
 197 static void _dump_D3DVIEWPORT2(const D3DVIEWPORT2 *lpvp)
 198 {
 199     TRACE("    - dwSize = %d   dwX = %d   dwY = %d\n",
 200             lpvp->dwSize, lpvp->dwX, lpvp->dwY);
 201     TRACE("    - dwWidth = %d   dwHeight = %d\n",
 202             lpvp->dwWidth, lpvp->dwHeight);
 203     TRACE("    - dvClipX = %f   dvClipY = %f\n",
 204             lpvp->dvClipX, lpvp->dvClipY);
 205     TRACE("    - dvClipWidth = %f   dvClipHeight = %f\n",
 206             lpvp->dvClipWidth, lpvp->dvClipHeight);
 207     TRACE("    - dvMinZ = %f   dvMaxZ = %f\n",
 208             lpvp->dvMinZ, lpvp->dvMaxZ);
 209 }
 210
 211 static inline struct d3d_viewport *impl_from_IDirect3DViewport3(IDirect3DViewport3 *iface)
 212 {
 213     return CONTAINING_RECORD(iface, struct d3d_viewport, IDirect3DViewport3_iface);
 214 }
 215
 216 /*****************************************************************************
 217  * IUnknown Methods.
 218  *****************************************************************************/
 219
 220 /*****************************************************************************
 221  * IDirect3DViewport3::QueryInterface
 222  *
 223  * A normal QueryInterface. Can query all interface versions and the
 224  * IUnknown interface. The VTables of the different versions
 225  * are equal
 226  *
 227  * Params:
 228  *  refiid: Interface id queried for
 229  *  obj: Address to write the interface pointer to
 230  *
 231  * Returns:
 232  *  S_OK on success.
 233  *  E_NOINTERFACE if the requested interface wasn't found
 234  *
 235  *****************************************************************************/
 236 static HRESULT WINAPI d3d_viewport_QueryInterface(IDirect3DViewport3 *iface, REFIID riid, void **object)
 237 {
 238     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 239
 240     if (IsEqualGUID(&IID_IDirect3DViewport3, riid)
 241             || IsEqualGUID(&IID_IDirect3DViewport2, riid)
 242             || IsEqualGUID(&IID_IDirect3DViewport, riid)
 243             || IsEqualGUID(&IID_IUnknown, riid))
 244     {
 245         IDirect3DViewport3_AddRef(iface);
 246         *object = iface;
 247         return S_OK;
 248     }
 249
 250     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 251
 252     *object = NULL;
 253     return E_NOINTERFACE;
 254 }
 255
 256 /*****************************************************************************
 257  * IDirect3DViewport3::AddRef
 258  *
 259  * Increases the refcount.
 260  *
 261  * Returns:
 262  *  The new refcount
 263  *
 264  *****************************************************************************/
 265 static ULONG WINAPI d3d_viewport_AddRef(IDirect3DViewport3 *iface)
 266 {
 267     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 268     ULONG ref = InterlockedIncrement(&viewport->ref);
 269
 270     TRACE("%p increasing refcount to %u.\n", viewport, ref);
 271
 272     return ref;
 273 }
 274
 275 /*****************************************************************************
 276  * IDirect3DViewport3::Release
 277  *
 278  * Reduces the refcount. If it falls to 0, the interface is released
 279  *
 280  * Returns:
 281  *  The new refcount
 282  *
 283  *****************************************************************************/
 284 static ULONG WINAPI d3d_viewport_Release(IDirect3DViewport3 *iface)
 285 {
 286     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 287     ULONG ref = InterlockedDecrement(&viewport->ref);
 288
 289     TRACE("%p decreasing refcount to %u.\n", viewport, ref);
 290
 291     if (!ref)
 292         heap_free(viewport);
 293
 294     return ref;
 295 }
 296
 297 /*****************************************************************************
 298  * IDirect3DViewport Methods.
 299  *****************************************************************************/
 300
 301 /*****************************************************************************
 302  * IDirect3DViewport3::Initialize
 303  *
 304  * No-op initialization.
 305  *
 306  * Params:
 307  *  Direct3D: The direct3D device this viewport is assigned to
 308  *
 309  * Returns:
 310  *  DDERR_ALREADYINITIALIZED
 311  *
 312  *****************************************************************************/
 313 static HRESULT WINAPI d3d_viewport_Initialize(IDirect3DViewport3 *iface, IDirect3D *d3d)
 314 {
 315     TRACE("iface %p, d3d %p.\n", iface, d3d);
 316
 317     return DDERR_ALREADYINITIALIZED;
 318 }
 319
 320 static HRESULT WINAPI d3d_viewport_GetViewport(IDirect3DViewport3 *iface, D3DVIEWPORT *vp)
 321 {
 322     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 323     DWORD size;
 324
 325     TRACE("iface %p, vp %p.\n", iface, vp);
 326
 327     if (!vp)
 328         return DDERR_INVALIDPARAMS;
 329
 330     if (viewport->version == DDRAW_VIEWPORT_VERSION_NONE)
 331     {
 332         WARN("Viewport data was not set.\n");
 333         return D3DERR_VIEWPORTDATANOTSET;
 334     }
 335
 336     wined3d_mutex_lock();
 337
 338     size = vp->dwSize;
 339     if (viewport->version == DDRAW_VIEWPORT_VERSION_1)
 340     {
 341         memcpy(vp, &viewport->viewports.vp1, size);
 342     }
 343     else
 344     {
 345         D3DVIEWPORT vp1;
 346
 347         vp1.dwSize = sizeof(vp1);
 348         vp1.dwX = viewport->viewports.vp2.dwX;
 349         vp1.dwY = viewport->viewports.vp2.dwY;
 350         vp1.dwWidth = viewport->viewports.vp2.dwWidth;
 351         vp1.dwHeight = viewport->viewports.vp2.dwHeight;
 352
 353         vp1.dvScaleX = vp1.dwWidth / viewport->viewports.vp2.dvClipWidth;
 354         vp1.dvScaleY = vp1.dwHeight / viewport->viewports.vp2.dvClipHeight;
 355         vp1.dvMaxX = viewport->viewports.vp2.dvClipWidth + viewport->viewports.vp2.dvClipX;
 356         vp1.dvMaxY = viewport->viewports.vp2.dvClipY;
 357         vp1.dvMinZ = 0.0f;
 358         vp1.dvMaxZ = 1.0f;
 359         memcpy(vp, &vp1, size);
 360     }
 361
 362     if (TRACE_ON(ddraw))
 363     {
 364         TRACE("  returning D3DVIEWPORT :\n");
 365         _dump_D3DVIEWPORT(vp);
 366     }
 367
 368     wined3d_mutex_unlock();
 369
 370     return D3D_OK;
 371 }
 372
 373 static HRESULT WINAPI d3d_viewport_SetViewport(IDirect3DViewport3 *iface, D3DVIEWPORT *vp)
 374 {
 375     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 376     struct d3d_device *device = viewport->active_device;
 377     struct wined3d_sub_resource_desc rt_desc;
 378     struct wined3d_rendertarget_view *rtv;
 379     IDirect3DViewport3 *current_viewport;
 380     struct ddraw_surface *surface;
 381
 382     TRACE("iface %p, vp %p.\n", iface, vp);
 383
 384     if (!vp)
 385         return DDERR_INVALIDPARAMS;
 386
 387     if (vp->dwSize != sizeof(*vp))
 388     {
 389         WARN("Invalid D3DVIEWPORT size %u.\n", vp->dwSize);
 390         return DDERR_INVALIDPARAMS;
 391     }
 392
 393     if (TRACE_ON(ddraw))
 394     {
 395         TRACE("  getting D3DVIEWPORT :\n");
 396         _dump_D3DVIEWPORT(vp);
 397     }
 398
 399     if (!device)
 400     {
 401         WARN("Viewport not bound to a device, returning D3DERR_VIEWPORTHASNODEVICE.\n");
 402         return D3DERR_VIEWPORTHASNODEVICE;
 403     }
 404
 405     wined3d_mutex_lock();
 406
 407     if (device->version > 1)
 408     {
 409         if (!(rtv = wined3d_device_get_rendertarget_view(device->wined3d_device, 0)))
 410         {
 411             wined3d_mutex_unlock();
 412             return DDERR_INVALIDCAPS;
 413         }
 414         surface = wined3d_rendertarget_view_get_sub_resource_parent(rtv);
 415         wined3d_texture_get_sub_resource_desc(surface->wined3d_texture, surface->sub_resource_idx, &rt_desc);
 416
 417         if (vp->dwX > rt_desc.width || vp->dwWidth > rt_desc.width - vp->dwX
 418             || vp->dwY > rt_desc.height || vp->dwHeight > rt_desc.height - vp->dwY)
 419         {
 420             WARN("Invalid viewport, returning DDERR_INVALIDPARAMS.\n");
 421             wined3d_mutex_unlock();
 422             return DDERR_INVALIDPARAMS;
 423         }
 424     }
 425
 426     viewport->version = DDRAW_VIEWPORT_VERSION_1;
 427     viewport->viewports.vp1 = *vp;
 428
 429     /* Empirical testing on a couple of d3d1 games showed that these values
 430      * should be ignored. */
 431     viewport->viewports.vp1.dvMinZ = 0.0f;
 432     viewport->viewports.vp1.dvMaxZ = 1.0f;
 433
 434     if (SUCCEEDED(IDirect3DDevice3_GetCurrentViewport(&device->IDirect3DDevice3_iface, &current_viewport)))
 435     {
 436         if (current_viewport == iface)
 437             viewport_activate(viewport, FALSE);
 438         IDirect3DViewport3_Release(current_viewport);
 439     }
 440
 441     wined3d_mutex_unlock();
 442
 443     return D3D_OK;
 444 }
 445
 446 /*****************************************************************************
 447  * IDirect3DViewport3::TransformVertices
 448  *
 449  * Transforms vertices by the transformation matrix.
 450  *
 451  * This function is pretty similar to IDirect3DVertexBuffer7::ProcessVertices,
 452  * so it's tempting to forward it to there. However, there are some
 453  * tiny differences. First, the lpOffscreen flag that is reported back,
 454  * then there is the homogeneous vertex that is generated. Also there's a lack
 455  * of FVFs, but still a custom stride. Last, the d3d1 - d3d3 viewport has some
 456  * settings (scale) that d3d7 and wined3d do not have. All in all wrapping to
 457  * ProcessVertices doesn't pay of in terms of wrapper code needed and code
 458  * reused.
 459  *
 460  * Params:
 461  *  dwVertexCount: The number of vertices to be transformed
 462  *  data: Pointer to the vertex input / output data.
 463  *  dwFlags: D3DTRANSFORM_CLIPPED or D3DTRANSFORM_UNCLIPPED
 464  *  offscreen: Logical AND of the planes that clipped the vertices if clipping
 465  *          is on. 0 if clipping is off.
 466  *
 467  * Returns:
 468  *  D3D_OK on success
 469  *  D3DERR_VIEWPORTHASNODEVICE if the viewport is not assigned to a device
 470  *  DDERR_INVALIDPARAMS if no clipping flag is specified
 471  *
 472  *****************************************************************************/
 473 struct transform_vertices_vertex
 474 {
 475     float x, y, z, w; /* w is unused in input data. */
 476     struct
 477     {
 478         DWORD p[4];
 479     } payload;
 480 };
 481
 482 static HRESULT WINAPI d3d_viewport_TransformVertices(IDirect3DViewport3 *iface,
 483         DWORD dwVertexCount, D3DTRANSFORMDATA *data, DWORD dwFlags, DWORD *offscreen)
 484 {
 485     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 486     const struct wined3d_stateblock_state *state;
 487     D3DVIEWPORT vp = viewport->viewports.vp1;
 488     struct transform_vertices_vertex *in, *out;
 489     struct wined3d_matrix mat;
 490     float x, y, z, w;
 491     unsigned int i;
 492     D3DHVERTEX *outH;
 493     struct d3d_device *device = viewport->active_device;
 494     BOOL activate = device->current_viewport != viewport;
 495
 496     TRACE("iface %p, vertex_count %u, data %p, flags %#x, offscreen %p.\n",
 497             iface, dwVertexCount, data, dwFlags, offscreen);
 498
 499     /* Tests on windows show that Windows crashes when this occurs,
 500      * so don't return the (intuitive) return value
 501     if (!device)
 502     {
 503         WARN("No device active, returning D3DERR_VIEWPORTHASNODEVICE\n");
 504         return D3DERR_VIEWPORTHASNODEVICE;
 505     }
 506      */
 507
 508     if (!data || data->dwSize != sizeof(*data))
 509     {
 510         WARN("Transform data is NULL or size is incorrect, returning DDERR_INVALIDPARAMS\n");
 511         return DDERR_INVALIDPARAMS;
 512     }
 513     if (!(dwFlags & (D3DTRANSFORM_UNCLIPPED | D3DTRANSFORM_CLIPPED)))
 514     {
 515         WARN("No clipping flag passed, returning DDERR_INVALIDPARAMS\n");
 516         return DDERR_INVALIDPARAMS;
 517     }
 518
 519     wined3d_mutex_lock();
 520     if (activate)
 521         viewport_activate(viewport, TRUE);
 522
 523     state = device->stateblock_state;
 524     multiply_matrix(&mat, &state->transforms[WINED3D_TS_VIEW], &state->transforms[WINED3D_TS_WORLD_MATRIX(0)]);
 525     multiply_matrix(&mat, &state->transforms[WINED3D_TS_PROJECTION], &mat);
 526
 527     /* The pointer is not tested against NULL on Windows. */
 528     if (dwFlags & D3DTRANSFORM_CLIPPED)
 529         *offscreen = ~0U;
 530     else
 531         *offscreen = 0;
 532
 533     outH = data->lpHOut;
 534     for(i = 0; i < dwVertexCount; i++)
 535     {
 536         in = (struct transform_vertices_vertex *)((char *)data->lpIn + data->dwInSize * i);
 537         out = (struct transform_vertices_vertex *)((char *)data->lpOut + data->dwOutSize * i);
 538
 539         x = (in->x * mat._11) + (in->y * mat._21) + (in->z * mat._31) + mat._41;
 540         y = (in->x * mat._12) + (in->y * mat._22) + (in->z * mat._32) + mat._42;
 541         z = (in->x * mat._13) + (in->y * mat._23) + (in->z * mat._33) + mat._43;
 542         w = (in->x * mat._14) + (in->y * mat._24) + (in->z * mat._34) + mat._44;
 543
 544         if(dwFlags & D3DTRANSFORM_CLIPPED)
 545         {
 546             /* If clipping is enabled, Windows assumes that outH is
 547              * a valid pointer. */
 548             outH[i].u1.hx = (x - device->legacy_clipspace._41 * w) / device->legacy_clipspace._11;
 549             outH[i].u2.hy = (y - device->legacy_clipspace._42 * w) / device->legacy_clipspace._22;
 550             outH[i].u3.hz = (z - device->legacy_clipspace._43 * w) / device->legacy_clipspace._33;
 551
 552             outH[i].dwFlags = 0;
 553             if (x > w)
 554                 outH[i].dwFlags |= D3DCLIP_RIGHT;
 555             if (x < -w)
 556                 outH[i].dwFlags |= D3DCLIP_LEFT;
 557             if (y > w)
 558                 outH[i].dwFlags |= D3DCLIP_TOP;
 559             if (y < -w)
 560                 outH[i].dwFlags |= D3DCLIP_BOTTOM;
 561             if (z < 0.0f)
 562                 outH[i].dwFlags |= D3DCLIP_FRONT;
 563             if (z > w)
 564                 outH[i].dwFlags |= D3DCLIP_BACK;
 565
 566             *offscreen &= outH[i].dwFlags;
 567
 568             if(outH[i].dwFlags)
 569             {
 570                 /* Looks like native just drops the vertex, leaves whatever data
 571                  * it has in the output buffer and goes on with the next vertex.
 572                  * The exact scheme hasn't been figured out yet, but windows
 573                  * definitely writes something there.
 574                  */
 575                 out->x = x;
 576                 out->y = y;
 577                 out->z = z;
 578                 out->w = w;
 579                 continue;
 580             }
 581         }
 582
 583         w = 1 / w;
 584         x *= w; y *= w; z *= w;
 585
 586         out->x = (x + 1.0f) * vp.dwWidth * 0.5 + vp.dwX;
 587         out->y = (-y + 1.0f) * vp.dwHeight * 0.5 + vp.dwY;
 588         out->z = z;
 589         out->w = w;
 590         out->payload = in->payload;
 591     }
 592
 593     if (activate && device->current_viewport)
 594         viewport_activate(device->current_viewport, TRUE);
 595
 596     wined3d_mutex_unlock();
 597
 598     TRACE("All done\n");
 599     return DD_OK;
 600 }
 601
 602 /*****************************************************************************
 603  * IDirect3DViewport3::LightElements
 604  *
 605  * The DirectX 5.0 sdk says that it's not implemented
 606  *
 607  * Params:
 608  *  ?
 609  *
 610  * Returns:
 611  *  DDERR_UNSUPPORTED
 612  *
 613  *****************************************************************************/
 614 static HRESULT WINAPI d3d_viewport_LightElements(IDirect3DViewport3 *iface,
 615         DWORD element_count, D3DLIGHTDATA *data)
 616 {
 617     TRACE("iface %p, element_count %u, data %p.\n", iface, element_count, data);
 618
 619     return DDERR_UNSUPPORTED;
 620 }
 621
 622 static HRESULT WINAPI d3d_viewport_SetBackground(IDirect3DViewport3 *iface, D3DMATERIALHANDLE material)
 623 {
 624     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 625     struct d3d_material *m;
 626
 627     TRACE("iface %p, material %#x.\n", iface, material);
 628
 629     wined3d_mutex_lock();
 630
 631     if (!(m = ddraw_get_object(&viewport->ddraw->d3ddevice->handle_table, material - 1, DDRAW_HANDLE_MATERIAL)))
 632     {
 633         WARN("Invalid material handle %#x.\n", material);
 634         wined3d_mutex_unlock();
 635         return DDERR_INVALIDPARAMS;
 636     }
 637
 638     TRACE("Setting background color : %.8e %.8e %.8e %.8e.\n",
 639             m->mat.u.diffuse.u1.r, m->mat.u.diffuse.u2.g,
 640             m->mat.u.diffuse.u3.b, m->mat.u.diffuse.u4.a);
 641     viewport->background = m;
 642
 643     wined3d_mutex_unlock();
 644
 645     return D3D_OK;
 646 }
 647
 648 /*****************************************************************************
 649  * IDirect3DViewport3::GetBackground
 650  *
 651  * Returns the material handle assigned to the background of the viewport
 652  *
 653  * Params:
 654  *  lphMat: Address to store the handle
 655  *  lpValid: is set to FALSE if no background is set, TRUE if one is set
 656  *
 657  * Returns:
 658  *  D3D_OK
 659  *
 660  *****************************************************************************/
 661 static HRESULT WINAPI d3d_viewport_GetBackground(IDirect3DViewport3 *iface,
 662         D3DMATERIALHANDLE *material, BOOL *valid)
 663 {
 664     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 665
 666     TRACE("iface %p, material %p, valid %p.\n", iface, material, valid);
 667
 668     wined3d_mutex_lock();
 669     if (valid)
 670         *valid = !!viewport->background;
 671     if (material)
 672         *material = viewport->background ? viewport->background->Handle : 0;
 673     wined3d_mutex_unlock();
 674
 675     return D3D_OK;
 676 }
 677
 678 /*****************************************************************************
 679  * IDirect3DViewport3::SetBackgroundDepth
 680  *
 681  * Sets a surface that represents the background depth. Its contents are
 682  * used to set the depth buffer in IDirect3DViewport3::Clear
 683  *
 684  * Params:
 685  *  lpDDSurface: Surface to set
 686  *
 687  * Returns: D3D_OK, because it's a stub
 688  *
 689  *****************************************************************************/
 690 static HRESULT WINAPI d3d_viewport_SetBackgroundDepth(IDirect3DViewport3 *iface, IDirectDrawSurface *surface)
 691 {
 692     FIXME("iface %p, surface %p stub!\n", iface, surface);
 693
 694     return D3D_OK;
 695 }
 696
 697 /*****************************************************************************
 698  * IDirect3DViewport3::GetBackgroundDepth
 699  *
 700  * Returns the surface that represents the depth field
 701  *
 702  * Params:
 703  *  lplpDDSurface: Address to store the interface pointer
 704  *  lpValid: Set to TRUE if a depth is assigned, FALSE otherwise
 705  *
 706  * Returns:
 707  *  D3D_OK, because it's a stub
 708  *  (DDERR_INVALIDPARAMS if DDSurface of Valid is NULL)
 709  *
 710  *****************************************************************************/
 711 static HRESULT WINAPI d3d_viewport_GetBackgroundDepth(IDirect3DViewport3 *iface,
 712         IDirectDrawSurface **surface, BOOL *valid)
 713 {
 714     FIXME("iface %p, surface %p, valid %p stub!\n", iface, surface, valid);
 715
 716     return DD_OK;
 717 }
 718
 719 /*****************************************************************************
 720  * IDirect3DViewport3::Clear
 721  *
 722  * Clears the render target and / or the z buffer
 723  *
 724  * Params:
 725  *  dwCount: The amount of rectangles to clear. If 0, the whole buffer is
 726  *           cleared
 727  *  lpRects: Pointer to the array of rectangles. If NULL, Count must be 0
 728  *  dwFlags: D3DCLEAR_ZBUFFER and / or D3DCLEAR_TARGET
 729  *
 730  * Returns:
 731  *  D3D_OK on success
 732  *  D3DERR_VIEWPORTHASNODEVICE if there's no active device
 733  *  The return value of IDirect3DDevice7::Clear
 734  *
 735  *****************************************************************************/
 736 static HRESULT WINAPI d3d_viewport_Clear(IDirect3DViewport3 *iface,
 737         DWORD rect_count, D3DRECT *rects, DWORD flags)
 738 {
 739     struct d3d_viewport *This = impl_from_IDirect3DViewport3(iface);
 740     DWORD color = 0x00000000;
 741     HRESULT hr;
 742     IDirect3DViewport3 *current_viewport;
 743     IDirect3DDevice3 *d3d_device3;
 744
 745     TRACE("iface %p, rect_count %u, rects %p, flags %#x.\n", iface, rect_count, rects, flags);
 746
 747     if (!rects || !rect_count)
 748     {
 749         WARN("rect_count = %u, rects = %p, ignoring clear\n", rect_count, rects);
 750         return D3D_OK;
 751     }
 752
 753     if (This->active_device == NULL) {
 754         ERR(" Trying to clear a viewport not attached to a device!\n");
 755         return D3DERR_VIEWPORTHASNODEVICE;
 756     }
 757     d3d_device3 = &This->active_device->IDirect3DDevice3_iface;
 758
 759     wined3d_mutex_lock();
 760
 761     if (flags & D3DCLEAR_TARGET)
 762     {
 763         if (!This->background)
 764             WARN("No background material set.\n");
 765         else
 766             color = D3DRGBA(This->background->mat.u.diffuse.u1.r,
 767                     This->background->mat.u.diffuse.u2.g,
 768                     This->background->mat.u.diffuse.u3.b,
 769                     This->background->mat.u.diffuse.u4.a);
 770     }
 771
 772     /* Need to temporarily activate the viewport to clear it. The previously
 773      * active one will be restored afterwards. */
 774     viewport_activate(This, TRUE);
 775
 776     hr = IDirect3DDevice7_Clear(&This->active_device->IDirect3DDevice7_iface, rect_count, rects,
 777             flags & (D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET), color, 1.0, 0x00000000);
 778
 779     if (SUCCEEDED(IDirect3DDevice3_GetCurrentViewport(d3d_device3, &current_viewport)))
 780     {
 781         struct d3d_viewport *vp = impl_from_IDirect3DViewport3(current_viewport);
 782         viewport_activate(vp, TRUE);
 783         IDirect3DViewport3_Release(current_viewport);
 784     }
 785
 786     wined3d_mutex_unlock();
 787
 788     return hr;
 789 }
 790
 791 /*****************************************************************************
 792  * IDirect3DViewport3::AddLight
 793  *
 794  * Adds an light to the viewport
 795  *
 796  * Params:
 797  *  lpDirect3DLight: Interface of the light to add
 798  *
 799  * Returns:
 800  *  D3D_OK on success
 801  *  DDERR_INVALIDPARAMS if Direct3DLight is NULL
 802  *  DDERR_INVALIDPARAMS if there are 8 lights or more
 803  *
 804  *****************************************************************************/
 805 static HRESULT WINAPI d3d_viewport_AddLight(IDirect3DViewport3 *viewport, IDirect3DLight *light)
 806 {
 807     struct d3d_light *light_impl = unsafe_impl_from_IDirect3DLight(light);
 808     struct d3d_viewport *vp = impl_from_IDirect3DViewport3(viewport);
 809
 810     TRACE("viewport %p, light %p.\n", viewport, light);
 811
 812     wined3d_mutex_lock();
 813
 814     if (light_impl->active_viewport)
 815     {
 816         wined3d_mutex_unlock();
 817         WARN("Light %p is active in viewport %p.\n", light_impl, light_impl->active_viewport);
 818         return D3DERR_LIGHTHASVIEWPORT;
 819     }
 820
 821     light_impl->active_viewport = vp;
 822
 823     /* Add the light in the 'linked' chain */
 824     list_add_tail(&vp->light_list, &light_impl->entry);
 825     IDirect3DLight_AddRef(light);
 826
 827     light_activate(light_impl);
 828
 829     wined3d_mutex_unlock();
 830
 831     return D3D_OK;
 832 }
 833
 834 /*****************************************************************************
 835  * IDirect3DViewport3::DeleteLight
 836  *
 837  * Deletes a light from the viewports' light list
 838  *
 839  * Params:
 840  *  lpDirect3DLight: Light to delete
 841  *
 842  * Returns:
 843  *  D3D_OK on success
 844  *  DDERR_INVALIDPARAMS if the light wasn't found
 845  *
 846  *****************************************************************************/
 847 static HRESULT WINAPI d3d_viewport_DeleteLight(IDirect3DViewport3 *iface, IDirect3DLight *lpDirect3DLight)
 848 {
 849     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 850     struct d3d_light *l = unsafe_impl_from_IDirect3DLight(lpDirect3DLight);
 851
 852     TRACE("iface %p, light %p.\n", iface, lpDirect3DLight);
 853
 854     wined3d_mutex_lock();
 855
 856     if (l->active_viewport != viewport)
 857     {
 858         WARN("Light %p active viewport is %p.\n", l, l->active_viewport);
 859         wined3d_mutex_unlock();
 860         return DDERR_INVALIDPARAMS;
 861     }
 862
 863     light_deactivate(l);
 864     list_remove(&l->entry);
 865     l->active_viewport = NULL;
 866     IDirect3DLight_Release(lpDirect3DLight);
 867
 868     wined3d_mutex_unlock();
 869
 870     return D3D_OK;
 871 }
 872
 873 /*****************************************************************************
 874  * IDirect3DViewport::NextLight
 875  *
 876  * Enumerates the lights associated with the viewport
 877  *
 878  * Params:
 879  *  lpDirect3DLight: Light to start with
 880  *  lplpDirect3DLight: Address to store the successor to
 881  *
 882  * Returns:
 883  *  D3D_OK, because it's a stub
 884  *
 885  *****************************************************************************/
 886 static HRESULT WINAPI d3d_viewport_NextLight(IDirect3DViewport3 *iface,
 887         IDirect3DLight *lpDirect3DLight, IDirect3DLight **lplpDirect3DLight, DWORD flags)
 888 {
 889     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 890     struct d3d_light *l = unsafe_impl_from_IDirect3DLight(lpDirect3DLight);
 891     struct list *entry;
 892     HRESULT hr;
 893
 894     TRACE("iface %p, light %p, next_light %p, flags %#x.\n",
 895             iface, lpDirect3DLight, lplpDirect3DLight, flags);
 896
 897     if (!lplpDirect3DLight)
 898         return DDERR_INVALIDPARAMS;
 899
 900     wined3d_mutex_lock();
 901
 902     switch (flags)
 903     {
 904         case D3DNEXT_NEXT:
 905             if (!l || l->active_viewport != viewport)
 906             {
 907                 if (l)
 908                     WARN("Light %p active viewport is %p.\n", l, l->active_viewport);
 909                 entry = NULL;
 910             }
 911             else
 912                 entry = list_next(&viewport->light_list, &l->entry);
 913             break;
 914
 915         case D3DNEXT_HEAD:
 916             entry = list_head(&viewport->light_list);
 917             break;
 918
 919         case D3DNEXT_TAIL:
 920             entry = list_tail(&viewport->light_list);
 921             break;
 922
 923         default:
 924             entry = NULL;
 925             WARN("Invalid flags %#x.\n", flags);
 926             break;
 927     }
 928
 929     if (entry)
 930     {
 931         *lplpDirect3DLight = (IDirect3DLight *)LIST_ENTRY(entry, struct d3d_light, entry);
 932         IDirect3DLight_AddRef(*lplpDirect3DLight);
 933         hr = D3D_OK;
 934     }
 935     else
 936     {
 937         *lplpDirect3DLight = NULL;
 938         hr = DDERR_INVALIDPARAMS;
 939     }
 940
 941     wined3d_mutex_unlock();
 942
 943     return hr;
 944 }
 945
 946 /*****************************************************************************
 947  * IDirect3DViewport2 Methods.
 948  *****************************************************************************/
 949
 950 static HRESULT WINAPI d3d_viewport_GetViewport2(IDirect3DViewport3 *iface, D3DVIEWPORT2 *vp)
 951 {
 952     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
 953     DWORD size;
 954
 955     TRACE("iface %p, vp %p.\n", iface, vp);
 956
 957     if (!vp)
 958         return DDERR_INVALIDPARAMS;
 959
 960     if (viewport->version == DDRAW_VIEWPORT_VERSION_NONE)
 961     {
 962         WARN("Viewport data was not set.\n");
 963         return D3DERR_VIEWPORTDATANOTSET;
 964     }
 965
 966     wined3d_mutex_lock();
 967     size = vp->dwSize;
 968     if (viewport->version == DDRAW_VIEWPORT_VERSION_2)
 969     {
 970         memcpy(vp, &viewport->viewports.vp2, size);
 971     }
 972     else
 973     {
 974         D3DVIEWPORT2 vp2;
 975
 976         vp2.dwSize = sizeof(vp2);
 977         vp2.dwX = viewport->viewports.vp1.dwX;
 978         vp2.dwY = viewport->viewports.vp1.dwY;
 979         vp2.dwWidth = viewport->viewports.vp1.dwWidth;
 980         vp2.dwHeight = viewport->viewports.vp1.dwHeight;
 981
 982         vp2.dvClipWidth = viewport->viewports.vp1.dwWidth / viewport->viewports.vp1.dvScaleX;
 983         vp2.dvClipHeight = viewport->viewports.vp1.dwHeight / viewport->viewports.vp1.dvScaleY;
 984         vp2.dvClipX = -vp2.dvClipWidth / 2.0f;
 985         vp2.dvClipY = vp2.dvClipHeight / 2.0f;
 986         vp2.dvMinZ = 0.0f;
 987         vp2.dvMaxZ = 1.0f;
 988         memcpy(vp, &vp2, size);
 989     }
 990
 991     if (TRACE_ON(ddraw))
 992     {
 993         TRACE("  returning D3DVIEWPORT2 :\n");
 994         _dump_D3DVIEWPORT2(vp);
 995     }
 996
 997     wined3d_mutex_unlock();
 998
 999     return D3D_OK;
1000 }
1001
1002 static HRESULT WINAPI d3d_viewport_SetViewport2(IDirect3DViewport3 *iface, D3DVIEWPORT2 *vp)
1003 {
1004     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
1005     struct d3d_device *device = viewport->active_device;
1006     struct wined3d_sub_resource_desc rt_desc;
1007     struct wined3d_rendertarget_view *rtv;
1008     IDirect3DViewport3 *current_viewport;
1009     struct ddraw_surface *surface;
1010
1011     TRACE("iface %p, vp %p.\n", iface, vp);
1012
1013     if (!vp)
1014         return DDERR_INVALIDPARAMS;
1015
1016     if (vp->dwSize != sizeof(*vp))
1017     {
1018         WARN("Invalid D3DVIEWPORT2 size %u.\n", vp->dwSize);
1019         return DDERR_INVALIDPARAMS;
1020     }
1021
1022     if (TRACE_ON(ddraw))
1023     {
1024         TRACE("  getting D3DVIEWPORT2 :\n");
1025         _dump_D3DVIEWPORT2(vp);
1026     }
1027
1028     if (!device)
1029     {
1030         WARN("Viewport not bound to a device, returning D3DERR_VIEWPORTHASNODEVICE.\n");
1031         return D3DERR_VIEWPORTHASNODEVICE;
1032     }
1033
1034     wined3d_mutex_lock();
1035
1036     if (device->version > 1)
1037     {
1038         if (!(rtv = wined3d_device_get_rendertarget_view(device->wined3d_device, 0)))
1039         {
1040             wined3d_mutex_unlock();
1041             return DDERR_INVALIDCAPS;
1042         }
1043         surface = wined3d_rendertarget_view_get_sub_resource_parent(rtv);
1044         wined3d_texture_get_sub_resource_desc(surface->wined3d_texture, surface->sub_resource_idx, &rt_desc);
1045
1046         if (vp->dwX > rt_desc.width || vp->dwWidth > rt_desc.width - vp->dwX
1047             || vp->dwY > rt_desc.height || vp->dwHeight > rt_desc.height - vp->dwY)
1048         {
1049             WARN("Invalid viewport, returning DDERR_INVALIDPARAMS.\n");
1050             wined3d_mutex_unlock();
1051             return DDERR_INVALIDPARAMS;
1052         }
1053     }
1054
1055     viewport->version = DDRAW_VIEWPORT_VERSION_2;
1056     viewport->viewports.vp2 = *vp;
1057
1058     if (SUCCEEDED(IDirect3DDevice3_GetCurrentViewport(&device->IDirect3DDevice3_iface, &current_viewport)))
1059     {
1060         if (current_viewport == iface)
1061             viewport_activate(viewport, FALSE);
1062         IDirect3DViewport3_Release(current_viewport);
1063     }
1064
1065     wined3d_mutex_unlock();
1066
1067     return D3D_OK;
1068 }
1069
1070 /*****************************************************************************
1071  * IDirect3DViewport3 Methods.
1072  *****************************************************************************/
1073
1074 /*****************************************************************************
1075  * IDirect3DViewport3::SetBackgroundDepth2
1076  *
1077  * Sets a IDirectDrawSurface4 surface as the background depth surface
1078  *
1079  * Params:
1080  *  lpDDS: Surface to set
1081  *
1082  * Returns:
1083  *  D3D_OK, because it's stub
1084  *
1085  *****************************************************************************/
1086 static HRESULT WINAPI d3d_viewport_SetBackgroundDepth2(IDirect3DViewport3 *iface,
1087         IDirectDrawSurface4 *surface)
1088 {
1089     FIXME("iface %p, surface %p stub!\n", iface, surface);
1090
1091     return D3D_OK;
1092 }
1093
1094 /*****************************************************************************
1095  * IDirect3DViewport3::GetBackgroundDepth2
1096  *
1097  * Returns the IDirect3DSurface4 interface to the background depth surface
1098  *
1099  * Params:
1100  *  lplpDDS: Address to store the interface pointer at
1101  *  lpValid: Set to true if a surface is assigned
1102  *
1103  * Returns:
1104  *  D3D_OK because it's a stub
1105  *
1106  *****************************************************************************/
1107 static HRESULT WINAPI d3d_viewport_GetBackgroundDepth2(IDirect3DViewport3 *iface,
1108         IDirectDrawSurface4 **surface, BOOL *valid)
1109 {
1110     FIXME("iface %p, surface %p, valid %p stub!\n", iface, surface, valid);
1111
1112     return D3D_OK;
1113 }
1114
1115 /*****************************************************************************
1116  * IDirect3DViewport3::Clear2
1117  *
1118  * Another clearing method
1119  *
1120  * Params:
1121  *  Count: Number of rectangles to clear
1122  *  Rects: Rectangle array to clear
1123  *  Flags: Some flags :)
1124  *  Color: Color to fill the render target with
1125  *  Z: Value to fill the depth buffer with
1126  *  Stencil: Value to fill the stencil bits with
1127  *
1128  * Returns:
1129  *
1130  *****************************************************************************/
1131 static HRESULT WINAPI d3d_viewport_Clear2(IDirect3DViewport3 *iface, DWORD rect_count,
1132         D3DRECT *rects, DWORD flags, DWORD color, D3DVALUE depth, DWORD stencil)
1133 {
1134     struct d3d_viewport *viewport = impl_from_IDirect3DViewport3(iface);
1135     HRESULT hr;
1136     IDirect3DViewport3 *current_viewport;
1137     IDirect3DDevice3 *d3d_device3;
1138
1139     TRACE("iface %p, rect_count %u, rects %p, flags %#x, color 0x%08x, depth %.8e, stencil %u.\n",
1140             iface, rect_count, rects, flags, color, depth, stencil);
1141
1142     if (!rects || !rect_count)
1143     {
1144         WARN("rect_count = %u, rects = %p, ignoring clear\n", rect_count, rects);
1145         return D3D_OK;
1146     }
1147
1148     wined3d_mutex_lock();
1149
1150     if (!viewport->active_device)
1151     {
1152         WARN("Trying to clear a viewport not attached to a device.\n");
1153         wined3d_mutex_unlock();
1154         return D3DERR_VIEWPORTHASNODEVICE;
1155     }
1156     d3d_device3 = &viewport->active_device->IDirect3DDevice3_iface;
1157     /* Need to temporarily activate viewport to clear it. Previously active
1158      * one will be restored afterwards. */
1159     viewport_activate(viewport, TRUE);
1160
1161     hr = IDirect3DDevice7_Clear(&viewport->active_device->IDirect3DDevice7_iface,
1162             rect_count, rects, flags, color, depth, stencil);
1163     if (SUCCEEDED(IDirect3DDevice3_GetCurrentViewport(d3d_device3, &current_viewport)))
1164     {
1165         struct d3d_viewport *vp = impl_from_IDirect3DViewport3(current_viewport);
1166         viewport_activate(vp, TRUE);
1167         IDirect3DViewport3_Release(current_viewport);
1168     }
1169
1170     wined3d_mutex_unlock();
1171
1172     return hr;
1173 }
1174
1175 /*****************************************************************************
1176  * The VTable
1177  *****************************************************************************/
1178
1179 static const struct IDirect3DViewport3Vtbl d3d_viewport_vtbl =
1180 {
1181     /*** IUnknown Methods ***/
1182     d3d_viewport_QueryInterface,
1183     d3d_viewport_AddRef,
1184     d3d_viewport_Release,
1185     /*** IDirect3DViewport Methods */
1186     d3d_viewport_Initialize,
1187     d3d_viewport_GetViewport,
1188     d3d_viewport_SetViewport,
1189     d3d_viewport_TransformVertices,
1190     d3d_viewport_LightElements,
1191     d3d_viewport_SetBackground,
1192     d3d_viewport_GetBackground,
1193     d3d_viewport_SetBackgroundDepth,
1194     d3d_viewport_GetBackgroundDepth,
1195     d3d_viewport_Clear,
1196     d3d_viewport_AddLight,
1197     d3d_viewport_DeleteLight,
1198     d3d_viewport_NextLight,
1199     /*** IDirect3DViewport2 Methods ***/
1200     d3d_viewport_GetViewport2,
1201     d3d_viewport_SetViewport2,
1202     /*** IDirect3DViewport3 Methods ***/
1203     d3d_viewport_SetBackgroundDepth2,
1204     d3d_viewport_GetBackgroundDepth2,
1205     d3d_viewport_Clear2,
1206 };
1207
1208 struct d3d_viewport *unsafe_impl_from_IDirect3DViewport3(IDirect3DViewport3 *iface)
1209 {
1210     if (!iface) return NULL;
1211     assert(iface->lpVtbl == &d3d_viewport_vtbl);
1212     return CONTAINING_RECORD(iface, struct d3d_viewport, IDirect3DViewport3_iface);
1213 }
1214
1215 struct d3d_viewport *unsafe_impl_from_IDirect3DViewport2(IDirect3DViewport2 *iface)
1216 {
1217     /* IDirect3DViewport and IDirect3DViewport3 use the same iface. */
1218     if (!iface) return NULL;
1219     assert(iface->lpVtbl == (IDirect3DViewport2Vtbl *)&d3d_viewport_vtbl);
1220     return CONTAINING_RECORD(iface, struct d3d_viewport, IDirect3DViewport3_iface);
1221 }
1222
1223 struct d3d_viewport *unsafe_impl_from_IDirect3DViewport(IDirect3DViewport *iface)
1224 {
1225     /* IDirect3DViewport and IDirect3DViewport3 use the same iface. */
1226     if (!iface) return NULL;
1227     assert(iface->lpVtbl == (IDirect3DViewportVtbl *)&d3d_viewport_vtbl);
1228     return CONTAINING_RECORD(iface, struct d3d_viewport, IDirect3DViewport3_iface);
1229 }
1230
1231 void d3d_viewport_init(struct d3d_viewport *viewport, struct ddraw *ddraw)
1232 {
1233     viewport->IDirect3DViewport3_iface.lpVtbl = &d3d_viewport_vtbl;
1234     viewport->ref = 1;
1235     viewport->ddraw = ddraw;
1236     viewport->version = DDRAW_VIEWPORT_VERSION_NONE;
1237     list_init(&viewport->light_list);
1238 }