/* Direct3D Viewport * Copyright (c) 1998 Lionel ULMER * Copyright (c) 2006-2007 Stefan DÖSINGER * * This file contains the implementation of Direct3DViewport2. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include #include #include #include #define COBJMACROS #define NONAMELESSUNION #include "windef.h" #include "winbase.h" #include "winerror.h" #include "wingdi.h" #include "wine/exception.h" #include "ddraw.h" #include "d3d.h" #include "ddraw_private.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(d3d7); /***************************************************************************** * Helper functions *****************************************************************************/ /***************************************************************************** * viewport_activate * * activates the viewport using IDirect3DDevice7::SetViewport * *****************************************************************************/ void viewport_activate(IDirect3DViewportImpl* This, BOOL ignore_lights) { IDirect3DLightImpl* light; D3DVIEWPORT7 vp; if (!ignore_lights) { /* Activate all the lights associated with this context */ light = This->lights; while (light != NULL) { light->activate(light); light = light->next; } } /* And copy the values in the structure used by the device */ if (This->use_vp2) { vp.dwX = This->viewports.vp2.dwX; vp.dwY = This->viewports.vp2.dwY; vp.dwHeight = This->viewports.vp2.dwHeight; vp.dwWidth = This->viewports.vp2.dwWidth; vp.dvMinZ = This->viewports.vp2.dvMinZ; vp.dvMaxZ = This->viewports.vp2.dvMaxZ; } else { vp.dwX = This->viewports.vp1.dwX; vp.dwY = This->viewports.vp1.dwY; vp.dwHeight = This->viewports.vp1.dwHeight; vp.dwWidth = This->viewports.vp1.dwWidth; vp.dvMinZ = This->viewports.vp1.dvMinZ; vp.dvMaxZ = This->viewports.vp1.dvMaxZ; } /* And also set the viewport */ IDirect3DDevice7_SetViewport((IDirect3DDevice7 *)This->active_device, &vp); } /***************************************************************************** * _dump_D3DVIEWPORT, _dump_D3DVIEWPORT2 * * Writes viewport information to TRACE * *****************************************************************************/ static void _dump_D3DVIEWPORT(const D3DVIEWPORT *lpvp) { TRACE(" - dwSize = %d dwX = %d dwY = %d\n", lpvp->dwSize, lpvp->dwX, lpvp->dwY); TRACE(" - dwWidth = %d dwHeight = %d\n", lpvp->dwWidth, lpvp->dwHeight); TRACE(" - dvScaleX = %f dvScaleY = %f\n", lpvp->dvScaleX, lpvp->dvScaleY); TRACE(" - dvMaxX = %f dvMaxY = %f\n", lpvp->dvMaxX, lpvp->dvMaxY); TRACE(" - dvMinZ = %f dvMaxZ = %f\n", lpvp->dvMinZ, lpvp->dvMaxZ); } static void _dump_D3DVIEWPORT2(const D3DVIEWPORT2 *lpvp) { TRACE(" - dwSize = %d dwX = %d dwY = %d\n", lpvp->dwSize, lpvp->dwX, lpvp->dwY); TRACE(" - dwWidth = %d dwHeight = %d\n", lpvp->dwWidth, lpvp->dwHeight); TRACE(" - dvClipX = %f dvClipY = %f\n", lpvp->dvClipX, lpvp->dvClipY); TRACE(" - dvClipWidth = %f dvClipHeight = %f\n", lpvp->dvClipWidth, lpvp->dvClipHeight); TRACE(" - dvMinZ = %f dvMaxZ = %f\n", lpvp->dvMinZ, lpvp->dvMaxZ); } /***************************************************************************** * IUnknown Methods. *****************************************************************************/ /***************************************************************************** * IDirect3DViewport3::QueryInterface * * A normal QueryInterface. Can query all interface versions and the * IUnknown interface. The VTables of the different versions * are equal * * Params: * refiid: Interface id queried for * obj: Address to write the interface pointer to * * Returns: * S_OK on success. * E_NOINTERFACE if the requested interface wasn't found * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_QueryInterface(IDirect3DViewport3 *iface, REFIID riid, void **obp) { TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), obp); *obp = NULL; if ( IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDirect3DViewport, riid) || IsEqualGUID(&IID_IDirect3DViewport2, riid) || IsEqualGUID(&IID_IDirect3DViewport3, riid) ) { IDirect3DViewport3_AddRef(iface); *obp = iface; TRACE(" Creating IDirect3DViewport1/2/3 interface %p\n", *obp); return S_OK; } FIXME("(%p): interface for IID %s NOT found!\n", iface, debugstr_guid(riid)); return E_NOINTERFACE; } /***************************************************************************** * IDirect3DViewport3::AddRef * * Increases the refcount. * * Returns: * The new refcount * *****************************************************************************/ static ULONG WINAPI IDirect3DViewportImpl_AddRef(IDirect3DViewport3 *iface) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; ULONG ref = InterlockedIncrement(&This->ref); TRACE("(%p)->() incrementing from %u.\n", This, ref - 1); return ref; } /***************************************************************************** * IDirect3DViewport3::Release * * Reduces the refcount. If it falls to 0, the interface is released * * Returns: * The new refcount * *****************************************************************************/ static ULONG WINAPI IDirect3DViewportImpl_Release(IDirect3DViewport3 *iface) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; ULONG ref = InterlockedDecrement(&This->ref); TRACE("(%p)->() decrementing from %u.\n", This, ref + 1); if (!ref) { HeapFree(GetProcessHeap(), 0, This); return 0; } return ref; } /***************************************************************************** * IDirect3DViewport Methods. *****************************************************************************/ /***************************************************************************** * IDirect3DViewport3::Initialize * * No-op initialization. * * Params: * Direct3D: The direct3D device this viewport is assigned to * * Returns: * DDERR_ALREADYINITIALIZED * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_Initialize(IDirect3DViewport3 *iface, IDirect3D *Direct3D) { TRACE("(%p)->(%p) no-op...\n", iface, Direct3D); return DDERR_ALREADYINITIALIZED; } /***************************************************************************** * IDirect3DViewport3::GetViewport * * Returns the viewport data assigned to this viewport interface * * Params: * Data: Address to store the data * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS if Data is NULL * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_GetViewport(IDirect3DViewport3 *iface, D3DVIEWPORT *lpData) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; DWORD dwSize; TRACE("(%p/%p)->(%p)\n", This, iface, lpData); EnterCriticalSection(&ddraw_cs); dwSize = lpData->dwSize; memset(lpData, 0, dwSize); if (!This->use_vp2) memcpy(lpData, &(This->viewports.vp1), dwSize); else { D3DVIEWPORT vp1; vp1.dwSize = sizeof(vp1); vp1.dwX = This->viewports.vp2.dwX; vp1.dwY = This->viewports.vp2.dwY; vp1.dwWidth = This->viewports.vp2.dwWidth; vp1.dwHeight = This->viewports.vp2.dwHeight; vp1.dvMaxX = 0.0; vp1.dvMaxY = 0.0; vp1.dvScaleX = 0.0; vp1.dvScaleY = 0.0; vp1.dvMinZ = This->viewports.vp2.dvMinZ; vp1.dvMaxZ = This->viewports.vp2.dvMaxZ; memcpy(lpData, &vp1, dwSize); } if (TRACE_ON(d3d7)) { TRACE(" returning D3DVIEWPORT :\n"); _dump_D3DVIEWPORT(lpData); } LeaveCriticalSection(&ddraw_cs); return DD_OK; } /***************************************************************************** * IDirect3DViewport3::SetViewport * * Sets the viewport information for this interface * * Params: * lpData: Viewport to set * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS if Data is NULL * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_SetViewport(IDirect3DViewport3 *iface, D3DVIEWPORT *lpData) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; LPDIRECT3DVIEWPORT3 current_viewport; TRACE("(%p/%p)->(%p)\n", This, iface, lpData); if (TRACE_ON(d3d7)) { TRACE(" getting D3DVIEWPORT :\n"); _dump_D3DVIEWPORT(lpData); } EnterCriticalSection(&ddraw_cs); This->use_vp2 = 0; memset(&(This->viewports.vp1), 0, sizeof(This->viewports.vp1)); memcpy(&(This->viewports.vp1), lpData, lpData->dwSize); /* Tests on two games show that these values are never used properly so override them with proper ones :-) */ This->viewports.vp1.dvMinZ = 0.0; This->viewports.vp1.dvMaxZ = 1.0; if (This->active_device) { IDirect3DDevice3 *d3d_device3 = (IDirect3DDevice3 *)&This->active_device->IDirect3DDevice3_vtbl; IDirect3DDevice3_GetCurrentViewport(d3d_device3, ¤t_viewport); if (current_viewport) { if ((IDirect3DViewportImpl *)current_viewport == This) This->activate(This, FALSE); IDirect3DViewport3_Release(current_viewport); } } LeaveCriticalSection(&ddraw_cs); return DD_OK; } /***************************************************************************** * IDirect3DViewport3::TransformVertices * * Transforms vertices by the transformation matrix. * * This function is pretty similar to IDirect3DVertexBuffer7::ProcessVertices, * so it's tempting to forward it to there. However, there are some * tiny differences. First, the lpOffscreen flag that is reported back, * then there is the homogeneous vertex that is generated. Also there's a lack * of FVFs, but still a custom stride. Last, the d3d1 - d3d3 viewport has some * settings (scale) that d3d7 and wined3d do not have. All in all wrapping to * ProcessVertices doesn't pay of in terms of wrapper code needed and code * reused. * * Params: * dwVertexCount: The number of vertices to be transformed * lpData: Pointer to the vertex data * dwFlags: D3DTRANSFORM_CLIPPED or D3DTRANSFORM_UNCLIPPED * lpOffScreen: Set to the clipping plane clipping the vertex, if only one * vertex is transformed and clipping is on. 0 otherwise * * Returns: * D3D_OK on success * D3DERR_VIEWPORTHASNODEVICE if the viewport is not assigned to a device * DDERR_INVALIDPARAMS if no clipping flag is specified * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_TransformVertices(IDirect3DViewport3 *iface, DWORD dwVertexCount, D3DTRANSFORMDATA *lpData, DWORD dwFlags, DWORD *lpOffScreen) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; D3DMATRIX view_mat, world_mat, proj_mat, mat; float *in; float *out; float x, y, z, w; unsigned int i; D3DVIEWPORT vp = This->viewports.vp1; D3DHVERTEX *outH; TRACE("(%p)->(%08x,%p,%08x,%p)\n", This, dwVertexCount, lpData, dwFlags, lpOffScreen); /* Tests on windows show that Windows crashes when this occurs, * so don't return the (intuitive) return value if(!This->active_device) { WARN("No device active, returning D3DERR_VIEWPORTHASNODEVICE\n"); return D3DERR_VIEWPORTHASNODEVICE; } */ if(!(dwFlags & (D3DTRANSFORM_UNCLIPPED | D3DTRANSFORM_CLIPPED))) { WARN("No clipping flag passed, returning DDERR_INVALIDPARAMS\n"); return DDERR_INVALIDPARAMS; } EnterCriticalSection(&ddraw_cs); IWineD3DDevice_GetTransform(This->active_device->wineD3DDevice, D3DTRANSFORMSTATE_VIEW, (WINED3DMATRIX*) &view_mat); IWineD3DDevice_GetTransform(This->active_device->wineD3DDevice, D3DTRANSFORMSTATE_PROJECTION, (WINED3DMATRIX*) &proj_mat); IWineD3DDevice_GetTransform(This->active_device->wineD3DDevice, WINED3DTS_WORLDMATRIX(0), (WINED3DMATRIX*) &world_mat); multiply_matrix(&mat,&view_mat,&world_mat); multiply_matrix(&mat,&proj_mat,&mat); in = lpData->lpIn; out = lpData->lpOut; outH = lpData->lpHOut; for(i = 0; i < dwVertexCount; i++) { x = (in[0] * mat._11) + (in[1] * mat._21) + (in[2] * mat._31) + (1.0 * mat._41); y = (in[0] * mat._12) + (in[1] * mat._22) + (in[2] * mat._32) + (1.0 * mat._42); z = (in[0] * mat._13) + (in[1] * mat._23) + (in[2] * mat._33) + (1.0 * mat._43); w = (in[0] * mat._14) + (in[1] * mat._24) + (in[2] * mat._34) + (1.0 * mat._44); if(dwFlags & D3DTRANSFORM_CLIPPED) { /* If clipping is enabled, Windows assumes that outH is * a valid pointer */ outH[i].u1.hx = x; outH[i].u2.hy = y; outH[i].u3.hz = z; outH[i].dwFlags = 0; if(x * vp.dvScaleX > ((float) vp.dwWidth * 0.5)) outH[i].dwFlags |= D3DCLIP_RIGHT; if(x * vp.dvScaleX <= -((float) vp.dwWidth) * 0.5) outH[i].dwFlags |= D3DCLIP_LEFT; if(y * vp.dvScaleY > ((float) vp.dwHeight * 0.5)) outH[i].dwFlags |= D3DCLIP_TOP; if(y * vp.dvScaleY <= -((float) vp.dwHeight) * 0.5) outH[i].dwFlags |= D3DCLIP_BOTTOM; if(z < 0.0) outH[i].dwFlags |= D3DCLIP_FRONT; if(z > 1.0) outH[i].dwFlags |= D3DCLIP_BACK; if(outH[i].dwFlags) { /* Looks like native just drops the vertex, leaves whatever data * it has in the output buffer and goes on with the next vertex. * The exact scheme hasn't been figured out yet, but windows * definitely writes something there. */ out[0] = x; out[1] = y; out[2] = z; out[3] = w; in = (float *) ((char *) in + lpData->dwInSize); out = (float *) ((char *) out + lpData->dwOutSize); continue; } } w = 1 / w; x *= w; y *= w; z *= w; out[0] = vp.dwWidth / 2 + vp.dwX + x * vp.dvScaleX; out[1] = vp.dwHeight / 2 + vp.dwY - y * vp.dvScaleY; out[2] = z; out[3] = w; in = (float *) ((char *) in + lpData->dwInSize); out = (float *) ((char *) out + lpData->dwOutSize); } /* According to the d3d test, the offscreen flag is set only * if exactly one vertex is transformed. Its not documented, * but the test shows that the lpOffscreen flag is set to the * flag combination of clipping planes that clips the vertex. * * If clipping is requested, Windows assumes that the offscreen * param is a valid pointer. */ if(dwVertexCount == 1 && dwFlags & D3DTRANSFORM_CLIPPED) { *lpOffScreen = outH[0].dwFlags; } else if(*lpOffScreen) { *lpOffScreen = 0; } LeaveCriticalSection(&ddraw_cs); TRACE("All done\n"); return DD_OK; } /***************************************************************************** * IDirect3DViewport3::LightElements * * The DirectX 5.0 sdk says that it's not implemented * * Params: * ? * * Returns: * DDERR_UNSUPPORTED * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_LightElements(IDirect3DViewport3 *iface, DWORD dwElementCount, LPD3DLIGHTDATA lpData) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; TRACE("(%p)->(%08x,%p): Unimplemented!\n", This, dwElementCount, lpData); return DDERR_UNSUPPORTED; } /***************************************************************************** * IDirect3DViewport3::SetBackground * * Sets tje background material * * Params: * hMat: Handle from a IDirect3DMaterial interface * * Returns: * D3D_OK on success * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_SetBackground(IDirect3DViewport3 *iface, D3DMATERIALHANDLE hMat) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; TRACE("(%p)->(%d)\n", This, hMat); EnterCriticalSection(&ddraw_cs); if(hMat && hMat > This->ddraw->d3ddevice->numHandles) { WARN("Specified Handle %d out of range\n", hMat); LeaveCriticalSection(&ddraw_cs); return DDERR_INVALIDPARAMS; } else if(hMat && This->ddraw->d3ddevice->Handles[hMat - 1].type != DDrawHandle_Material) { WARN("Handle %d is not a material handle\n", hMat); LeaveCriticalSection(&ddraw_cs); return DDERR_INVALIDPARAMS; } if(hMat) { This->background = This->ddraw->d3ddevice->Handles[hMat - 1].ptr; TRACE(" setting background color : %f %f %f %f\n", This->background->mat.u.diffuse.u1.r, This->background->mat.u.diffuse.u2.g, This->background->mat.u.diffuse.u3.b, This->background->mat.u.diffuse.u4.a); } else { This->background = NULL; TRACE("Setting background to NULL\n"); } LeaveCriticalSection(&ddraw_cs); return D3D_OK; } /***************************************************************************** * IDirect3DViewport3::GetBackground * * Returns the material handle assigned to the background of the viewport * * Params: * lphMat: Address to store the handle * lpValid: is set to FALSE if no background is set, TRUE if one is set * * Returns: * D3D_OK * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_GetBackground(IDirect3DViewport3 *iface, D3DMATERIALHANDLE *lphMat, BOOL *lpValid) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; TRACE("(%p)->(%p,%p)\n", This, lphMat, lpValid); EnterCriticalSection(&ddraw_cs); if(lpValid) { *lpValid = This->background != NULL; } if(lphMat) { if(This->background) { *lphMat = This->background->Handle; } else { *lphMat = 0; } } LeaveCriticalSection(&ddraw_cs); return D3D_OK; } /***************************************************************************** * IDirect3DViewport3::SetBackgroundDepth * * Sets a surface that represents the background depth. It's contents are * used to set the depth buffer in IDirect3DViewport3::Clear * * Params: * lpDDSurface: Surface to set * * Returns: D3D_OK, because it's a stub * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_SetBackgroundDepth(IDirect3DViewport3 *iface, IDirectDrawSurface *lpDDSurface) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; FIXME("(%p)->(%p): stub!\n", This, lpDDSurface); return D3D_OK; } /***************************************************************************** * IDirect3DViewport3::GetBackgroundDepth * * Returns the surface that represents the depth field * * Params: * lplpDDSurface: Address to store the interface pointer * lpValid: Set to TRUE if a depth is assigned, FALSE otherwise * * Returns: * D3D_OK, because it's a stub * (DDERR_INVALIDPARAMS if DDSurface of Valid is NULL) * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_GetBackgroundDepth(IDirect3DViewport3 *iface, IDirectDrawSurface **lplpDDSurface, LPBOOL lpValid) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; FIXME("(%p)->(%p,%p): stub!\n", This, lplpDDSurface, lpValid); return DD_OK; } /***************************************************************************** * IDirect3DViewport3::Clear * * Clears the render target and / or the z buffer * * Params: * dwCount: The amount of rectangles to clear. If 0, the whole buffer is * cleared * lpRects: Pointer to the array of rectangles. If NULL, Count must be 0 * dwFlags: D3DCLEAR_ZBUFFER and / or D3DCLEAR_TARGET * * Returns: * D3D_OK on success * D3DERR_VIEWPORTHASNODEVICE if there's no active device * The return value of IDirect3DDevice7::Clear * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_Clear(IDirect3DViewport3 *iface, DWORD dwCount, D3DRECT *lpRects, DWORD dwFlags) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; DWORD color = 0x00000000; HRESULT hr; LPDIRECT3DVIEWPORT3 current_viewport; IDirect3DDevice3 *d3d_device3; TRACE("(%p/%p)->(%08x,%p,%08x)\n", This, iface, dwCount, lpRects, dwFlags); if (This->active_device == NULL) { ERR(" Trying to clear a viewport not attached to a device !\n"); return D3DERR_VIEWPORTHASNODEVICE; } d3d_device3 = (IDirect3DDevice3 *)&This->active_device->IDirect3DDevice3_vtbl; EnterCriticalSection(&ddraw_cs); if (dwFlags & D3DCLEAR_TARGET) { if (This->background == NULL) { ERR(" Trying to clear the color buffer without background material !\n"); } else { color = ((int)((This->background->mat.u.diffuse.u1.r) * 255) << 16) | ((int) ((This->background->mat.u.diffuse.u2.g) * 255) << 8) | ((int) ((This->background->mat.u.diffuse.u3.b) * 255) << 0) | ((int) ((This->background->mat.u.diffuse.u4.a) * 255) << 24); } } /* Need to temporarily activate viewport to clear it. Previously active one will be restored afterwards. */ This->activate(This, TRUE); hr = IDirect3DDevice7_Clear((IDirect3DDevice7 *)This->active_device, dwCount, lpRects, dwFlags & (D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET), color, 1.0, 0x00000000); IDirect3DDevice3_GetCurrentViewport(d3d_device3, ¤t_viewport); if(current_viewport) { IDirect3DViewportImpl *vp = (IDirect3DViewportImpl *)current_viewport; vp->activate(vp, TRUE); IDirect3DViewport3_Release(current_viewport); } LeaveCriticalSection(&ddraw_cs); return hr; } /***************************************************************************** * IDirect3DViewport3::AddLight * * Adds an light to the viewport * * Params: * lpDirect3DLight: Interface of the light to add * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS if Direct3DLight is NULL * DDERR_INVALIDPARAMS if there are 8 lights or more * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_AddLight(IDirect3DViewport3 *iface, IDirect3DLight *lpDirect3DLight) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; IDirect3DLightImpl *lpDirect3DLightImpl = (IDirect3DLightImpl *)lpDirect3DLight; DWORD i = 0; DWORD map = This->map_lights; TRACE("(%p)->(%p)\n", This, lpDirect3DLight); EnterCriticalSection(&ddraw_cs); if (This->num_lights >= 8) { LeaveCriticalSection(&ddraw_cs); return DDERR_INVALIDPARAMS; } /* Find a light number and update both light and viewports objects accordingly */ while(map&1) { map>>=1; i++; } lpDirect3DLightImpl->dwLightIndex = i; This->num_lights++; This->map_lights |= 1<next = This->lights; This->lights = lpDirect3DLightImpl; IDirect3DLight_AddRef(lpDirect3DLight); /* Attach the light to the viewport */ lpDirect3DLightImpl->active_viewport = This; /* If active, activate the light */ if (This->active_device != NULL) { lpDirect3DLightImpl->activate(lpDirect3DLightImpl); } LeaveCriticalSection(&ddraw_cs); return D3D_OK; } /***************************************************************************** * IDirect3DViewport3::DeleteLight * * Deletes a light from the viewports' light list * * Params: * lpDirect3DLight: Light to delete * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS if the light wasn't found * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_DeleteLight(IDirect3DViewport3 *iface, IDirect3DLight *lpDirect3DLight) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; IDirect3DLightImpl *lpDirect3DLightImpl = (IDirect3DLightImpl *)lpDirect3DLight; IDirect3DLightImpl *cur_light, *prev_light = NULL; TRACE("(%p)->(%p)\n", This, lpDirect3DLight); EnterCriticalSection(&ddraw_cs); cur_light = This->lights; while (cur_light != NULL) { if (cur_light == lpDirect3DLightImpl) { lpDirect3DLightImpl->desactivate(lpDirect3DLightImpl); if (prev_light == NULL) This->lights = cur_light->next; else prev_light->next = cur_light->next; /* Detach the light to the viewport */ cur_light->active_viewport = NULL; IDirect3DLight_Release( (IDirect3DLight *)cur_light ); This->num_lights--; This->map_lights &= ~(1<dwLightIndex); LeaveCriticalSection(&ddraw_cs); return D3D_OK; } prev_light = cur_light; cur_light = cur_light->next; } LeaveCriticalSection(&ddraw_cs); return DDERR_INVALIDPARAMS; } /***************************************************************************** * IDirect3DViewport::NextLight * * Enumerates the lights associated with the viewport * * Params: * lpDirect3DLight: Light to start with * lplpDirect3DLight: Address to store the successor to * * Returns: * D3D_OK, because it's a stub * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_NextLight(IDirect3DViewport3 *iface, IDirect3DLight *lpDirect3DLight, IDirect3DLight **lplpDirect3DLight, DWORD dwFlags) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; IDirect3DLightImpl *cur_light, *prev_light = NULL; TRACE("(%p)->(%p,%p,%08x)\n", This, lpDirect3DLight, lplpDirect3DLight, dwFlags); if (!lplpDirect3DLight) return DDERR_INVALIDPARAMS; *lplpDirect3DLight = NULL; EnterCriticalSection(&ddraw_cs); cur_light = This->lights; switch (dwFlags) { case D3DNEXT_NEXT: if (!lpDirect3DLight) { LeaveCriticalSection(&ddraw_cs); return DDERR_INVALIDPARAMS; } while (cur_light != NULL) { if (cur_light == (IDirect3DLightImpl *)lpDirect3DLight) { *lplpDirect3DLight = (IDirect3DLight*)cur_light->next; break; } cur_light = cur_light->next; } break; case D3DNEXT_HEAD: *lplpDirect3DLight = (IDirect3DLight*)This->lights; break; case D3DNEXT_TAIL: while (cur_light != NULL) { prev_light = cur_light; cur_light = cur_light->next; } *lplpDirect3DLight = (IDirect3DLight*)prev_light; break; default: ERR("Unknown flag %d\n", dwFlags); break; } if (*lplpDirect3DLight) IDirect3DLight_AddRef(*lplpDirect3DLight); LeaveCriticalSection(&ddraw_cs); return *lplpDirect3DLight ? D3D_OK : DDERR_INVALIDPARAMS; } /***************************************************************************** * IDirect3DViewport2 Methods. *****************************************************************************/ /***************************************************************************** * IDirect3DViewport3::GetViewport2 * * Returns the currently set viewport in a D3DVIEWPORT2 structure. * Similar to IDirect3DViewport3::GetViewport * * Params: * lpData: Pointer to the structure to fill * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS if the viewport was set with * IDirect3DViewport3::SetViewport * DDERR_INVALIDPARAMS if Data is NULL * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_GetViewport2(IDirect3DViewport3 *iface, D3DVIEWPORT2 *lpData) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; DWORD dwSize; TRACE("(%p)->(%p)\n", This, lpData); EnterCriticalSection(&ddraw_cs); dwSize = lpData->dwSize; memset(lpData, 0, dwSize); if (This->use_vp2) memcpy(lpData, &(This->viewports.vp2), dwSize); else { D3DVIEWPORT2 vp2; vp2.dwSize = sizeof(vp2); vp2.dwX = This->viewports.vp1.dwX; vp2.dwY = This->viewports.vp1.dwY; vp2.dwWidth = This->viewports.vp1.dwWidth; vp2.dwHeight = This->viewports.vp1.dwHeight; vp2.dvClipX = 0.0; vp2.dvClipY = 0.0; vp2.dvClipWidth = 0.0; vp2.dvClipHeight = 0.0; vp2.dvMinZ = This->viewports.vp1.dvMinZ; vp2.dvMaxZ = This->viewports.vp1.dvMaxZ; memcpy(lpData, &vp2, dwSize); } if (TRACE_ON(d3d7)) { TRACE(" returning D3DVIEWPORT2 :\n"); _dump_D3DVIEWPORT2(lpData); } LeaveCriticalSection(&ddraw_cs); return D3D_OK; } /***************************************************************************** * IDirect3DViewport3::SetViewport2 * * Sets the viewport from a D3DVIEWPORT2 structure * * Params: * lpData: Viewport to set * * Returns: * D3D_OK on success * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_SetViewport2(IDirect3DViewport3 *iface, D3DVIEWPORT2 *lpData) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; LPDIRECT3DVIEWPORT3 current_viewport; TRACE("(%p/%p)->(%p)\n", This, iface, lpData); if (TRACE_ON(d3d7)) { TRACE(" getting D3DVIEWPORT2 :\n"); _dump_D3DVIEWPORT2(lpData); } EnterCriticalSection(&ddraw_cs); This->use_vp2 = 1; memset(&(This->viewports.vp2), 0, sizeof(This->viewports.vp2)); memcpy(&(This->viewports.vp2), lpData, lpData->dwSize); if (This->active_device) { IDirect3DDevice3 *d3d_device3 = (IDirect3DDevice3 *)&This->active_device->IDirect3DDevice3_vtbl; IDirect3DDevice3_GetCurrentViewport(d3d_device3, ¤t_viewport); if (current_viewport) { if ((IDirect3DViewportImpl *)current_viewport == This) This->activate(This, FALSE); IDirect3DViewport3_Release(current_viewport); } } LeaveCriticalSection(&ddraw_cs); return D3D_OK; } /***************************************************************************** * IDirect3DViewport3 Methods. *****************************************************************************/ /***************************************************************************** * IDirect3DViewport3::SetBackgroundDepth2 * * Sets a IDirectDrawSurface4 surface as the background depth surface * * Params: * lpDDS: Surface to set * * Returns: * D3D_OK, because it's stub * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_SetBackgroundDepth2(IDirect3DViewport3 *iface, IDirectDrawSurface4 *lpDDS) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; FIXME("(%p)->(%p): stub!\n", This, lpDDS); return D3D_OK; } /***************************************************************************** * IDirect3DViewport3::GetBackgroundDepth2 * * Returns the IDirect3DSurface4 interface to the background depth surface * * Params: * lplpDDS: Address to store the interface pointer at * lpValid: Set to true if a surface is assigned * * Returns: * D3D_OK because it's a stub * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_GetBackgroundDepth2(IDirect3DViewport3 *iface, IDirectDrawSurface4 **lplpDDS, BOOL *lpValid) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; FIXME("(%p/%p)->(%p,%p): stub!\n", This, iface, lplpDDS, lpValid); return D3D_OK; } /***************************************************************************** * IDirect3DViewport3::Clear2 * * Another clearing method * * Params: * Count: Number of rectangles to clear * Rects: Rectangle array to clear * Flags: Some flags :) * Color: Color to fill the render target with * Z: Value to fill the depth buffer with * Stencil: Value to fill the stencil bits with * * Returns: * *****************************************************************************/ static HRESULT WINAPI IDirect3DViewportImpl_Clear2(IDirect3DViewport3 *iface, DWORD dwCount, LPD3DRECT lpRects, DWORD dwFlags, DWORD dwColor, D3DVALUE dvZ, DWORD dwStencil) { IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface; HRESULT hr; LPDIRECT3DVIEWPORT3 current_viewport; IDirect3DDevice3 *d3d_device3; TRACE("(%p)->(%08x,%p,%08x,%08x,%f,%08x)\n", This, dwCount, lpRects, dwFlags, dwColor, dvZ, dwStencil); EnterCriticalSection(&ddraw_cs); if (This->active_device == NULL) { ERR(" Trying to clear a viewport not attached to a device !\n"); LeaveCriticalSection(&ddraw_cs); return D3DERR_VIEWPORTHASNODEVICE; } d3d_device3 = (IDirect3DDevice3 *)&This->active_device->IDirect3DDevice3_vtbl; /* Need to temporarily activate viewport to clear it. Previously active one will be restored afterwards. */ This->activate(This, TRUE); hr = IDirect3DDevice7_Clear((IDirect3DDevice7 *)This->active_device, dwCount, lpRects, dwFlags, dwColor, dvZ, dwStencil); IDirect3DDevice3_GetCurrentViewport(d3d_device3, ¤t_viewport); if(current_viewport) { IDirect3DViewportImpl *vp = (IDirect3DViewportImpl *)current_viewport; vp->activate(vp, TRUE); IDirect3DViewport3_Release(current_viewport); } LeaveCriticalSection(&ddraw_cs); return hr; } /***************************************************************************** * The VTable *****************************************************************************/ const IDirect3DViewport3Vtbl IDirect3DViewport3_Vtbl = { /*** IUnknown Methods ***/ IDirect3DViewportImpl_QueryInterface, IDirect3DViewportImpl_AddRef, IDirect3DViewportImpl_Release, /*** IDirect3DViewport Methods */ IDirect3DViewportImpl_Initialize, IDirect3DViewportImpl_GetViewport, IDirect3DViewportImpl_SetViewport, IDirect3DViewportImpl_TransformVertices, IDirect3DViewportImpl_LightElements, IDirect3DViewportImpl_SetBackground, IDirect3DViewportImpl_GetBackground, IDirect3DViewportImpl_SetBackgroundDepth, IDirect3DViewportImpl_GetBackgroundDepth, IDirect3DViewportImpl_Clear, IDirect3DViewportImpl_AddLight, IDirect3DViewportImpl_DeleteLight, IDirect3DViewportImpl_NextLight, /*** IDirect3DViewport2 Methods ***/ IDirect3DViewportImpl_GetViewport2, IDirect3DViewportImpl_SetViewport2, /*** IDirect3DViewport3 Methods ***/ IDirect3DViewportImpl_SetBackgroundDepth2, IDirect3DViewportImpl_GetBackgroundDepth2, IDirect3DViewportImpl_Clear2, };