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