git.oblomov.eu Git - wine/blob - dlls/ddraw/viewport.c

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