| /* | |
| * Copyright (c) 2006 Stefan Dösinger | |
| * | |
| * 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 "wine/debug.h" | |
| #include <assert.h> | |
| #include <stdarg.h> | |
| #include <string.h> | |
| #include <stdlib.h> | |
| #define COBJMACROS | |
| #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" | |
| WINE_DEFAULT_DEBUG_CHANNEL(d3d7); | |
| /***************************************************************************** | |
| * IDirect3D7::QueryInterface | |
| * | |
| * QueryInterface implementation with thunks to IDirectDraw7 | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_7_QueryInterface(IDirect3D7 *iface, | |
| REFIID refiid, | |
| void **obj) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d7(iface); | |
| TRACE("(%p)->(%s,%p): Thunking to IDirectDraw7\n", This, debugstr_guid(refiid), obj); | |
| return IDirectDraw7_QueryInterface((IDirectDraw7 *)This, refiid, obj); | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_3_QueryInterface(IDirect3D3 *iface, | |
| REFIID refiid, | |
| void **obj) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| TRACE("(%p)->(%s,%p): Thunking to IDirectDraw7\n", This, debugstr_guid(refiid), obj); | |
| return IDirectDraw7_QueryInterface((IDirectDraw7 *)This, refiid, obj); | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_2_QueryInterface(IDirect3D2 *iface, | |
| REFIID refiid, | |
| void **obj) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| TRACE("(%p)->(%s,%p): Thunking to IDirectDraw7\n", This, debugstr_guid(refiid), obj); | |
| return IDirectDraw7_QueryInterface((IDirectDraw7 *)This, refiid, obj); | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_1_QueryInterface(IDirect3D *iface, | |
| REFIID refiid, | |
| void **obj) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| TRACE("(%p)->(%s,%p): Thunking to IDirectDraw7\n", This, debugstr_guid(refiid), obj); | |
| return IDirectDraw7_QueryInterface((IDirectDraw7 *)This, refiid, obj); | |
| } | |
| /***************************************************************************** | |
| * IDirect3D7::AddRef | |
| * | |
| * DirectDraw refcounting is a bit odd. Every version of the ddraw interface | |
| * has its own refcount, but IDirect3D 1/2/3 refcounts are linked to | |
| * IDirectDraw, and IDirect3D7 is linked to IDirectDraw7 | |
| * | |
| * IDirect3D7 -> IDirectDraw7 | |
| * IDirect3D3 -> IDirectDraw | |
| * IDirect3D2 -> IDirectDraw | |
| * IDirect3D -> IDirectDraw | |
| * | |
| * So every AddRef implementation thunks to a different interface, and the | |
| * IDirectDrawX::AddRef implementations have different counters... | |
| * | |
| * Returns | |
| * The new refcount | |
| * | |
| *****************************************************************************/ | |
| static ULONG WINAPI | |
| Thunk_IDirect3DImpl_7_AddRef(IDirect3D7 *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d7(iface); | |
| TRACE("(%p) : Thunking to IDirectDraw7.\n", This); | |
| return IDirectDraw7_AddRef((IDirectDraw7 *)This); | |
| } | |
| static ULONG WINAPI | |
| Thunk_IDirect3DImpl_3_AddRef(IDirect3D3 *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| TRACE("(%p) : Thunking to IDirectDraw.\n", This); | |
| return IDirectDraw_AddRef((IDirectDraw *)&This->IDirectDraw_vtbl); | |
| } | |
| static ULONG WINAPI | |
| Thunk_IDirect3DImpl_2_AddRef(IDirect3D2 *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| TRACE("(%p) : Thunking to IDirectDraw.\n", This); | |
| return IDirectDraw_AddRef((IDirectDraw *)&This->IDirectDraw_vtbl); | |
| } | |
| static ULONG WINAPI | |
| Thunk_IDirect3DImpl_1_AddRef(IDirect3D *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| TRACE("(%p) : Thunking to IDirectDraw.\n", This); | |
| return IDirectDraw_AddRef((IDirectDraw *)&This->IDirectDraw_vtbl); | |
| } | |
| /***************************************************************************** | |
| * IDirect3D7::Release | |
| * | |
| * Same story as IDirect3D7::AddRef | |
| * | |
| * Returns: The new refcount | |
| * | |
| *****************************************************************************/ | |
| static ULONG WINAPI | |
| Thunk_IDirect3DImpl_7_Release(IDirect3D7 *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d7(iface); | |
| TRACE("(%p) : Thunking to IDirectDraw7.\n", This); | |
| return IDirectDraw7_Release((IDirectDraw7 *)This); | |
| } | |
| static ULONG WINAPI | |
| Thunk_IDirect3DImpl_3_Release(IDirect3D3 *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| TRACE("(%p) : Thunking to IDirectDraw.\n", This); | |
| return IDirectDraw_Release((IDirectDraw *)&This->IDirectDraw_vtbl); | |
| } | |
| static ULONG WINAPI | |
| Thunk_IDirect3DImpl_2_Release(IDirect3D2 *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| TRACE("(%p) : Thunking to IDirectDraw.\n", This); | |
| return IDirectDraw_Release((IDirectDraw *)&This->IDirectDraw_vtbl); | |
| } | |
| static ULONG WINAPI | |
| Thunk_IDirect3DImpl_1_Release(IDirect3D *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| TRACE("(%p) : Thunking to IDirectDraw.\n", This); | |
| return IDirectDraw_Release((IDirectDraw *)&This->IDirectDraw_vtbl); | |
| } | |
| /***************************************************************************** | |
| * IDirect3D Methods | |
| *****************************************************************************/ | |
| /***************************************************************************** | |
| * IDirect3D::Initialize | |
| * | |
| * Initializes the IDirect3D interface. This is a no-op implementation, | |
| * as all initialization is done at create time. | |
| * | |
| * Version 1 | |
| * | |
| * Params: | |
| * refiid: ? | |
| * | |
| * Returns: | |
| * D3D_OK, because it's a no-op | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_1_Initialize(IDirect3D *iface, | |
| REFIID refiid) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| TRACE("(%p)->(%s) no-op...\n", This, debugstr_guid(refiid)); | |
| return D3D_OK; | |
| } | |
| /***************************************************************************** | |
| * IDirect3D7::EnumDevices | |
| * | |
| * The EnumDevices method for IDirect3D7. It enumerates all supported | |
| * D3D7 devices. Currently the T&L, HAL and RGB devices are enumerated. | |
| * | |
| * Params: | |
| * Callback: Function to call for each enumerated device | |
| * Context: Pointer to pass back to the app | |
| * | |
| * Returns: | |
| * D3D_OK, or the return value of the GetCaps call | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_7_EnumDevices(IDirect3D7 *iface, | |
| LPD3DENUMDEVICESCALLBACK7 Callback, | |
| void *Context) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d7(iface); | |
| char interface_name_tnl[] = "WINE Direct3D7 Hardware Transform and Lighting acceleration using WineD3D"; | |
| char device_name_tnl[] = "Wine D3D7 T&L HAL"; | |
| char interface_name_hal[] = "WINE Direct3D7 Hardware acceleration using WineD3D"; | |
| char device_name_hal[] = "Wine D3D7 HAL"; | |
| char interface_name_rgb[] = "WINE Direct3D7 RGB Software Emulation using WineD3D"; | |
| char device_name_rgb[] = "Wine D3D7 RGB"; | |
| D3DDEVICEDESC7 ddesc; | |
| D3DDEVICEDESC oldDesc; | |
| HRESULT hr; | |
| TRACE("(%p)->(%p,%p)\n", This, Callback, Context); | |
| EnterCriticalSection(&ddraw_cs); | |
| TRACE("(%p) Enumerating WineD3D D3Device7 interface\n", This); | |
| hr = IDirect3DImpl_GetCaps(This->wineD3D, &oldDesc, &ddesc); | |
| if(hr != D3D_OK) | |
| { | |
| LeaveCriticalSection(&ddraw_cs); | |
| return hr; | |
| } | |
| Callback(interface_name_tnl, device_name_tnl, &ddesc, Context); | |
| ddesc.deviceGUID = IID_IDirect3DHALDevice; | |
| Callback(interface_name_hal, device_name_hal, &ddesc, Context); | |
| ddesc.deviceGUID = IID_IDirect3DRGBDevice; | |
| Callback(interface_name_rgb, device_name_rgb, &ddesc, Context); | |
| TRACE("(%p) End of enumeration\n", This); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return D3D_OK; | |
| } | |
| /***************************************************************************** | |
| * IDirect3D3::EnumDevices | |
| * | |
| * Enumerates all supported Direct3DDevice interfaces. This is the | |
| * implementation for Direct3D 1 to Direc3D 3, Version 7 has its own. | |
| * | |
| * Version 1, 2 and 3 | |
| * | |
| * Params: | |
| * Callback: Application-provided routine to call for each enumerated device | |
| * Context: Pointer to pass to the callback | |
| * | |
| * Returns: | |
| * D3D_OK on success, | |
| * The result of IDirect3DImpl_GetCaps if it failed | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_3_EnumDevices(IDirect3D3 *iface, | |
| LPD3DENUMDEVICESCALLBACK Callback, | |
| void *Context) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| D3DDEVICEDESC dref, d1, d2; | |
| D3DDEVICEDESC7 newDesc; | |
| static CHAR wined3d_description[] = "Wine D3DDevice using WineD3D and OpenGL"; | |
| HRESULT hr; | |
| /* Some games (Motoracer 2 demo) have the bad idea to modify the device name string. | |
| Let's put the string in a sufficiently sized array in writable memory. */ | |
| char device_name[50]; | |
| strcpy(device_name,"Direct3D HEL"); | |
| TRACE("(%p)->(%p,%p)\n", This, Callback, Context); | |
| EnterCriticalSection(&ddraw_cs); | |
| hr = IDirect3DImpl_GetCaps(This->wineD3D, &dref, &newDesc); | |
| if(hr != D3D_OK) | |
| { | |
| LeaveCriticalSection(&ddraw_cs); | |
| return hr; | |
| } | |
| /* Do I have to enumerate the reference id? Note from old d3d7: | |
| * "It seems that enumerating the reference IID on Direct3D 1 games | |
| * (AvP / Motoracer2) breaks them". So do not enumerate this iid in V1 | |
| * | |
| * There's a registry key HKLM\Software\Microsoft\Direct3D\Drivers, EnumReference | |
| * which enables / disables enumerating the reference rasterizer. It's a DWORD, | |
| * 0 means disabled, 2 means enabled. The enablerefrast.reg and disablerefrast.reg | |
| * files in the DirectX 7.0 sdk demo directory suggest this. | |
| * | |
| * Some games(GTA 2) seem to use the second enumerated device, so I have to enumerate | |
| * at least 2 devices. So enumerate the reference device to have 2 devices. | |
| * | |
| * Other games(Rollcage) tell emulation and hal device apart by certain flags. | |
| * Rollcage expects D3DPTEXTURECAPS_POW2 to be set(yeah, it is a limitation flag), | |
| * and it refuses all devices that have the perspective flag set. This way it refuses | |
| * the emulation device, and HAL devices never have POW2 unset in d3d7 on windows. | |
| */ | |
| if(This->d3dversion != 1) | |
| { | |
| static CHAR reference_description[] = "RGB Direct3D emulation"; | |
| TRACE("(%p) Enumerating WineD3D D3DDevice interface\n", This); | |
| d1 = dref; | |
| d2 = dref; | |
| /* The rgb device has the pow2 flag set in the hel caps, but not in the hal caps */ | |
| d1.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE); | |
| d1.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE); | |
| hr = Callback( (LPIID) &IID_IDirect3DRGBDevice, reference_description, device_name, &d1, &d2, Context); | |
| if(hr != D3DENUMRET_OK) | |
| { | |
| TRACE("Application cancelled the enumeration\n"); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return D3D_OK; | |
| } | |
| } | |
| strcpy(device_name,"Direct3D HAL"); | |
| TRACE("(%p) Enumerating HAL Direct3D device\n", This); | |
| d1 = dref; | |
| d2 = dref; | |
| /* The hal device does not have the pow2 flag set in hel, but in hal */ | |
| d2.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE); | |
| d2.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE); | |
| hr = Callback( (LPIID) &IID_IDirect3DHALDevice, wined3d_description, device_name, &d1, &d2, Context); | |
| if(hr != D3DENUMRET_OK) | |
| { | |
| TRACE("Application cancelled the enumeration\n"); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return D3D_OK; | |
| } | |
| TRACE("(%p) End of enumeration\n", This); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_2_EnumDevices(IDirect3D2 *iface, | |
| LPD3DENUMDEVICESCALLBACK Callback, | |
| void *Context) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Callback, Context); | |
| return IDirect3D3_EnumDevices((IDirect3D3 *)&This->IDirect3D3_vtbl, Callback, Context); | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_1_EnumDevices(IDirect3D *iface, | |
| LPD3DENUMDEVICESCALLBACK Callback, | |
| void *Context) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Callback, Context); | |
| return IDirect3D3_EnumDevices((IDirect3D3 *)&This->IDirect3D3_vtbl, Callback, Context); | |
| } | |
| /***************************************************************************** | |
| * IDirect3D3::CreateLight | |
| * | |
| * Creates an IDirect3DLight interface. This interface is used in | |
| * Direct3D3 or earlier for lighting. In Direct3D7 it has been replaced | |
| * by the DIRECT3DLIGHT7 structure. Wine's Direct3DLight implementation | |
| * uses the IDirect3DDevice7 interface with D3D7 lights. | |
| * | |
| * Version 1, 2 and 3 | |
| * | |
| * Params: | |
| * Light: Address to store the new interface pointer | |
| * UnkOuter: Basically for aggregation, but ddraw doesn't support it. | |
| * Must be NULL | |
| * | |
| * Returns: | |
| * D3D_OK on success | |
| * DDERR_OUTOFMEMORY if memory allocation failed | |
| * CLASS_E_NOAGGREGATION if UnkOuter != NULL | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_3_CreateLight(IDirect3D3 *iface, | |
| IDirect3DLight **Light, | |
| IUnknown *UnkOuter ) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| IDirect3DLightImpl *object; | |
| TRACE("(%p)->(%p,%p)\n", This, Light, UnkOuter); | |
| if(UnkOuter) | |
| return CLASS_E_NOAGGREGATION; | |
| object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DLightImpl)); | |
| if (object == NULL) | |
| return DDERR_OUTOFMEMORY; | |
| object->lpVtbl = &IDirect3DLight_Vtbl; | |
| object->ref = 1; | |
| object->ddraw = This; | |
| object->next = NULL; | |
| object->active_viewport = NULL; | |
| /* Update functions */ | |
| object->activate = light_update; | |
| object->desactivate = light_activate; | |
| object->update = light_desactivate; | |
| object->active_viewport = NULL; | |
| *Light = (IDirect3DLight *)object; | |
| TRACE("(%p) creating implementation at %p.\n", This, object); | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_2_CreateLight(IDirect3D2 *iface, | |
| IDirect3DLight **Direct3DLight, | |
| IUnknown *UnkOuter) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Direct3DLight, UnkOuter); | |
| return IDirect3D3_CreateLight((IDirect3D3 *)&This->IDirect3D3_vtbl, Direct3DLight, UnkOuter); | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_1_CreateLight(IDirect3D *iface, | |
| IDirect3DLight **Direct3DLight, | |
| IUnknown *UnkOuter) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Direct3DLight, UnkOuter); | |
| return IDirect3D3_CreateLight((IDirect3D3 *)&This->IDirect3D3_vtbl, Direct3DLight, UnkOuter); | |
| } | |
| /***************************************************************************** | |
| * IDirect3D3::CreateMaterial | |
| * | |
| * Creates an IDirect3DMaterial interface. This interface is used by Direct3D3 | |
| * and older versions. The IDirect3DMaterial implementation wraps its | |
| * functionality to IDirect3DDevice7::SetMaterial and friends. | |
| * | |
| * Version 1, 2 and 3 | |
| * | |
| * Params: | |
| * Material: Address to store the new interface's pointer to | |
| * UnkOuter: Basically for aggregation, but ddraw doesn't support it. | |
| * Must be NULL | |
| * | |
| * Returns: | |
| * D3D_OK on success | |
| * DDERR_OUTOFMEMORY if memory allocation failed | |
| * CLASS_E_NOAGGREGATION if UnkOuter != NULL | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_3_CreateMaterial(IDirect3D3 *iface, | |
| IDirect3DMaterial3 **Material, | |
| IUnknown *UnkOuter ) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| IDirect3DMaterialImpl *object; | |
| TRACE("(%p)->(%p,%p)\n", This, Material, UnkOuter); | |
| if(UnkOuter) | |
| return CLASS_E_NOAGGREGATION; | |
| object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DMaterialImpl)); | |
| if (object == NULL) | |
| return DDERR_OUTOFMEMORY; | |
| object->lpVtbl = &IDirect3DMaterial3_Vtbl; | |
| object->IDirect3DMaterial2_vtbl = &IDirect3DMaterial2_Vtbl; | |
| object->IDirect3DMaterial_vtbl = &IDirect3DMaterial_Vtbl; | |
| object->ref = 1; | |
| object->ddraw = This; | |
| object->activate = material_activate; | |
| *Material = (IDirect3DMaterial3 *)object; | |
| TRACE("(%p) creating implementation at %p.\n", This, object); | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_2_CreateMaterial(IDirect3D2 *iface, | |
| IDirect3DMaterial2 **Direct3DMaterial, | |
| IUnknown* UnkOuter) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| HRESULT ret; | |
| IDirect3DMaterial3 *ret_val; | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Direct3DMaterial, UnkOuter); | |
| ret = IDirect3D3_CreateMaterial((IDirect3D3 *)&This->IDirect3D3_vtbl, &ret_val, UnkOuter); | |
| *Direct3DMaterial = ret_val ? | |
| (IDirect3DMaterial2 *)&((IDirect3DMaterialImpl *)ret_val)->IDirect3DMaterial2_vtbl : NULL; | |
| TRACE(" returning interface %p.\n", *Direct3DMaterial); | |
| return ret; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_1_CreateMaterial(IDirect3D *iface, | |
| IDirect3DMaterial **Direct3DMaterial, | |
| IUnknown* UnkOuter) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| HRESULT ret; | |
| LPDIRECT3DMATERIAL3 ret_val; | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Direct3DMaterial, UnkOuter); | |
| ret = IDirect3D3_CreateMaterial((IDirect3D3 *)&This->IDirect3D3_vtbl, &ret_val, UnkOuter); | |
| *Direct3DMaterial = ret_val ? | |
| (IDirect3DMaterial *)&((IDirect3DMaterialImpl *)ret_val)->IDirect3DMaterial_vtbl : NULL; | |
| TRACE(" returning interface %p.\n", *Direct3DMaterial); | |
| return ret; | |
| } | |
| /***************************************************************************** | |
| * IDirect3D3::CreateViewport | |
| * | |
| * Creates an IDirect3DViewport interface. This interface is used | |
| * by Direct3D and earlier versions for Viewport management. In Direct3D7 | |
| * it has been replaced by a viewport structure and | |
| * IDirect3DDevice7::*Viewport. Wine's IDirect3DViewport implementation | |
| * uses the IDirect3DDevice7 methods for its functionality | |
| * | |
| * Params: | |
| * Viewport: Address to store the new interface pointer | |
| * UnkOuter: Basically for aggregation, but ddraw doesn't support it. | |
| * Must be NULL | |
| * | |
| * Returns: | |
| * D3D_OK on success | |
| * DDERR_OUTOFMEMORY if memory allocation failed | |
| * CLASS_E_NOAGGREGATION if UnkOuter != NULL | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_3_CreateViewport(IDirect3D3 *iface, | |
| IDirect3DViewport3 **Viewport, | |
| IUnknown *UnkOuter ) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| IDirect3DViewportImpl *object; | |
| if(UnkOuter) | |
| return CLASS_E_NOAGGREGATION; | |
| object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DViewportImpl)); | |
| if (object == NULL) | |
| return DDERR_OUTOFMEMORY; | |
| object->lpVtbl = &IDirect3DViewport3_Vtbl; | |
| object->ref = 1; | |
| object->ddraw = This; | |
| object->activate = viewport_activate; | |
| object->use_vp2 = 0xFF; | |
| object->next = NULL; | |
| object->lights = NULL; | |
| object->num_lights = 0; | |
| object->map_lights = 0; | |
| *Viewport = (IDirect3DViewport3 *)object; | |
| TRACE("(%p) creating implementation at %p.\n",This, object); | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_2_CreateViewport(IDirect3D2 *iface, | |
| IDirect3DViewport2 **D3DViewport2, | |
| IUnknown *UnkOuter) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, D3DViewport2, UnkOuter); | |
| return IDirect3D3_CreateViewport((IDirect3D3 *)&This->IDirect3D3_vtbl, | |
| (IDirect3DViewport3 **) D3DViewport2 /* No need to cast here */, | |
| UnkOuter); | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_1_CreateViewport(IDirect3D *iface, | |
| IDirect3DViewport **D3DViewport, | |
| IUnknown* UnkOuter) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, D3DViewport, UnkOuter); | |
| return IDirect3D3_CreateViewport((IDirect3D3 *)&This->IDirect3D3_vtbl, | |
| (IDirect3DViewport3 **) D3DViewport /* No need to cast here */, | |
| UnkOuter); | |
| } | |
| /***************************************************************************** | |
| * IDirect3D3::FindDevice | |
| * | |
| * This method finds a device with the requested properties and returns a | |
| * device description | |
| * | |
| * Verion 1, 2 and 3 | |
| * Params: | |
| * D3DDFS: Describes the requested device characteristics | |
| * D3DFDR: Returns the device description | |
| * | |
| * Returns: | |
| * D3D_OK on success | |
| * DDERR_INVALIDPARAMS if no device was found | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_3_FindDevice(IDirect3D3 *iface, | |
| D3DFINDDEVICESEARCH *D3DDFS, | |
| D3DFINDDEVICERESULT *D3DFDR) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| D3DDEVICEDESC desc; | |
| D3DDEVICEDESC7 newDesc; | |
| HRESULT hr; | |
| TRACE("(%p)->(%p,%p)\n", This, D3DDFS, D3DFDR); | |
| if ((D3DDFS->dwFlags & D3DFDS_COLORMODEL) && | |
| (D3DDFS->dcmColorModel != D3DCOLOR_RGB)) | |
| { | |
| TRACE(" trying to request a non-RGB D3D color model. Not supported.\n"); | |
| return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */ | |
| } | |
| if (D3DDFS->dwFlags & D3DFDS_GUID) | |
| { | |
| TRACE(" trying to match guid %s.\n", debugstr_guid(&(D3DDFS->guid))); | |
| if ((IsEqualGUID(&IID_D3DDEVICE_WineD3D, &(D3DDFS->guid)) == 0) && | |
| (IsEqualGUID(&IID_IDirect3DHALDevice, &(D3DDFS->guid)) == 0) && | |
| (IsEqualGUID(&IID_IDirect3DRefDevice, &(D3DDFS->guid)) == 0)) | |
| { | |
| TRACE(" no match for this GUID.\n"); | |
| return DDERR_INVALIDPARAMS; | |
| } | |
| } | |
| /* Get the caps */ | |
| hr = IDirect3DImpl_GetCaps(This->wineD3D, &desc, &newDesc); | |
| if(hr != D3D_OK) return hr; | |
| /* Now return our own GUID */ | |
| D3DFDR->guid = IID_D3DDEVICE_WineD3D; | |
| D3DFDR->ddHwDesc = desc; | |
| D3DFDR->ddSwDesc = desc; | |
| TRACE(" returning Wine's WineD3D device with (undumped) capabilities\n"); | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_2_FindDevice(IDirect3D2 *iface, | |
| D3DFINDDEVICESEARCH *D3DDFS, | |
| D3DFINDDEVICERESULT *D3DFDR) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", iface, D3DDFS, D3DFDR); | |
| return IDirect3D3_FindDevice((IDirect3D3 *)&This->IDirect3D3_vtbl, D3DDFS, D3DFDR); | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_1_FindDevice(IDirect3D *iface, | |
| D3DFINDDEVICESEARCH *D3DDFS, | |
| D3DFINDDEVICERESULT *D3DDevice) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d1(iface); | |
| TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, D3DDFS, D3DDevice); | |
| return IDirect3D3_FindDevice((IDirect3D3 *)&This->IDirect3D3_vtbl, D3DDFS, D3DDevice); | |
| } | |
| /***************************************************************************** | |
| * IDirect3D7::CreateDevice | |
| * | |
| * Creates an IDirect3DDevice7 interface. | |
| * | |
| * Version 2, 3 and 7. IDirect3DDevice 1 interfaces are interfaces to | |
| * DirectDraw surfaces and are created with | |
| * IDirectDrawSurface::QueryInterface. This method uses CreateDevice to | |
| * create the device object and QueryInterfaces for IDirect3DDevice | |
| * | |
| * Params: | |
| * refiid: IID of the device to create | |
| * Surface: Initial rendertarget | |
| * Device: Address to return the interface pointer | |
| * | |
| * Returns: | |
| * D3D_OK on success | |
| * DDERR_OUTOFMEMORY if memory allocation failed | |
| * DDERR_INVALIDPARAMS if a device exists already | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_7_CreateDevice(IDirect3D7 *iface, | |
| REFCLSID refiid, | |
| IDirectDrawSurface7 *Surface, | |
| IDirect3DDevice7 **Device) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d7(iface); | |
| IDirect3DDeviceImpl *object; | |
| IParentImpl *IndexBufferParent; | |
| HRESULT hr; | |
| IDirectDrawSurfaceImpl *target = (IDirectDrawSurfaceImpl *)Surface; | |
| TRACE("(%p)->(%s,%p,%p)\n", iface, debugstr_guid(refiid), Surface, Device); | |
| EnterCriticalSection(&ddraw_cs); | |
| *Device = NULL; | |
| /* Fail device creation if non-opengl surfaces are used */ | |
| if(This->ImplType != SURFACE_OPENGL) | |
| { | |
| ERR("The application wants to create a Direct3D device, but non-opengl surfaces are set in the registry. Please set the surface implementation to opengl or autodetection to allow 3D rendering\n"); | |
| /* We only hit this path if a default surface is set in the registry. Incorrect autodetection | |
| * is caught in CreateSurface or QueryInterface | |
| */ | |
| LeaveCriticalSection(&ddraw_cs); | |
| return DDERR_NO3D; | |
| } | |
| /* So far we can only create one device per ddraw object */ | |
| if(This->d3ddevice) | |
| { | |
| FIXME("(%p): Only one Direct3D device per DirectDraw object supported\n", This); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return DDERR_INVALIDPARAMS; | |
| } | |
| object = HeapAlloc(GetProcessHeap(), 0, sizeof(IDirect3DDeviceImpl)); | |
| if(!object) | |
| { | |
| ERR("Out of memory when allocating a IDirect3DDevice implementation\n"); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return DDERR_OUTOFMEMORY; | |
| } | |
| if (This->cooperative_level & DDSCL_FPUPRESERVE) | |
| object->lpVtbl = &IDirect3DDevice7_FPUPreserve_Vtbl; | |
| else | |
| object->lpVtbl = &IDirect3DDevice7_FPUSetup_Vtbl; | |
| object->IDirect3DDevice3_vtbl = &IDirect3DDevice3_Vtbl; | |
| object->IDirect3DDevice2_vtbl = &IDirect3DDevice2_Vtbl; | |
| object->IDirect3DDevice_vtbl = &IDirect3DDevice1_Vtbl; | |
| object->ref = 1; | |
| object->ddraw = This; | |
| object->viewport_list = NULL; | |
| object->current_viewport = NULL; | |
| object->material = 0; | |
| object->target = target; | |
| object->Handles = NULL; | |
| object->numHandles = 0; | |
| object->legacyTextureBlending = FALSE; | |
| /* This is for convenience */ | |
| object->wineD3DDevice = This->wineD3DDevice; | |
| /* Create an index buffer, it's needed for indexed drawing */ | |
| IndexBufferParent = HeapAlloc(GetProcessHeap(), 0, sizeof(IParentImpl)); | |
| if(!IndexBufferParent) | |
| { | |
| ERR("Allocating memory for an index buffer parent failed\n"); | |
| HeapFree(GetProcessHeap(), 0, object); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return DDERR_OUTOFMEMORY; | |
| } | |
| IndexBufferParent->lpVtbl = &IParent_Vtbl; | |
| IndexBufferParent->ref = 1; | |
| /* Create an Index Buffer. WineD3D needs one for Drawing indexed primitives | |
| * Create a (hopefully) long enough buffer, and copy the indices into it | |
| * Ideally, a IWineD3DBuffer::SetData method could be created, which | |
| * takes the pointer and avoids the memcpy | |
| */ | |
| hr = IWineD3DDevice_CreateIndexBuffer(This->wineD3DDevice, 0x40000 /* Length. Don't know how long it should be */, | |
| WINED3DUSAGE_DYNAMIC /* Usage */, WINED3DPOOL_DEFAULT, &object->indexbuffer, (IUnknown *)IndexBufferParent, | |
| &ddraw_null_wined3d_parent_ops); | |
| if(FAILED(hr)) | |
| { | |
| ERR("Failed to create an index buffer\n"); | |
| HeapFree(GetProcessHeap(), 0, object); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return hr; | |
| } | |
| IndexBufferParent->child = (IUnknown *) object->indexbuffer; | |
| /* No need to set the indices, it's done when necessary */ | |
| /* AddRef the WineD3D Device */ | |
| IWineD3DDevice_AddRef(This->wineD3DDevice); | |
| /* Don't forget to return the interface ;) */ | |
| *Device = (IDirect3DDevice7 *)object; | |
| TRACE(" (%p) Created an IDirect3DDeviceImpl object at %p\n", This, object); | |
| /* This is for apps which create a non-flip, non-d3d primary surface | |
| * and an offscreen D3DDEVICE surface, then render to the offscreen surface | |
| * and do a Blt from the offscreen to the primary surface. | |
| * | |
| * Set the offscreen D3DDDEVICE surface(=target) as the back buffer, | |
| * and the primary surface(=This->d3d_target) as the front buffer. | |
| * | |
| * This way the app will render to the D3DDEVICE surface and WineD3D | |
| * will catch the Blt was Back Buffer -> Front buffer blt and perform | |
| * a flip instead. This way we don't have to deal with a mixed GL / GDI | |
| * environment. | |
| * | |
| * This should be checked against windowed apps. The only app tested with | |
| * this is moto racer 2 during the loading screen. | |
| */ | |
| TRACE("Isrendertarget: %s, d3d_target=%p\n", target->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE ? "true" : "false", This->d3d_target); | |
| if(!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) && | |
| (This->d3d_target != target)) | |
| { | |
| TRACE("(%p) Using %p as front buffer, %p as back buffer\n", This, This->d3d_target, target); | |
| hr = IWineD3DDevice_SetFrontBackBuffers(This->wineD3DDevice, | |
| This->d3d_target->WineD3DSurface, | |
| target->WineD3DSurface); | |
| if(hr != D3D_OK) | |
| ERR("(%p) Error %08x setting the front and back buffer\n", This, hr); | |
| /* Render to the back buffer */ | |
| IWineD3DDevice_SetRenderTarget(This->wineD3DDevice, 0, | |
| target->WineD3DSurface, | |
| TRUE); | |
| object->OffScreenTarget = TRUE; | |
| } | |
| else | |
| { | |
| object->OffScreenTarget = FALSE; | |
| } | |
| /* AddRef the render target. Also AddRef the render target from ddraw, | |
| * because if it is released before the app releases the D3D device, the D3D capabilities | |
| * of WineD3D will be uninitialized, which has bad effects. | |
| * | |
| * In most cases, those surfaces are the surfaces are the same anyway, but this will simply | |
| * add another ref which is released when the device is destroyed. | |
| */ | |
| IDirectDrawSurface7_AddRef(Surface); | |
| IDirectDrawSurface7_AddRef((IDirectDrawSurface7 *)This->d3d_target); | |
| This->d3ddevice = object; | |
| IWineD3DDevice_SetRenderState(This->wineD3DDevice, | |
| WINED3DRS_ZENABLE, | |
| IDirect3DDeviceImpl_UpdateDepthStencil(object)); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_3_CreateDevice(IDirect3D3 *iface, | |
| REFCLSID refiid, | |
| IDirectDrawSurface4 *Surface, | |
| IDirect3DDevice3 **Device, | |
| IUnknown *UnkOuter) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| HRESULT hr; | |
| TRACE("(%p)->(%s,%p,%p,%p): Thunking to IDirect3D7\n", This, debugstr_guid(refiid), Surface, Device, UnkOuter); | |
| if(UnkOuter != NULL) | |
| return CLASS_E_NOAGGREGATION; | |
| hr = IDirect3D7_CreateDevice((IDirect3D7 *)&This->IDirect3D7_vtbl, refiid, | |
| (IDirectDrawSurface7 *)Surface /* Same VTables */, (IDirect3DDevice7 **)Device); | |
| *Device = *Device ? (IDirect3DDevice3 *)&((IDirect3DDeviceImpl *)*Device)->IDirect3DDevice3_vtbl : NULL; | |
| return hr; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_2_CreateDevice(IDirect3D2 *iface, | |
| REFCLSID refiid, | |
| IDirectDrawSurface *Surface, | |
| IDirect3DDevice2 **Device) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d2(iface); | |
| HRESULT hr; | |
| TRACE("(%p)->(%s,%p,%p): Thunking to IDirect3D7\n", This, debugstr_guid(refiid), Surface, Device); | |
| hr = IDirect3D7_CreateDevice((IDirect3D7 *)&This->IDirect3D7_vtbl, refiid, | |
| Surface ? (IDirectDrawSurface7 *)surface_from_surface3((IDirectDrawSurface3 *)Surface) : NULL, | |
| (IDirect3DDevice7 **)Device); | |
| *Device = *Device ? (IDirect3DDevice2 *)&((IDirect3DDeviceImpl *)*Device)->IDirect3DDevice2_vtbl : NULL; | |
| return hr; | |
| } | |
| /***************************************************************************** | |
| * IDirect3D7::CreateVertexBuffer | |
| * | |
| * Creates a new vertex buffer object and returns a IDirect3DVertexBuffer7 | |
| * interface. | |
| * | |
| * Version 3 and 7 | |
| * | |
| * Params: | |
| * Desc: Requested Vertex buffer properties | |
| * VertexBuffer: Address to return the interface pointer at | |
| * Flags: Some flags, must be 0 | |
| * | |
| * Returns | |
| * D3D_OK on success | |
| * DDERR_OUTOFMEMORY if memory allocation failed | |
| * The return value of IWineD3DDevice::CreateVertexBuffer if this call fails | |
| * DDERR_INVALIDPARAMS if Desc or VertexBuffer are NULL, or Flags != 0 | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_7_CreateVertexBuffer(IDirect3D7 *iface, | |
| D3DVERTEXBUFFERDESC *Desc, | |
| IDirect3DVertexBuffer7 **VertexBuffer, | |
| DWORD Flags) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d7(iface); | |
| IDirect3DVertexBufferImpl *object; | |
| HRESULT hr; | |
| DWORD usage; | |
| TRACE("(%p)->(%p,%p,%08x)\n", This, Desc, VertexBuffer, Flags); | |
| TRACE("(%p) Vertex buffer description:\n", This); | |
| TRACE("(%p) dwSize=%d\n", This, Desc->dwSize); | |
| TRACE("(%p) dwCaps=%08x\n", This, Desc->dwCaps); | |
| TRACE("(%p) FVF=%08x\n", This, Desc->dwFVF); | |
| TRACE("(%p) dwNumVertices=%d\n", This, Desc->dwNumVertices); | |
| /* D3D7 SDK: "No Flags are currently defined for this method. This | |
| * parameter must be 0" | |
| * | |
| * Never trust the documentation - this is wrong | |
| if(Flags != 0) | |
| { | |
| ERR("(%p) Flags is %08lx, returning DDERR_INVALIDPARAMS\n", This, Flags); | |
| return DDERR_INVALIDPARAMS; | |
| } | |
| */ | |
| /* Well, this sounds sane */ | |
| if( (!VertexBuffer) || (!Desc) ) | |
| return DDERR_INVALIDPARAMS; | |
| /* Now create the vertex buffer */ | |
| object = HeapAlloc(GetProcessHeap(), 0, sizeof(IDirect3DVertexBufferImpl)); | |
| if(!object) | |
| { | |
| ERR("(%p) Out of memory when allocating a IDirect3DVertexBufferImpl structure\n", This); | |
| return DDERR_OUTOFMEMORY; | |
| } | |
| object->ref = 1; | |
| object->lpVtbl = &IDirect3DVertexBuffer7_Vtbl; | |
| object->IDirect3DVertexBuffer_vtbl = &IDirect3DVertexBuffer1_Vtbl; | |
| object->Caps = Desc->dwCaps; | |
| object->ddraw = This; | |
| object->fvf = Desc->dwFVF; | |
| usage = Desc->dwCaps & D3DVBCAPS_WRITEONLY ? WINED3DUSAGE_WRITEONLY : 0; | |
| usage |= WINED3DUSAGE_STATICDECL; | |
| EnterCriticalSection(&ddraw_cs); | |
| hr = IWineD3DDevice_CreateVertexBuffer(This->wineD3DDevice, | |
| get_flexible_vertex_size(Desc->dwFVF) * Desc->dwNumVertices, | |
| usage, Desc->dwCaps & D3DVBCAPS_SYSTEMMEMORY ? WINED3DPOOL_SYSTEMMEM : WINED3DPOOL_DEFAULT, | |
| &object->wineD3DVertexBuffer, (IUnknown *)object, &ddraw_null_wined3d_parent_ops); | |
| if(hr != D3D_OK) | |
| { | |
| ERR("(%p) IWineD3DDevice::CreateVertexBuffer failed with hr=%08x\n", This, hr); | |
| HeapFree(GetProcessHeap(), 0, object); | |
| LeaveCriticalSection(&ddraw_cs); | |
| if (hr == WINED3DERR_INVALIDCALL) | |
| return DDERR_INVALIDPARAMS; | |
| else | |
| return hr; | |
| } | |
| object->wineD3DVertexDeclaration = IDirectDrawImpl_FindDecl(This, | |
| Desc->dwFVF); | |
| if(!object->wineD3DVertexDeclaration) | |
| { | |
| ERR("Cannot find the vertex declaration for fvf %08x\n", Desc->dwFVF); | |
| IWineD3DBuffer_Release(object->wineD3DVertexBuffer); | |
| HeapFree(GetProcessHeap(), 0, object); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return DDERR_INVALIDPARAMS; | |
| } | |
| IWineD3DVertexDeclaration_AddRef(object->wineD3DVertexDeclaration); | |
| /* Return the interface */ | |
| *VertexBuffer = (IDirect3DVertexBuffer7 *)object; | |
| TRACE("(%p) Created new vertex buffer implementation at %p, returning interface at %p\n", This, object, *VertexBuffer); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_3_CreateVertexBuffer(IDirect3D3 *iface, | |
| D3DVERTEXBUFFERDESC *Desc, | |
| IDirect3DVertexBuffer **VertexBuffer, | |
| DWORD Flags, | |
| IUnknown *UnkOuter) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| HRESULT hr; | |
| TRACE("(%p)->(%p,%p,%08x,%p): Relaying to IDirect3D7\n", This, Desc, VertexBuffer, Flags, UnkOuter); | |
| if(UnkOuter != NULL) return CLASS_E_NOAGGREGATION; | |
| hr = IDirect3D7_CreateVertexBuffer((IDirect3D7 *)&This->IDirect3D7_vtbl, | |
| Desc, (IDirect3DVertexBuffer7 **)VertexBuffer, Flags); | |
| *VertexBuffer = *VertexBuffer ? | |
| (IDirect3DVertexBuffer *)&((IDirect3DVertexBufferImpl *)*VertexBuffer)->IDirect3DVertexBuffer_vtbl : NULL; | |
| return hr; | |
| } | |
| /***************************************************************************** | |
| * IDirect3D7::EnumZBufferFormats | |
| * | |
| * Enumerates all supported Z buffer pixel formats | |
| * | |
| * Version 3 and 7 | |
| * | |
| * Params: | |
| * refiidDevice: | |
| * Callback: Callback to call for each pixel format | |
| * Context: Pointer to pass back to the callback | |
| * | |
| * Returns: | |
| * D3D_OK on success | |
| * DDERR_INVALIDPARAMS if Callback is NULL | |
| * For details, see IWineD3DDevice::EnumZBufferFormats | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_7_EnumZBufferFormats(IDirect3D7 *iface, | |
| REFCLSID refiidDevice, | |
| LPD3DENUMPIXELFORMATSCALLBACK Callback, | |
| void *Context) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d7(iface); | |
| HRESULT hr; | |
| unsigned int i; | |
| WINED3DDISPLAYMODE d3ddm; | |
| WINED3DDEVTYPE type; | |
| /* Order matters. Specifically, BattleZone II (full version) expects the | |
| * 16-bit depth formats to be listed before the 24 and 32 ones. */ | |
| WINED3DFORMAT FormatList[] = { | |
| WINED3DFMT_S1_UINT_D15_UNORM, | |
| WINED3DFMT_D16_UNORM, | |
| WINED3DFMT_X8D24_UNORM, | |
| WINED3DFMT_S4X4_UINT_D24_UNORM, | |
| WINED3DFMT_D24_UNORM_S8_UINT, | |
| WINED3DFMT_D32_UNORM, | |
| }; | |
| TRACE("(%p)->(%s,%p,%p): Relay\n", iface, debugstr_guid(refiidDevice), Callback, Context); | |
| if(!Callback) | |
| return DDERR_INVALIDPARAMS; | |
| if(IsEqualGUID(refiidDevice, &IID_IDirect3DHALDevice) || | |
| IsEqualGUID(refiidDevice, &IID_IDirect3DTnLHalDevice) || | |
| IsEqualGUID(refiidDevice, &IID_D3DDEVICE_WineD3D)) | |
| { | |
| TRACE("Asked for HAL device\n"); | |
| type = WINED3DDEVTYPE_HAL; | |
| } | |
| else if(IsEqualGUID(refiidDevice, &IID_IDirect3DRGBDevice) || | |
| IsEqualGUID(refiidDevice, &IID_IDirect3DMMXDevice)) | |
| { | |
| TRACE("Asked for SW device\n"); | |
| type = WINED3DDEVTYPE_SW; | |
| } | |
| else if(IsEqualGUID(refiidDevice, &IID_IDirect3DRefDevice)) | |
| { | |
| TRACE("Asked for REF device\n"); | |
| type = WINED3DDEVTYPE_REF; | |
| } | |
| else if(IsEqualGUID(refiidDevice, &IID_IDirect3DNullDevice)) | |
| { | |
| TRACE("Asked for NULLREF device\n"); | |
| type = WINED3DDEVTYPE_NULLREF; | |
| } | |
| else | |
| { | |
| FIXME("Unexpected device GUID %s\n", debugstr_guid(refiidDevice)); | |
| type = WINED3DDEVTYPE_HAL; | |
| } | |
| EnterCriticalSection(&ddraw_cs); | |
| /* We need an adapter format from somewhere to please wined3d and WGL. Use the current display mode. | |
| * So far all cards offer the same depth stencil format for all modes, but if some do not and apps | |
| * do not like that we'll have to find some workaround, like iterating over all imaginable formats | |
| * and collecting all the depth stencil formats we can get | |
| */ | |
| hr = IWineD3DDevice_GetDisplayMode(This->wineD3DDevice, | |
| 0 /* swapchain 0 */, | |
| &d3ddm); | |
| for(i = 0; i < (sizeof(FormatList) / sizeof(FormatList[0])); i++) | |
| { | |
| hr = IWineD3D_CheckDeviceFormat(This->wineD3D, | |
| WINED3DADAPTER_DEFAULT /* Adapter */, | |
| type /* DeviceType */, | |
| d3ddm.Format /* AdapterFormat */, | |
| WINED3DUSAGE_DEPTHSTENCIL /* Usage */, | |
| WINED3DRTYPE_SURFACE, | |
| FormatList[i], | |
| SURFACE_OPENGL); | |
| if(hr == D3D_OK) | |
| { | |
| DDPIXELFORMAT pformat; | |
| memset(&pformat, 0, sizeof(pformat)); | |
| pformat.dwSize = sizeof(pformat); | |
| PixelFormat_WineD3DtoDD(&pformat, FormatList[i]); | |
| TRACE("Enumerating WineD3DFormat %d\n", FormatList[i]); | |
| hr = Callback(&pformat, Context); | |
| if(hr != DDENUMRET_OK) | |
| { | |
| TRACE("Format enumeration cancelled by application\n"); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return D3D_OK; | |
| } | |
| } | |
| } | |
| TRACE("End of enumeration\n"); | |
| LeaveCriticalSection(&ddraw_cs); | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_3_EnumZBufferFormats(IDirect3D3 *iface, | |
| REFCLSID riidDevice, | |
| LPD3DENUMPIXELFORMATSCALLBACK Callback, | |
| void *Context) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| TRACE("(%p)->(%s,%p,%p) thunking to IDirect3D7 interface.\n", This, debugstr_guid(riidDevice), Callback, Context); | |
| return IDirect3D7_EnumZBufferFormats((IDirect3D7 *)&This->IDirect3D7_vtbl, riidDevice, Callback, Context); | |
| } | |
| /***************************************************************************** | |
| * IDirect3D7::EvictManagedTextures | |
| * | |
| * Removes all managed textures (=surfaces with DDSCAPS2_TEXTUREMANAGE or | |
| * DDSCAPS2_D3DTEXTUREMANAGE caps) to be removed from video memory. | |
| * | |
| * Version 3 and 7 | |
| * | |
| * Returns: | |
| * D3D_OK, because it's a stub | |
| * | |
| *****************************************************************************/ | |
| static HRESULT WINAPI | |
| IDirect3DImpl_7_EvictManagedTextures(IDirect3D7 *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d7(iface); | |
| FIXME("(%p): Stub!\n", This); | |
| /* Implementation idea: | |
| * Add an IWineD3DSurface method which sets the opengl texture | |
| * priority low or even removes the opengl texture. | |
| */ | |
| return D3D_OK; | |
| } | |
| static HRESULT WINAPI | |
| Thunk_IDirect3DImpl_3_EvictManagedTextures(IDirect3D3 *iface) | |
| { | |
| IDirectDrawImpl *This = ddraw_from_d3d3(iface); | |
| TRACE("(%p)->() thunking to IDirect3D7 interface.\n", This); | |
| return IDirect3D7_EvictManagedTextures((IDirect3D7 *)&This->IDirect3D7_vtbl); | |
| } | |
| /***************************************************************************** | |
| * IDirect3DImpl_GetCaps | |
| * | |
| * This function retrieves the device caps from wined3d | |
| * and converts it into a D3D7 and D3D - D3D3 structure | |
| * This is a helper function called from various places in ddraw | |
| * | |
| * Params: | |
| * WineD3D: The interface to get the caps from | |
| * Desc123: Old D3D <3 structure to fill (needed) | |
| * Desc7: D3D7 device desc structure to fill (needed) | |
| * | |
| * Returns | |
| * D3D_OK on success, or the return value of IWineD3D::GetCaps | |
| * | |
| *****************************************************************************/ | |
| HRESULT | |
| IDirect3DImpl_GetCaps(IWineD3D *WineD3D, | |
| D3DDEVICEDESC *Desc123, | |
| D3DDEVICEDESC7 *Desc7) | |
| { | |
| WINED3DCAPS WCaps; | |
| HRESULT hr; | |
| /* Some variables to assign to the pointers in WCaps */ | |
| TRACE("()->(%p,%p,%p\n", WineD3D, Desc123, Desc7); | |
| memset(&WCaps, 0, sizeof(WCaps)); | |
| EnterCriticalSection(&ddraw_cs); | |
| hr = IWineD3D_GetDeviceCaps(WineD3D, 0, WINED3DDEVTYPE_HAL, &WCaps); | |
| LeaveCriticalSection(&ddraw_cs); | |
| if(hr != D3D_OK) | |
| { | |
| return hr; | |
| } | |
| /* Copy the results into the d3d7 and d3d3 structures */ | |
| Desc7->dwDevCaps = WCaps.DevCaps; | |
| Desc7->dpcLineCaps.dwRasterCaps = WCaps.RasterCaps; | |
| Desc7->dpcLineCaps.dwZCmpCaps = WCaps.ZCmpCaps; | |
| Desc7->dpcLineCaps.dwSrcBlendCaps = WCaps.SrcBlendCaps; | |
| Desc7->dpcLineCaps.dwDestBlendCaps = WCaps.DestBlendCaps; | |
| Desc7->dpcLineCaps.dwAlphaCmpCaps = WCaps.AlphaCmpCaps; | |
| Desc7->dpcLineCaps.dwShadeCaps = WCaps.ShadeCaps; | |
| Desc7->dpcLineCaps.dwTextureCaps = WCaps.TextureCaps; | |
| Desc7->dpcLineCaps.dwTextureFilterCaps = WCaps.TextureFilterCaps; | |
| Desc7->dpcLineCaps.dwTextureAddressCaps = WCaps.TextureAddressCaps; | |
| Desc7->dwMaxTextureWidth = WCaps.MaxTextureWidth; | |
| Desc7->dwMaxTextureHeight = WCaps.MaxTextureHeight; | |
| Desc7->dwMaxTextureRepeat = WCaps.MaxTextureRepeat; | |
| Desc7->dwMaxTextureAspectRatio = WCaps.MaxTextureAspectRatio; | |
| Desc7->dwMaxAnisotropy = WCaps.MaxAnisotropy; | |
| Desc7->dvMaxVertexW = WCaps.MaxVertexW; | |
| Desc7->dvGuardBandLeft = WCaps.GuardBandLeft; | |
| Desc7->dvGuardBandTop = WCaps.GuardBandTop; | |
| Desc7->dvGuardBandRight = WCaps.GuardBandRight; | |
| Desc7->dvGuardBandBottom = WCaps.GuardBandBottom; | |
| Desc7->dvExtentsAdjust = WCaps.ExtentsAdjust; | |
| Desc7->dwStencilCaps = WCaps.StencilCaps; | |
| Desc7->dwFVFCaps = WCaps.FVFCaps; | |
| Desc7->dwTextureOpCaps = WCaps.TextureOpCaps; | |
| Desc7->dwVertexProcessingCaps = WCaps.VertexProcessingCaps; | |
| Desc7->dwMaxActiveLights = WCaps.MaxActiveLights; | |
| /* Remove all non-d3d7 caps */ | |
| Desc7->dwDevCaps &= ( | |
| D3DDEVCAPS_FLOATTLVERTEX | D3DDEVCAPS_SORTINCREASINGZ | D3DDEVCAPS_SORTDECREASINGZ | | |
| D3DDEVCAPS_SORTEXACT | D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY | | |
| D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | D3DDEVCAPS_TLVERTEXVIDEOMEMORY | D3DDEVCAPS_TEXTURESYSTEMMEMORY | | |
| D3DDEVCAPS_TEXTUREVIDEOMEMORY | D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_CANRENDERAFTERFLIP | | |
| D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_DRAWPRIMITIVES2 | D3DDEVCAPS_SEPARATETEXTUREMEMORIES | | |
| D3DDEVCAPS_DRAWPRIMITIVES2EX | D3DDEVCAPS_HWTRANSFORMANDLIGHT | D3DDEVCAPS_CANBLTSYSTONONLOCAL | | |
| D3DDEVCAPS_HWRASTERIZATION); | |
| Desc7->dwStencilCaps &= ( | |
| D3DSTENCILCAPS_KEEP | D3DSTENCILCAPS_ZERO | D3DSTENCILCAPS_REPLACE | | |
| D3DSTENCILCAPS_INCRSAT | D3DSTENCILCAPS_DECRSAT | D3DSTENCILCAPS_INVERT | | |
| D3DSTENCILCAPS_INCR | D3DSTENCILCAPS_DECR); | |
| /* FVF caps ?*/ | |
| Desc7->dwTextureOpCaps &= ( | |
| D3DTEXOPCAPS_DISABLE | D3DTEXOPCAPS_SELECTARG1 | D3DTEXOPCAPS_SELECTARG2 | | |
| D3DTEXOPCAPS_MODULATE | D3DTEXOPCAPS_MODULATE2X | D3DTEXOPCAPS_MODULATE4X | | |
| D3DTEXOPCAPS_ADD | D3DTEXOPCAPS_ADDSIGNED | D3DTEXOPCAPS_ADDSIGNED2X | | |
| D3DTEXOPCAPS_SUBTRACT | D3DTEXOPCAPS_ADDSMOOTH | D3DTEXOPCAPS_BLENDTEXTUREALPHA | | |
| D3DTEXOPCAPS_BLENDFACTORALPHA | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM | D3DTEXOPCAPS_BLENDCURRENTALPHA | | |
| D3DTEXOPCAPS_PREMODULATE | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA | | |
| D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP | | |
| D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3); | |
| Desc7->dwVertexProcessingCaps &= ( | |
| D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_VERTEXFOG | | |
| D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER); | |
| Desc7->dpcLineCaps.dwMiscCaps &= ( | |
| D3DPMISCCAPS_MASKPLANES | D3DPMISCCAPS_MASKZ | D3DPMISCCAPS_LINEPATTERNREP | | |
| D3DPMISCCAPS_CONFORMANT | D3DPMISCCAPS_CULLNONE | D3DPMISCCAPS_CULLCW | | |
| D3DPMISCCAPS_CULLCCW); | |
| Desc7->dpcLineCaps.dwRasterCaps &= ( | |
| D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_ROP2 | D3DPRASTERCAPS_XOR | | |
| D3DPRASTERCAPS_PAT | D3DPRASTERCAPS_ZTEST | D3DPRASTERCAPS_SUBPIXEL | | |
| D3DPRASTERCAPS_SUBPIXELX | D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_FOGTABLE | | |
| D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT | D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT | | |
| D3DPRASTERCAPS_ANTIALIASEDGES | D3DPRASTERCAPS_MIPMAPLODBIAS | D3DPRASTERCAPS_ZBIAS | | |
| D3DPRASTERCAPS_ZBUFFERLESSHSR | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_ANISOTROPY | | |
| D3DPRASTERCAPS_WBUFFER | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG | | |
| D3DPRASTERCAPS_ZFOG); | |
| Desc7->dpcLineCaps.dwZCmpCaps &= ( | |
| D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL | | |
| D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL | | |
| D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS); | |
| Desc7->dpcLineCaps.dwSrcBlendCaps &= ( | |
| D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR | | |
| D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA | | |
| D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR | | |
| D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA | | |
| D3DPBLENDCAPS_BOTHINVSRCALPHA); | |
| Desc7->dpcLineCaps.dwDestBlendCaps &= ( | |
| D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR | | |
| D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA | | |
| D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR | | |
| D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA | | |
| D3DPBLENDCAPS_BOTHINVSRCALPHA); | |
| Desc7->dpcLineCaps.dwAlphaCmpCaps &= ( | |
| D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL | | |
| D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL | | |
| D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS); | |
| Desc7->dpcLineCaps.dwShadeCaps &= ( | |
| D3DPSHADECAPS_COLORFLATMONO | D3DPSHADECAPS_COLORFLATRGB | D3DPSHADECAPS_COLORGOURAUDMONO | | |
| D3DPSHADECAPS_COLORGOURAUDRGB | D3DPSHADECAPS_COLORPHONGMONO | D3DPSHADECAPS_COLORPHONGRGB | | |
| D3DPSHADECAPS_SPECULARFLATMONO | D3DPSHADECAPS_SPECULARFLATRGB | D3DPSHADECAPS_SPECULARGOURAUDMONO | | |
| D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_SPECULARPHONGMONO | D3DPSHADECAPS_SPECULARPHONGRGB | | |
| D3DPSHADECAPS_ALPHAFLATBLEND | D3DPSHADECAPS_ALPHAFLATSTIPPLED | D3DPSHADECAPS_ALPHAGOURAUDBLEND | | |
| D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED | D3DPSHADECAPS_ALPHAPHONGBLEND | D3DPSHADECAPS_ALPHAPHONGSTIPPLED | | |
| D3DPSHADECAPS_FOGFLAT | D3DPSHADECAPS_FOGGOURAUD | D3DPSHADECAPS_FOGPHONG); | |
| Desc7->dpcLineCaps.dwTextureCaps &= ( | |
| D3DPTEXTURECAPS_PERSPECTIVE | D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_ALPHA | | |
| D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_BORDER | D3DPTEXTURECAPS_SQUAREONLY | | |
| D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | D3DPTEXTURECAPS_ALPHAPALETTE| D3DPTEXTURECAPS_NONPOW2CONDITIONAL | | |
| D3DPTEXTURECAPS_PROJECTED | D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_COLORKEYBLEND); | |
| Desc7->dpcLineCaps.dwTextureFilterCaps &= ( | |
| D3DPTFILTERCAPS_NEAREST | D3DPTFILTERCAPS_LINEAR | D3DPTFILTERCAPS_MIPNEAREST | | |
| D3DPTFILTERCAPS_MIPLINEAR | D3DPTFILTERCAPS_LINEARMIPNEAREST | D3DPTFILTERCAPS_LINEARMIPLINEAR | | |
| D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MINFANISOTROPIC | | |
| D3DPTFILTERCAPS_MIPFPOINT | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | | |
| D3DPTFILTERCAPS_MAGFLINEAR | D3DPTFILTERCAPS_MAGFANISOTROPIC | D3DPTFILTERCAPS_MAGFAFLATCUBIC | | |
| D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC); | |
| Desc7->dpcLineCaps.dwTextureBlendCaps &= ( | |
| D3DPTBLENDCAPS_DECAL | D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_DECALALPHA | | |
| D3DPTBLENDCAPS_MODULATEALPHA | D3DPTBLENDCAPS_DECALMASK | D3DPTBLENDCAPS_MODULATEMASK | | |
| D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_ADD); | |
| Desc7->dpcLineCaps.dwTextureAddressCaps &= ( | |
| D3DPTADDRESSCAPS_WRAP | D3DPTADDRESSCAPS_MIRROR | D3DPTADDRESSCAPS_CLAMP | | |
| D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_INDEPENDENTUV); | |
| if(!(Desc7->dpcLineCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2)) { | |
| /* DirectX7 always has the np2 flag set, no matter what the card supports. Some old games(rollcage) | |
| * check the caps incorrectly. If wined3d supports nonpow2 textures it also has np2 conditional support | |
| */ | |
| Desc7->dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL; | |
| } | |
| /* Fill the missing members, and do some fixup */ | |
| Desc7->dpcLineCaps.dwSize = sizeof(Desc7->dpcLineCaps); | |
| Desc7->dpcLineCaps.dwTextureBlendCaps = D3DPTBLENDCAPS_ADD | D3DPTBLENDCAPS_MODULATEMASK | | |
| D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_DECAL | | |
| D3DPTBLENDCAPS_DECALALPHA | D3DPTBLENDCAPS_DECALMASK | | |
| D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_MODULATEALPHA; | |
| Desc7->dpcLineCaps.dwStippleWidth = 32; | |
| Desc7->dpcLineCaps.dwStippleHeight = 32; | |
| /* Use the same for the TriCaps */ | |
| Desc7->dpcTriCaps = Desc7->dpcLineCaps; | |
| Desc7->dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32; | |
| Desc7->dwDeviceZBufferBitDepth = DDBD_16 | DDBD_24; | |
| Desc7->dwMinTextureWidth = 1; | |
| Desc7->dwMinTextureHeight = 1; | |
| /* Convert DWORDs safely to WORDs */ | |
| if(WCaps.MaxTextureBlendStages > 65535) Desc7->wMaxTextureBlendStages = 65535; | |
| else Desc7->wMaxTextureBlendStages = (WORD) WCaps.MaxTextureBlendStages; | |
| if(WCaps.MaxSimultaneousTextures > 65535) Desc7->wMaxSimultaneousTextures = 65535; | |
| else Desc7->wMaxSimultaneousTextures = (WORD) WCaps.MaxSimultaneousTextures; | |
| if(WCaps.MaxUserClipPlanes > 65535) Desc7->wMaxUserClipPlanes = 65535; | |
| else Desc7->wMaxUserClipPlanes = (WORD) WCaps.MaxUserClipPlanes; | |
| if(WCaps.MaxVertexBlendMatrices > 65535) Desc7->wMaxVertexBlendMatrices = 65535; | |
| else Desc7->wMaxVertexBlendMatrices = (WORD) WCaps.MaxVertexBlendMatrices; | |
| Desc7->deviceGUID = IID_IDirect3DTnLHalDevice; | |
| Desc7->dwReserved1 = 0; | |
| Desc7->dwReserved2 = 0; | |
| Desc7->dwReserved3 = 0; | |
| Desc7->dwReserved4 = 0; | |
| /* Fill the old structure */ | |
| memset(Desc123, 0x0, sizeof(D3DDEVICEDESC)); | |
| Desc123->dwSize = sizeof(D3DDEVICEDESC); | |
| Desc123->dwFlags = D3DDD_COLORMODEL | | |
| D3DDD_DEVCAPS | | |
| D3DDD_TRANSFORMCAPS | | |
| D3DDD_BCLIPPING | | |
| D3DDD_LIGHTINGCAPS | | |
| D3DDD_LINECAPS | | |
| D3DDD_TRICAPS | | |
| D3DDD_DEVICERENDERBITDEPTH | | |
| D3DDD_DEVICEZBUFFERBITDEPTH | | |
| D3DDD_MAXBUFFERSIZE | | |
| D3DDD_MAXVERTEXCOUNT; | |
| Desc123->dcmColorModel = D3DCOLOR_RGB; | |
| Desc123->dwDevCaps = Desc7->dwDevCaps; | |
| Desc123->dtcTransformCaps.dwSize = sizeof(D3DTRANSFORMCAPS); | |
| Desc123->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP; | |
| Desc123->bClipping = TRUE; | |
| Desc123->dlcLightingCaps.dwSize = sizeof(D3DLIGHTINGCAPS); | |
| Desc123->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL | D3DLIGHTCAPS_PARALLELPOINT | D3DLIGHTCAPS_POINT | D3DLIGHTCAPS_SPOT; | |
| Desc123->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB; | |
| Desc123->dlcLightingCaps.dwNumLights = Desc7->dwMaxActiveLights; | |
| Desc123->dpcLineCaps.dwSize = sizeof(D3DPRIMCAPS); | |
| Desc123->dpcLineCaps.dwMiscCaps = Desc7->dpcLineCaps.dwMiscCaps; | |
| Desc123->dpcLineCaps.dwRasterCaps = Desc7->dpcLineCaps.dwRasterCaps; | |
| Desc123->dpcLineCaps.dwZCmpCaps = Desc7->dpcLineCaps.dwZCmpCaps; | |
| Desc123->dpcLineCaps.dwSrcBlendCaps = Desc7->dpcLineCaps.dwSrcBlendCaps; | |
| Desc123->dpcLineCaps.dwDestBlendCaps = Desc7->dpcLineCaps.dwDestBlendCaps; | |
| Desc123->dpcLineCaps.dwShadeCaps = Desc7->dpcLineCaps.dwShadeCaps; | |
| Desc123->dpcLineCaps.dwTextureCaps = Desc7->dpcLineCaps.dwTextureCaps; | |
| Desc123->dpcLineCaps.dwTextureFilterCaps = Desc7->dpcLineCaps.dwTextureFilterCaps; | |
| Desc123->dpcLineCaps.dwTextureBlendCaps = Desc7->dpcLineCaps.dwTextureBlendCaps; | |
| Desc123->dpcLineCaps.dwTextureAddressCaps = Desc7->dpcLineCaps.dwTextureAddressCaps; | |
| Desc123->dpcLineCaps.dwStippleWidth = Desc7->dpcLineCaps.dwStippleWidth; | |
| Desc123->dpcLineCaps.dwAlphaCmpCaps = Desc7->dpcLineCaps.dwAlphaCmpCaps; | |
| Desc123->dpcTriCaps.dwSize = sizeof(D3DPRIMCAPS); | |
| Desc123->dpcTriCaps.dwMiscCaps = Desc7->dpcTriCaps.dwMiscCaps; | |
| Desc123->dpcTriCaps.dwRasterCaps = Desc7->dpcTriCaps.dwRasterCaps; | |
| Desc123->dpcTriCaps.dwZCmpCaps = Desc7->dpcTriCaps.dwZCmpCaps; | |
| Desc123->dpcTriCaps.dwSrcBlendCaps = Desc7->dpcTriCaps.dwSrcBlendCaps; | |
| Desc123->dpcTriCaps.dwDestBlendCaps = Desc7->dpcTriCaps.dwDestBlendCaps; | |
| Desc123->dpcTriCaps.dwShadeCaps = Desc7->dpcTriCaps.dwShadeCaps; | |
| Desc123->dpcTriCaps.dwTextureCaps = Desc7->dpcTriCaps.dwTextureCaps; | |
| Desc123->dpcTriCaps.dwTextureFilterCaps = Desc7->dpcTriCaps.dwTextureFilterCaps; | |
| Desc123->dpcTriCaps.dwTextureBlendCaps = Desc7->dpcTriCaps.dwTextureBlendCaps; | |
| Desc123->dpcTriCaps.dwTextureAddressCaps = Desc7->dpcTriCaps.dwTextureAddressCaps; | |
| Desc123->dpcTriCaps.dwStippleWidth = Desc7->dpcTriCaps.dwStippleWidth; | |
| Desc123->dpcTriCaps.dwAlphaCmpCaps = Desc7->dpcTriCaps.dwAlphaCmpCaps; | |
| Desc123->dwDeviceRenderBitDepth = Desc7->dwDeviceRenderBitDepth; | |
| Desc123->dwDeviceZBufferBitDepth = Desc7->dwDeviceZBufferBitDepth; | |
| Desc123->dwMaxBufferSize = 0; | |
| Desc123->dwMaxVertexCount = 65536; | |
| Desc123->dwMinTextureWidth = Desc7->dwMinTextureWidth; | |
| Desc123->dwMinTextureHeight = Desc7->dwMinTextureHeight; | |
| Desc123->dwMaxTextureWidth = Desc7->dwMaxTextureWidth; | |
| Desc123->dwMaxTextureHeight = Desc7->dwMaxTextureHeight; | |
| Desc123->dwMinStippleWidth = 1; | |
| Desc123->dwMinStippleHeight = 1; | |
| Desc123->dwMaxStippleWidth = 32; | |
| Desc123->dwMaxStippleHeight = 32; | |
| Desc123->dwMaxTextureRepeat = Desc7->dwMaxTextureRepeat; | |
| Desc123->dwMaxTextureAspectRatio = Desc7->dwMaxTextureAspectRatio; | |
| Desc123->dwMaxAnisotropy = Desc7->dwMaxAnisotropy; | |
| Desc123->dvGuardBandLeft = Desc7->dvGuardBandLeft; | |
| Desc123->dvGuardBandRight = Desc7->dvGuardBandRight; | |
| Desc123->dvGuardBandTop = Desc7->dvGuardBandTop; | |
| Desc123->dvGuardBandBottom = Desc7->dvGuardBandBottom; | |
| Desc123->dvExtentsAdjust = Desc7->dvExtentsAdjust; | |
| Desc123->dwStencilCaps = Desc7->dwStencilCaps; | |
| Desc123->dwFVFCaps = Desc7->dwFVFCaps; | |
| Desc123->dwTextureOpCaps = Desc7->dwTextureOpCaps; | |
| Desc123->wMaxTextureBlendStages = Desc7->wMaxTextureBlendStages; | |
| Desc123->wMaxSimultaneousTextures = Desc7->wMaxSimultaneousTextures; | |
| return DD_OK; | |
| } | |
| /***************************************************************************** | |
| * IDirect3D vtables in various versions | |
| *****************************************************************************/ | |
| const IDirect3DVtbl IDirect3D1_Vtbl = | |
| { | |
| /*** IUnknown methods ***/ | |
| Thunk_IDirect3DImpl_1_QueryInterface, | |
| Thunk_IDirect3DImpl_1_AddRef, | |
| Thunk_IDirect3DImpl_1_Release, | |
| /*** IDirect3D methods ***/ | |
| IDirect3DImpl_1_Initialize, | |
| Thunk_IDirect3DImpl_1_EnumDevices, | |
| Thunk_IDirect3DImpl_1_CreateLight, | |
| Thunk_IDirect3DImpl_1_CreateMaterial, | |
| Thunk_IDirect3DImpl_1_CreateViewport, | |
| Thunk_IDirect3DImpl_1_FindDevice | |
| }; | |
| const IDirect3D2Vtbl IDirect3D2_Vtbl = | |
| { | |
| /*** IUnknown methods ***/ | |
| Thunk_IDirect3DImpl_2_QueryInterface, | |
| Thunk_IDirect3DImpl_2_AddRef, | |
| Thunk_IDirect3DImpl_2_Release, | |
| /*** IDirect3D2 methods ***/ | |
| Thunk_IDirect3DImpl_2_EnumDevices, | |
| Thunk_IDirect3DImpl_2_CreateLight, | |
| Thunk_IDirect3DImpl_2_CreateMaterial, | |
| Thunk_IDirect3DImpl_2_CreateViewport, | |
| Thunk_IDirect3DImpl_2_FindDevice, | |
| Thunk_IDirect3DImpl_2_CreateDevice | |
| }; | |
| const IDirect3D3Vtbl IDirect3D3_Vtbl = | |
| { | |
| /*** IUnknown methods ***/ | |
| Thunk_IDirect3DImpl_3_QueryInterface, | |
| Thunk_IDirect3DImpl_3_AddRef, | |
| Thunk_IDirect3DImpl_3_Release, | |
| /*** IDirect3D3 methods ***/ | |
| IDirect3DImpl_3_EnumDevices, | |
| IDirect3DImpl_3_CreateLight, | |
| IDirect3DImpl_3_CreateMaterial, | |
| IDirect3DImpl_3_CreateViewport, | |
| IDirect3DImpl_3_FindDevice, | |
| Thunk_IDirect3DImpl_3_CreateDevice, | |
| Thunk_IDirect3DImpl_3_CreateVertexBuffer, | |
| Thunk_IDirect3DImpl_3_EnumZBufferFormats, | |
| Thunk_IDirect3DImpl_3_EvictManagedTextures | |
| }; | |
| const IDirect3D7Vtbl IDirect3D7_Vtbl = | |
| { | |
| /*** IUnknown methods ***/ | |
| Thunk_IDirect3DImpl_7_QueryInterface, | |
| Thunk_IDirect3DImpl_7_AddRef, | |
| Thunk_IDirect3DImpl_7_Release, | |
| /*** IDirect3D7 methods ***/ | |
| IDirect3DImpl_7_EnumDevices, | |
| IDirect3DImpl_7_CreateDevice, | |
| IDirect3DImpl_7_CreateVertexBuffer, | |
| IDirect3DImpl_7_EnumZBufferFormats, | |
| IDirect3DImpl_7_EvictManagedTextures | |
| }; |