VirtualBox

Changeset 39570 in vbox for trunk/src/VBox/Additions


Ignore:
Timestamp:
Dec 9, 2011 2:02:53 PM (13 years ago)
Author:
vboxsync
Message:

wine: IDirect3D9Impl_QueryInterface fix, getd3dcaps9 fix, debug tooling

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Wine
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/Makefile.kmk

    r39252 r39570  
    176176    $(PATH_STAGE_LIB)/libWine$(VBOX_SUFF_LIB)
    177177wined3d_SDKS.amd64    = WINDDKWLH
     178ifdef VBOX_WINE_WITH_IPRT
     179wined3d_LIBS         += \
     180                                                        $(VBOX_LIB_IPRT_GUEST_R3) \
     181                                                        $(VBOX_LIB_VBGL_R3)
     182wined3d_DEFS         += VBOX_WINE_WITH_IPRT
     183endif
    178184
    179185ifdef VBOX_WITH_WDDM
    … …  
    195201wined3dwddm_SDKS.amd64     = $(NO_SUCH_VARIABLE)
    196202#VBOX_WINE_WITH_IPRT is used for debugging currently to enable Assert & stuff
    197 ifdef VBOX_WINE_WITH_IPRT
    198 wined3dwddm_LIBS          += \
    199                                                         $(VBOX_LIB_IPRT_GUEST_R3) \
    200                                                         $(VBOX_LIB_VBGL_R3)
    201 wined3dwddm_DEFS          += VBOX_WINE_WITH_IPRT
    202 endif
     203#ifdef VBOX_WINE_WITH_IPRT
     204#wined3dwddm_LIBS          += \
     205                                                        $(VBOX_LIB_IPRT_GUEST_R3) \
     206                                                        $(VBOX_LIB_VBGL_R3)
     207#wined3dwddm_DEFS          += VBOX_WINE_WITH_IPRT
     208#endif
    203209wined3dwddm_DEFS          += VBOX_WINE_WITH_SINGLE_CONTEXT
    204210
    … …  
    253259VBoxD3D8_SOURCES.amd64 = vbox/libWineStub/debug.c
    254260VBoxD3D8_SDKS.amd64    = WINDDKWLH
     261ifdef VBOX_WINE_WITH_IPRT
     262VBoxD3D8_LIBS         += \
     263                                                        $(VBOX_LIB_IPRT_GUEST_R3) \
     264                                                        $(VBOX_LIB_VBGL_R3)
     265VBoxD3D8_DEFS         += VBOX_WINE_WITH_IPRT
     266endif
    255267
    256268DLLS += VBoxD3D9
    … …  
    300312    $(PATH_STAGE_LIB)/wined3d$(VBOX_SUFF_LIB)
    301313VBoxD3D9_SDKS.amd64    = WINDDKWLH
     314ifdef VBOX_WINE_WITH_IPRT
     315VBoxD3D9_LIBS         += \
     316                                                        $(VBOX_LIB_IPRT_GUEST_R3) \
     317                                                        $(VBOX_LIB_VBGL_R3)
     318VBoxD3D9_DEFS         += VBOX_WINE_WITH_IPRT
     319endif
    302320
    303321ifdef VBOX_WITH_WDDM
    … …  
    315333VBoxD3D9wddm_SOURCES.x86    = $(NO_SUCH_VARIABLE)
    316334VBoxD3D9wddm_SOURCES.amd64  = $(NO_SUCH_VARIABLE)
    317 VBoxD3D9wddm_LIBS           = $(PATH_STAGE_LIB)/wined3dwddm$(VBOX_SUFF_LIB)
     335VBoxD3D9wddm_LIBS           = $(subst $(PATH_STAGE_LIB)/wined3d$(VBOX_SUFF_LIB),$(PATH_STAGE_LIB)/wined3dwddm$(VBOX_SUFF_LIB),$(VBoxD3D9_LIBS))
    318336VBoxD3D9wddm_LIBS.x86       = $(NO_SUCH_VARIABLE)
    319337VBoxD3D9wddm_SDKS           = WINDDKWLH
    320338VBoxD3D9wddm_SDKS.amd64     = $(NO_SUCH_VARIABLE)
    321 ifdef VBOX_WINE_WITH_IPRT
    322 VBoxD3D9wddm_LIBS          += \
    323                                                         $(VBOX_LIB_IPRT_GUEST_R3) \
    324                                                         $(VBOX_LIB_VBGL_R3)
    325 VBoxD3D9wddm_DEFS          += VBOX_WINE_WITH_IPRT
    326 endif
     339#ifdef VBOX_WINE_WITH_IPRT
     340#VBoxD3D9wddm_LIBS          += \
     341                                                        $(VBOX_LIB_IPRT_GUEST_R3) \
     342                                                        $(VBOX_LIB_VBGL_R3)
     343#VBoxD3D9wddm_DEFS          += VBOX_WINE_WITH_IPRT
     344#endif
    327345
    328346DLLS.amd64 += VBoxD3D9wddm-x86
    … …  
    348366    switcher/d3d8.rc
    349367d3d8_SDKS.amd64    = WINDDKWLH
     368ifdef VBOX_WINE_WITH_IPRT
     369d3d8_LIBS         += \
     370                                                        $(VBOX_LIB_IPRT_GUEST_R3) \
     371                                                        $(VBOX_LIB_VBGL_R3)
     372d3d8_DEFS         += VBOX_WINE_WITH_IPRT
     373endif
    350374
    351375DLLS += d3d9
    … …  
    362386    switcher/sw_d3d9xpdm.def
    363387d3d9_SDKS.amd64    = WINDDKWLH
    364 
     388ifdef VBOX_WINE_WITH_IPRT
     389d3d9_LIBS         += \
     390                                                        $(VBOX_LIB_IPRT_GUEST_R3) \
     391                                                        $(VBOX_LIB_VBGL_R3)
     392d3d9_DEFS         += VBOX_WINE_WITH_IPRT
     393endif
    365394
    366395include $(KBUILD_PATH)/subfooter.kmk

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d8/d3d8_main.c

    r33656 r39570  
    2828 * of the LGPL is applied is otherwise unspecified.
    2929 */
     30#define VBOX_WINE_DEBUG_DEFINES
    3031
    3132#include "config.h"

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9_main.c

    r39539 r39570  
    3030 * of the LGPL is applied is otherwise unspecified.
    3131 */
     32#define VBOX_WINE_DEBUG_DEFINES
    3233
    3334#include "config.h"

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/device.c

    r38982 r39570  
    233233            IDirect3D9_Release(d3d);
    234234            *ppobj = NULL;
     235            ERR_D3D();
    235236            return E_NOINTERFACE;
    236237        }
    … …  
    246247    WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
    247248    *ppobj = NULL;
     249    ERR_D3D();
    248250    return E_NOINTERFACE;
    249251}
    … …  
    302304    {
    303305        TRACE("D3D9 device is marked not reset.\n");
     306        ERR_D3D();
    304307        return D3DERR_DEVICENOTRESET;
    305308    }
    … …  
    318321    wined3d_mutex_unlock();
    319322
     323    ASSERT_D3D(hr > 0x400000);
    320324    return hr;
    321325}
    … …  
    331335    wined3d_mutex_unlock();
    332336
     337    ASSERT_D3D(hr == S_OK);
    333338    return hr;
    334339}
    … …  
    342347
    343348    if (NULL == ppD3D9) {
     349        ERR_D3D();
    344350        return D3DERR_INVALIDCALL;
    345351    }
    … …  
    358364    wined3d_mutex_unlock();
    359365
     366    ASSERT_D3D(hr == S_OK);
    360367    return hr;
    361368}
    … …  
    369376
    370377    if(NULL == pCaps){
     378        ERR_D3D();
    371379        return D3DERR_INVALIDCALL;
    372380    }
    373381    pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS));
    374382    if(pWineCaps == NULL){
     383        ERR_D3D();
    375384        return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */
    376385    }
    … …  
    391400
    392401    TRACE("Returning %p %p\n", This, pCaps);
     402    ASSERT_D3D(hrc == S_OK);
    393403    return hrc;
    394404}
    … …  
    406416    if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
    407417
     418    ASSERT_D3D(hr == S_OK);
    408419    return hr;
    409420}
    … …  
    419430    wined3d_mutex_unlock();
    420431
     432    ASSERT_D3D(hr == S_OK);
    421433    return hr;
    422434}
    … …  
    432444    if(!pCursorBitmap) {
    433445        WARN("No cursor bitmap, returning WINED3DERR_INVALIDCALL\n");
     446        ERR_D3D();
    434447        return WINED3DERR_INVALIDCALL;
    435448    }
    … …  
    439452    wined3d_mutex_unlock();
    440453
     454    ASSERT_D3D(hr == S_OK);
    441455    return hr;
    442456}
    … …  
    619633        wined3d_mutex_unlock();
    620634
     635        ERR_D3D();
    621636        return WINED3DERR_INVALIDCALL;
    622637    }
    … …  
    662677    wined3d_mutex_unlock();
    663678
     679    ASSERT_D3D(hr == S_OK);
    664680    return hr;
    665681}
    … …  
    677693    wined3d_mutex_unlock();
    678694
     695    ASSERT_D3D(hr == S_OK);
    679696    return hr;
    680697 }
    … …  
    696713    wined3d_mutex_unlock();
    697714
     715    ASSERT_D3D(rc == S_OK);
    698716    return rc;
    699717}
    … …  
    708726    wined3d_mutex_unlock();
    709727
     728    ASSERT_D3D(hr == S_OK);
    710729    return hr;
    711730}
    … …  
    721740    wined3d_mutex_unlock();
    722741
     742    ASSERT_D3D(hr == S_OK);
    723743    return hr;
    724744}
    … …  
    866886    {
    867887        ERR("Failed to allocate texture memory.\n");
     888        ERR_D3D();
    868889        return D3DERR_OUTOFVIDEOMEMORY;
    869890    }
    … …  
    874895        WARN("Failed to initialize texture, hr %#x.\n", hr);
    875896        HeapFree(GetProcessHeap(), 0, object);
     897        ERR_D3D();
    876898        return hr;
    877899    }
    … …  
    901923    {
    902924        ERR("Failed to allocate volume texture memory.\n");
     925        ERR_D3D();
    903926        return D3DERR_OUTOFVIDEOMEMORY;
    904927    }
    … …  
    907930    if (FAILED(hr))
    908931    {
     932        ERR_D3D();
    909933        WARN("Failed to initialize volume texture, hr %#x.\n", hr);
    910934        HeapFree(GetProcessHeap(), 0, object);
    … …  
    937961    {
    938962        ERR("Failed to allocate cube texture memory.\n");
     963        ERR_D3D();
    939964        return D3DERR_OUTOFVIDEOMEMORY;
    940965    }
    … …  
    943968    if (FAILED(hr))
    944969    {
     970        ERR_D3D();
    945971        WARN("Failed to initialize cube texture, hr %#x.\n", hr);
    946972        HeapFree(GetProcessHeap(), 0, object);
    … …  
    968994    if (!object)
    969995    {
     996        ERR_D3D();
    970997        ERR("Failed to allocate buffer memory.\n");
    971998        return D3DERR_OUTOFVIDEOMEMORY;
    … …  
    9751002    if (FAILED(hr))
    9761003    {
     1004        ERR_D3D();
    9771005        WARN("Failed to initialize vertex buffer, hr %#x.\n", hr);
    9781006        HeapFree(GetProcessHeap(), 0, object);
    … …  
    9991027    if (!object)
    10001028    {
     1029        ERR_D3D();
    10011030        ERR("Failed to allocate buffer memory.\n");
    10021031        return D3DERR_OUTOFVIDEOMEMORY;
    … …  
    10061035    if (FAILED(hr))
    10071036    {
     1037        ERR_D3D();
    10081038        WARN("Failed to initialize index buffer, hr %#x.\n", hr);
    10091039        HeapFree(GetProcessHeap(), 0, object);
    … …  
    10381068    if (!object)
    10391069    {
     1070        ERR_D3D();
    10401071        FIXME("Failed to allocate surface memory.\n");
    10411072        return D3DERR_OUTOFVIDEOMEMORY;
    … …  
    10511082    if (FAILED(hr))
    10521083    {
     1084        ERR_D3D();
    10531085        WARN("Failed to initialize surface, hr %#x.\n", hr);
    10541086        HeapFree(GetProcessHeap(), 0, object);
    … …  
    10811113            );
    10821114
     1115    ASSERT_D3D(hr == S_OK);
    10831116    return hr;
    10841117}
    … …  
    11031136            );
    11041137
     1138    ASSERT_D3D(hr == S_OK);
    11051139    return hr;
    11061140}
    … …  
    11181152    wined3d_mutex_unlock();
    11191153
     1154    ASSERT_D3D(hr == S_OK);
    11201155    return hr;
    11211156}
    … …  
    11311166    wined3d_mutex_unlock();
    11321167
     1168    ASSERT_D3D(hr == S_OK);
    11331169    return hr;
    11341170}
    … …  
    11471183    wined3d_mutex_unlock();
    11481184
     1185    ASSERT_D3D(hr == S_OK);
    11491186    return hr;
    11501187}
    … …  
    11611198    wined3d_mutex_unlock();
    11621199
     1200    ASSERT_D3D(hr == S_OK);
    11631201    return hr;
    11641202}
    … …  
    11781216    wined3d_mutex_unlock();
    11791217
     1218    ASSERT_D3D(hr == S_OK);
    11801219    return hr;
    11811220}
    … …  
    12051244        wined3d_mutex_unlock();
    12061245        WARN("Surface is not a render target, or not a stand-alone D3DPOOL_DEFAULT surface\n");
     1246        ERR_D3D();
    12071247        return D3DERR_INVALIDCALL;
    12081248    }
    … …  
    12141254    wined3d_mutex_unlock();
    12151255
     1256    ASSERT_D3D(hr == S_OK);
    12161257    return hr;
    12171258}
    … …  
    12241265
    12251266    if(Pool == D3DPOOL_MANAGED ){
     1267        ERR_D3D();
    12261268        FIXME("Attempting to create a managed offscreen plain surface\n");
    12271269        return D3DERR_INVALIDCALL;
    … …  
    12431285            );
    12441286
     1287    ASSERT_D3D(hr == S_OK);
    12451288    return hr;
    12461289}
    … …  
    12561299    if (RenderTargetIndex >= D3D9_MAX_SIMULTANEOUS_RENDERTARGETS)
    12571300    {
     1301        ERR_D3D();
    12581302        WARN("Invalid index %u specified.\n", RenderTargetIndex);
    12591303        return D3DERR_INVALIDCALL;
    … …  
    12641308    wined3d_mutex_unlock();
    12651309
     1310    ASSERT_D3D(hr == S_OK);
    12661311    return hr;
    12671312}
    … …  
    12751320
    12761321    if (ppRenderTarget == NULL) {
     1322        ERR_D3D();
    12771323        return D3DERR_INVALIDCALL;
    12781324    }
    … …  
    12801326    if (RenderTargetIndex >= D3D9_MAX_SIMULTANEOUS_RENDERTARGETS)
    12811327    {
     1328        ERR_D3D();
    12821329        WARN("Invalid index %u specified.\n", RenderTargetIndex);
    12831330        return D3DERR_INVALIDCALL;
    … …  
    13041351    wined3d_mutex_unlock();
    13051352
     1353    ASSERT_D3D(hr == S_OK);
    13061354    return hr;
    13071355}
    … …  
    13291377    wined3d_mutex_unlock();
    13301378
     1379    ASSERT_D3D(hr == S_OK);
    13311380    return hr;
    13321381}
    … …  
    13401389
    13411390    if(ppZStencilSurface == NULL){
     1391        ERR_D3D();
    13421392        return D3DERR_INVALIDCALL;
    13431393    }
    … …  
    13551405    wined3d_mutex_unlock();
    13561406
     1407    ASSERT_D3D(hr == S_OK);
    13571408    return hr;
    13581409}
    … …  
    13681419    wined3d_mutex_unlock();
    13691420
     1421    ASSERT_D3D(hr == S_OK);
    13701422    return hr;
    13711423}
    … …  
    13811433    wined3d_mutex_unlock();
    13821434
     1435    ASSERT_D3D(hr == S_OK);
    13831436    return hr;
    13841437}
    … …  
    13961449    wined3d_mutex_unlock();
    13971450
     1451    ASSERT_D3D(hr == S_OK);
    13981452    return hr;
    13991453}
    … …  
    14241478    wined3d_mutex_unlock();
    14251479
     1480    ASSERT_D3D(hr == S_OK);
    14261481    return hr;
    14271482}
    … …  
    14381493    wined3d_mutex_unlock();
    14391494
     1495    ASSERT_D3D(hr == S_OK);
    14401496    return hr;
    14411497}
    … …  
    14521508    wined3d_mutex_unlock();
    14531509
     1510    ASSERT_D3D(hr == S_OK);
     1511
    14541512    return hr;
    14551513}
    … …  
    14661524    wined3d_mutex_unlock();
    14671525
     1526    ASSERT_D3D(hr == S_OK);
    14681527    return hr;
    14691528}
    … …  
    14801539    wined3d_mutex_unlock();
    14811540
     1541    ASSERT_D3D(hr == S_OK);
    14821542    return hr;
    14831543}
    … …  
    14941554    wined3d_mutex_unlock();
    14951555
     1556    ASSERT_D3D(hr == S_OK);
    14961557    return hr;
    14971558}
    … …  
    15081569    wined3d_mutex_unlock();
    15091570
     1571    ASSERT_D3D(hr == S_OK);
    15101572    return hr;
    15111573}
    … …  
    15221584    wined3d_mutex_unlock();
    15231585
     1586    ASSERT_D3D(hr == S_OK);
    15241587    return hr;
    15251588}
    … …  
    15351598    wined3d_mutex_unlock();
    15361599
     1600    ASSERT_D3D(hr == S_OK);
    15371601    return hr;
    15381602}
    … …  
    15481612    wined3d_mutex_unlock();
    15491613
     1614    ASSERT_D3D(hr == S_OK);
    15501615    return hr;
    15511616}
    … …  
    15611626    wined3d_mutex_unlock();
    15621627
     1628    ASSERT_D3D(hr == S_OK);
    15631629    return hr;
    15641630}
    … …  
    15741640    wined3d_mutex_unlock();
    15751641
     1642    ASSERT_D3D(hr == S_OK);
    15761643    return hr;
    15771644}
    … …  
    15871654    wined3d_mutex_unlock();
    15881655
     1656    ASSERT_D3D(hr == S_OK);
    15891657    return hr;
    15901658}
    … …  
    16001668    wined3d_mutex_unlock();
    16011669
     1670    ASSERT_D3D(hr == S_OK);
    16021671    return hr;
    16031672}
    … …  
    16141683    if (type != D3DSBT_ALL && type != D3DSBT_PIXELSTATE && type != D3DSBT_VERTEXSTATE)
    16151684    {
     1685        ERR_D3D();
    16161686        WARN("Unexpected stateblock type, returning D3DERR_INVALIDCALL.\n");
    16171687        return D3DERR_INVALIDCALL;
    … …  
    16211691    if (!object)
    16221692    {
     1693        ERR_D3D();
    16231694        ERR("Failed to allocate stateblock memory.\n");
    16241695        return E_OUTOFMEMORY;
    … …  
    16281699    if (FAILED(hr))
    16291700    {
     1701        ERR_D3D();
    16301702        WARN("Failed to initialize stateblock, hr %#x.\n", hr);
    16311703        HeapFree(GetProcessHeap(), 0, object);
    … …  
    16501722    wined3d_mutex_unlock();
    16511723
     1724    ASSERT_D3D(hr == S_OK);
    16521725    return hr;
    16531726}
    … …  
    16671740    if (FAILED(hr))
    16681741    {
     1742        ERR_D3D();
    16691743       WARN("IWineD3DDevice_EndStateBlock() failed, hr %#x.\n", hr);
    16701744       return hr;
    … …  
    16741748    if (!object)
    16751749    {
     1750        ERR_D3D();
    16761751        ERR("Failed to allocate stateblock memory.\n");
    16771752        IWineD3DStateBlock_Release(wined3d_stateblock);
    … …  
    16821757    if (FAILED(hr))
    16831758    {
     1759        ERR_D3D();
    16841760        WARN("Failed to initialize stateblock, hr %#x.\n", hr);
    16851761        IWineD3DStateBlock_Release(wined3d_stateblock);
    … …  
    17041780    wined3d_mutex_unlock();
    17051781
     1782    ASSERT_D3D(hr == S_OK);
    17061783    return hr;
    17071784}
    … …  
    17171794    wined3d_mutex_unlock();
    17181795
     1796
     1797    ASSERT_D3D(hr == S_OK);
    17191798    return hr;
    17201799}
    … …  
    17281807
    17291808    if(ppTexture == NULL){
     1809        ERR_D3D();
    17301810        return D3DERR_INVALIDCALL;
    17311811    }
    … …  
    17441824    wined3d_mutex_unlock();
    17451825
     1826    ASSERT_D3D(rc == S_OK);
    17461827    return rc;
    17471828}
    … …  
    17581839    wined3d_mutex_unlock();
    17591840
     1841    ASSERT_D3D(hr == S_OK);
    17601842    return hr;
    17611843}
    … …  
    18081890    wined3d_mutex_unlock();
    18091891
     1892    ASSERT_D3D(hr == S_OK);
    18101893    return hr;
    18111894}
    … …  
    18211904    wined3d_mutex_unlock();
    18221905
     1906    ASSERT_D3D(hr == S_OK);
    18231907    return hr;
    18241908}
    … …  
    18361920    wined3d_mutex_unlock();
    18371921
     1922    ASSERT_D3D(hr == S_OK);
    18381923    return hr;
    18391924}
    … …  
    18491934    wined3d_mutex_unlock();
    18501935
     1936    ASSERT_D3D(hr == S_OK);
    18511937    return hr;
    18521938}
    … …  
    18621948    wined3d_mutex_unlock();
    18631949
     1950    ASSERT_D3D(hr == S_OK);
    18641951    return hr;
    18651952}
    … …  
    18771964    wined3d_mutex_unlock();
    18781965
     1966    ASSERT_D3D(hr == S_OK);
    18791967    return hr;
    18801968}
    … …  
    18901978    wined3d_mutex_unlock();
    18911979
     1980    ASSERT_D3D(hr == S_OK);
    18921981    return hr;
    18931982}
    … …  
    19031992    wined3d_mutex_unlock();
    19041993
     1994    ASSERT_D3D(hr == S_OK);
    19051995    return hr;
    19061996}
    … …  
    19162006    wined3d_mutex_unlock();
    19172007
     2008    ASSERT_D3D(hr == S_OK);
    19182009    return hr;
    19192010}
    … …  
    19292020    wined3d_mutex_unlock();
    19302021
     2022    ASSERT_D3D(hr == S_OK);
    19312023    return hr;
    19322024}
    … …  
    19422034    wined3d_mutex_unlock();
    19432035
     2036    ASSERT_D3D(hr == S_OK);
    19442037    return hr;
    19452038}
    … …  
    19552048    wined3d_mutex_unlock();
    19562049
     2050    ASSERT_D3D(hr == S_OK);
    19572051    return hr;
    19582052}
    … …  
    19812075    wined3d_mutex_unlock();
    19822076
     2077    ASSERT_D3D(hr == S_OK);
    19832078    return hr;
    19842079}
    … …  
    20122107    wined3d_mutex_unlock();
    20132108
     2109    ASSERT_D3D(hr == S_OK);
    20142110    return hr;
    20152111}
    … …  
    20322128    wined3d_mutex_unlock();
    20332129
     2130    ASSERT_D3D(hr == S_OK);
    20342131    return hr;
    20352132}
    … …  
    20512148    wined3d_mutex_unlock();
    20522149
     2150    ASSERT_D3D(hr == S_OK);
    20532151    return hr;
    20542152}
    … …  
    20722170    wined3d_mutex_unlock();
    20732171
     2172    ASSERT_D3D(hr == S_OK);
    20742173    return hr;
    20752174}
    … …  
    20882187    wined3d_mutex_unlock();
    20892188
     2189    ASSERT_D3D(hr == S_OK);
    20902190    return hr;
    20912191}
    … …  
    21022202    if (!declaration)
    21032203    {
     2204        ERR_D3D();
    21042205        WARN("Caller passed a NULL declaration, returning D3DERR_INVALIDCALL.\n");
    21052206        return D3DERR_INVALIDCALL;
    … …  
    21092210    if (!object)
    21102211    {
     2212        ERR_D3D();
    21112213        ERR("Failed to allocate vertex declaration memory.\n");
    21122214        return E_OUTOFMEMORY;
    … …  
    21162218    if (FAILED(hr))
    21172219    {
     2220        ERR_D3D();
    21182221        WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
    21192222        HeapFree(GetProcessHeap(), 0, object);
    … …  
    22032306    if (!decl)
    22042307    {
     2308        ERR_D3D();
    22052309         /* Any situation when this should happen, except out of memory? */
    22062310         ERR("Failed to create a converted vertex declaration\n");
    … …  
    22112315    if (FAILED(hr)) ERR("Failed to set vertex declaration\n");
    22122316
     2317    ASSERT_D3D(hr == S_OK);
    22132318    return hr;
    22142319}
    … …  
    22242329    if (FAILED(hr))
    22252330    {
     2331        ERR_D3D();
    22262332        WARN("Failed to get vertex declaration, %#x\n", hr);
    22272333        *pFVF = 0;
    … …  
    22412347    TRACE("Returning FVF %#x\n", *pFVF);
    22422348
     2349    ASSERT_D3D(hr == S_OK);
    22432350    return hr;
    22442351}
    … …  
    22562363    if (!object)
    22572364    {
     2365        ERR_D3D();
    22582366        ERR("Failed to allocate vertex shader memory.\n");
    22592367        return E_OUTOFMEMORY;
    … …  
    22632371    if (FAILED(hr))
    22642372    {
     2373        ERR_D3D();
    22652374        WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
    22662375        HeapFree(GetProcessHeap(), 0, object);
    … …  
    22872396    wined3d_mutex_unlock();
    22882397
     2398    ASSERT_D3D(hr == S_OK);
    22892399    return hr;
    22902400}
    … …  
    22992409
    23002410    if(pStream == NULL){
     2411        ERR_D3D();
    23012412        return D3DERR_INVALIDCALL;
    23022413    }
    … …  
    23152426    wined3d_mutex_unlock();
    23162427
     2428    ASSERT_D3D(rc == S_OK);
    23172429    return rc;
    23182430}
    … …  
    23302442    wined3d_mutex_unlock();
    23312443
     2444    ASSERT_D3D(hr == S_OK);
    23322445    return hr;
    23332446}
    … …  
    23432456    wined3d_mutex_unlock();
    23442457
     2458    ASSERT_D3D(hr == S_OK);
    23452459    return hr;
    23462460}
    … …  
    23592473    wined3d_mutex_unlock();
    23602474
     2475    ASSERT_D3D(hr == S_OK);
    23612476    return hr;
    23622477}
    … …  
    23702485
    23712486    if(ppIndexData == NULL){
     2487        ERR_D3D();
    23722488        return D3DERR_INVALIDCALL;
    23732489    }
    … …  
    23842500    wined3d_mutex_unlock();
    23852501
     2502    ASSERT_D3D(rc == S_OK);
    23862503    return rc;
    23872504}
    … …  
    23992516    if (!object)
    24002517    {
     2518        ERR_D3D();
    24012519        FIXME("Failed to allocate pixel shader memory.\n");
    24022520        return E_OUTOFMEMORY;
    … …  
    24062524    if (FAILED(hr))
    24072525    {
     2526        ERR_D3D();
    24082527        WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
    24092528        HeapFree(GetProcessHeap(), 0, object);
    … …  
    24282547    wined3d_mutex_unlock();
    24292548
     2549    ASSERT_D3D(hr == S_OK);
    24302550    return hr;
    24312551}
    … …  
    24422562    wined3d_mutex_unlock();
    24432563
     2564    ASSERT_D3D(hr == S_OK);
    24442565    return hr;
    24452566}
    … …  
    24552576    wined3d_mutex_unlock();
    24562577
     2578    ASSERT_D3D(hr == S_OK);
    24572579    return hr;
    24582580}
    … …  
    24702592    if (!object)
    24712593    {
     2594        ERR_D3D();
    24722595        ERR("Failed to allocate query memory.\n");
    24732596        return E_OUTOFMEMORY;
    … …  
    24772600    if (FAILED(hr))
    24782601    {
     2602        ERR_D3D();
    24792603        WARN("Failed to initialize query, hr %#x.\n", hr);
    24802604        HeapFree(GetProcessHeap(), 0, object);
    … …  
    24952619            iface, width, height, rows, columns);
    24962620
     2621    ERR_D3D();
    24972622    return WINED3DERR_INVALIDCALL;
    24982623}
    … …  
    25072632            dst_descs, operation, offset_x, offset_y);
    25082633
     2634    ERR_D3D();
    25092635    return WINED3DERR_INVALIDCALL;
    25102636}
    … …  
    25172643            iface, src_rect, dst_rect, dst_window_override, dirty_region, flags);
    25182644
     2645    ERR_D3D();
    25192646    return WINED3DERR_INVALIDCALL;
    25202647}
    … …  
    25242651    FIXME("iface %p, priority %p stub!\n", iface, priority);
    25252652
     2653    ERR_D3D();
    25262654    return WINED3DERR_INVALIDCALL;
    25272655}
    … …  
    25312659    FIXME("iface %p, priority %d stub!\n", iface, priority);
    25322660
     2661    ERR_D3D();
    25332662    return WINED3DERR_INVALIDCALL;
    25342663}
    … …  
    25382667    FIXME("iface %p, swapchain_idx %u stub!\n", iface, swapchain_idx);
    25392668
     2669    ERR_D3D();
    25402670    return WINED3DERR_INVALIDCALL;
    25412671}
    … …  
    25472677            iface, resources, resource_count);
    25482678
     2679    ERR_D3D();
    25492680    return WINED3DERR_INVALIDCALL;
    25502681}
    … …  
    25542685    FIXME("iface %p, max_latency %u stub!\n", iface, max_latency);
    25552686
     2687    ERR_D3D();
    25562688    return WINED3DERR_INVALIDCALL;
    25572689}
    … …  
    25632695    *max_latency = 2;
    25642696
     2697    ERR_D3D();
    25652698    return WINED3DERR_INVALIDCALL;
    25662699}
    … …  
    25702703    FIXME("iface %p, dst_window %p stub!\n", iface, dst_window);
    25712704
     2705    ERR_D3D();
    25722706    return WINED3DERR_INVALIDCALL;
    25732707}
    … …  
    25822716            lockable, surface, shared_handle, usage);
    25832717
     2718    ERR_D3D();
    25842719    return WINED3DERR_INVALIDCALL;
    25852720}
    … …  
    25922727            iface, width, height, format, pool, surface, shared_handle, usage);
    25932728
     2729    ERR_D3D();
    25942730    return WINED3DERR_INVALIDCALL;
    25952731}
    … …  
    26042740            discard, surface, shared_handle, usage);
    26052741
     2742    ERR_D3D();
    26062743    return WINED3DERR_INVALIDCALL;
    26072744}
    … …  
    26122749    FIXME("iface %p, present_parameters %p, mode %p stub!\n", iface, present_parameters, mode);
    26132750
     2751    ERR_D3D();
    26142752    return WINED3DERR_INVALIDCALL;
    26152753}
    … …  
    26202758    FIXME("iface %p, swapchain_idx %u, mode %p, rotation %p stub!\n", iface, swapchain_idx, mode, rotation);
    26212759
     2760    ERR_D3D();
    26222761    return WINED3DERR_INVALIDCALL;
    26232762}

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/directx.c

    r35713 r39570  
    3232#include "d3d9_private.h"
    3333
     34#include <iprt/cdefs.h>
     35
    3436WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
    3537
    … …  
    5254            TRACE("Returning IDirect3D9Ex interface at %p\n", *ppobj);
    5355            IDirect3D9Ex_AddRef((IDirect3D9Ex *)*ppobj);
     56            return S_OK;
    5457        } else {
    5558            WARN("Application asks for IDirect3D9Ex, but this instance wasn't created with Direct3DCreate9Ex\n");
    5659            WARN("Returning E_NOINTERFACE\n");
    5760            *ppobj = NULL;
     61            ERR_D3D();
    5862            return E_NOINTERFACE;
    5963        }
    … …  
    6266    WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
    6367    *ppobj = NULL;
     68    ERR_D3D();
    6469    return E_NOINTERFACE;
    6570}
    … …  
    102107    wined3d_mutex_unlock();
    103108
     109    ASSERT_D3D(hr == S_OK);
     110
    104111    return hr;
    105112}
    … …  
    114121    hr = IWineD3D_GetAdapterCount(This->WineD3D);
    115122    wined3d_mutex_unlock();
     123
     124    ASSERT_D3D(hr == S_OK);
    116125
    117126    return hr;
    … …  
    145154    pIdentifier->WHQLLevel = adapter_id.whql_level;
    146155
     156    ASSERT_D3D(hr == S_OK);
     157
    147158    return hr;
    148159}
    … …  
    156167    /* Others than that not supported by d3d9, but reported by wined3d for ddraw. Filter them out */
    157168    if(Format != D3DFMT_X8R8G8B8 && Format != D3DFMT_R5G6B5) {
     169        ERR_D3D();
    158170        return 0;
    159171    }
    … …  
    163175    wined3d_mutex_unlock();
    164176
     177    ASSERT_D3D(hr == S_OK);
    165178    return hr;
    166179}
    … …  
    176189       It's supposed to fail anyway, so no harm returning failure. */
    177190    if(Format != D3DFMT_X8R8G8B8 && Format != D3DFMT_R5G6B5)
     191    {
     192        ERR_D3D();
    178193        return D3DERR_INVALIDCALL;
     194    }
    179195
    180196    wined3d_mutex_lock();
    … …  
    185201    if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
    186202
     203    ASSERT_D3D(hr == S_OK);
    187204    return hr;
    188205}
    … …  
    200217    if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
    201218
     219    ASSERT_D3D(hr == S_OK);
    202220    return hr;
    203221}
    … …  
    217235    wined3d_mutex_unlock();
    218236
     237    ASSERT_D3D(hr == S_OK);
    219238    return hr;
    220239}
    … …  
    239258    {
    240259        WARN("D3DFMT_R8G8B8 is not available on windows, returning D3DERR_NOTAVAILABLE\n");
     260        ERR_D3D();
    241261        return D3DERR_NOTAVAILABLE;
    242262    }
    … …  
    258278    wined3d_mutex_unlock();
    259279
     280    ASSERT_D3D(hr == S_OK);
    260281    return hr;
    261282}
    … …  
    276297    wined3d_mutex_unlock();
    277298
     299    ASSERT_D3D(hr == S_OK);
    278300    return hr;
    279301}
    … …  
    294316    wined3d_mutex_unlock();
    295317
     318    ASSERT_D3D(hr == S_OK);
    296319    return hr;
    297320}
    … …  
    309332    wined3d_mutex_unlock();
    310333
     334    ASSERT_D3D(hr == S_OK);
    311335    return hr;
    312336}
    … …  
    372396}
    373397
     398#ifndef VBOX_WINE_WITHOUT_LIBWINE
     399#define D3DDEVCAPS_FLOATTLVERTEX        0x00000001
     400#define D3DPMISCCAPS_FOGINFVF           0x00002000
     401#define D3DPRASTERCAPS_SUBPIXEL         0x00000020
     402#define D3DPRASTERCAPS_STIPPLE          0x00000200
     403#define D3DPTEXTURECAPS_TRANSPARENCY    0x00000008
     404#endif
     405
    374406static HRESULT WINAPI IDirect3D9Impl_GetDeviceCaps(LPDIRECT3D9EX iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS9* pCaps) {
    375407    IDirect3D9Impl *This = (IDirect3D9Impl *)iface;
    … …  
    400432    filter_caps(pCaps);
    401433
     434    /* fixup caps  */
     435#ifdef VBOX_WITH_WDDM
     436    pCaps->Caps2 |= 0x00080000 /*D3DCAPS2_CANRENDERWINDOWED*/;
     437    pCaps->Caps2 |= D3DCAPS2_CANSHARERESOURCE;
     438    pCaps->DevCaps |= D3DDEVCAPS_FLOATTLVERTEX /* <- must be set according to the docs */
     439            /*| D3DDEVCAPS_HWVERTEXBUFFER | D3DDEVCAPS_HWINDEXBUFFER |  D3DDEVCAPS_SUBVOLUMELOCK */;
     440    pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_INDEPENDENTWRITEMASKS
     441            | D3DPMISCCAPS_FOGINFVF
     442            | D3DPMISCCAPS_SEPARATEALPHABLEND | D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS;
     443    pCaps->RasterCaps |= D3DPRASTERCAPS_SUBPIXEL | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_COLORPERSPECTIVE /* keep */;
     444    pCaps->TextureCaps |= D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE;
     445    pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
     446    pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
     447    pCaps->StencilCaps |= D3DSTENCILCAPS_TWOSIDED;
     448    pCaps->DeclTypes |= D3DDTCAPS_FLOAT16_2 | D3DDTCAPS_FLOAT16_4;
     449    pCaps->VertexTextureFilterCaps |= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MAGFPOINT;
     450    pCaps->GuardBandLeft = -8192.;
     451    pCaps->GuardBandTop = -8192.;
     452    pCaps->GuardBandRight = 8192.;
     453    pCaps->GuardBandBottom = 8192.;
     454    pCaps->VS20Caps.DynamicFlowControlDepth = 24;
     455    pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
     456    pCaps->PS20Caps.DynamicFlowControlDepth = 24;
     457    pCaps->PS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
     458#endif
     459    /* workaround for wine not returning InstructionSlots correctly for  shaders v3.0 */
     460    if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
     461    {
     462        pCaps->MaxVertexShader30InstructionSlots = RT_MIN(32768, pCaps->MaxVertexShader30InstructionSlots);
     463        pCaps->MaxPixelShader30InstructionSlots = RT_MIN(32768, pCaps->MaxPixelShader30InstructionSlots);
     464    }
     465#if defined(DEBUG)
     466    if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
     467    {
     468        ASSERT_D3D(pCaps->MaxVertexShader30InstructionSlots >= 512);
     469        ASSERT_D3D(pCaps->MaxVertexShader30InstructionSlots <= 32768);
     470        ASSERT_D3D(pCaps->MaxPixelShader30InstructionSlots >= 512);
     471        ASSERT_D3D(pCaps->MaxPixelShader30InstructionSlots <= 32768);
     472    }
     473    else if ((pCaps->VertexShaderVersion & 0xff00) == 0x0200)
     474    {
     475        ASSERT_D3D(pCaps->MaxVertexShader30InstructionSlots == 0);
     476        ASSERT_D3D(pCaps->MaxPixelShader30InstructionSlots == 0);
     477    }
     478    else
     479    {
     480        ERR_D3D();
     481    }
     482#endif
     483
     484    /* needed for Windows Media Player to work properly */
     485    pCaps->Caps |= D3DCAPS_READ_SCANLINE;
     486
    402487    TRACE("(%p) returning %p\n", This, pCaps);
     488
     489    ASSERT_D3D(hrc == S_OK);
    403490    return hrc;
    404491}
    … …  
    414501    wined3d_mutex_unlock();
    415502
     503    ASSERT_D3D(ret);
    416504    return ret;
    417505}
    … …  
    432520    {
    433521        ERR("Failed to allocate device memory.\n");
     522        ERR_D3D();
    434523        return E_OUTOFMEMORY;
    435524    }
    … …  
    438527    if (FAILED(hr))
    439528    {
     529        ERR_D3D();
    440530        WARN("Failed to initialize device, hr %#x.\n", hr);
    441531        HeapFree(GetProcessHeap(), 0, object);
    … …  
    454544    FIXME("iface %p, adapter %u, filter %p stub!\n", iface, adapter, filter);
    455545
     546    ERR_D3D();
    456547    return D3DERR_DRIVERINTERNALERROR;
    457548}
    … …  
    463554            iface, adapter, filter, mode_idx, mode);
    464555
     556    ERR_D3D();
    465557    return D3DERR_DRIVERINTERNALERROR;
    466558}
    … …  
    517609    }
    518610*/
     611    ASSERT_D3D(hr == S_OK);
    519612    return hr;
    520613}
    … …  
    531624    *device = NULL;
    532625
     626    ERR_D3D();
    533627    return D3DERR_DRIVERINTERNALERROR;
    534628}
    … …  
    552646    memcpy(luid, &adapter_id.adapter_luid, sizeof(*luid));
    553647
     648    ASSERT_D3D(hr == S_OK);
    554649    return hr;
    555650}

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/include/wine/debug.h

    r38982 r39570  
    4141#endif
    4242
    43 #ifdef VBOX_WITH_WDDM
    44 # ifdef VBOX_WINE_WITH_IPRT
    45 #  include <iprt/assert.h>
    46 # else
    47 #  define AssertBreakpoint() do { } while (0)
    48 #  define Assert(_expr) do { } while (0)
    49 #  define RT_BREAKPOINT()
    50 # endif
     43#ifdef VBOX_WINE_WITH_IPRT
     44# include <iprt/assert.h>
     45#else
     46# define AssertBreakpoint() do { } while (0)
     47# define Assert(_expr) do { } while (0)
     48# define RT_BREAKPOINT()
    5149#endif
    5250
    … …  
    6058
    6159struct _GUID;
     60
     61#ifdef DEBUG
     62# define VBOX_WINE_DEBUG
     63#endif
     64
     65#ifdef VBOX_WINE_DEBUG
     66# ifndef VBOX_WINE_DEBUG_DEFINES
     67extern DWORD g_VBoxVDbgBreakOnD3DErr;
     68# else
     69#  ifdef DEBUG_misha
     70#   define _ERR_BREAK_DEFAULT 1
     71#  else
     72#   define _ERR_BREAK_DEFAULT 0
     73#  endif
     74DWORD g_VBoxVDbgBreakOnD3DErr = _ERR_BREAK_DEFAULT;
     75# endif
     76
     77# define _ERR_BREAK() Assert(0)
     78# define _ERR_ASSERT(_e) Assert((_e))
     79# define _ERR_CHECK_BREAK(_t) do { \
     80        if (g_VBoxVDbgBreakOn##_t) { _ERR_BREAK(); } \
     81    } while (0)
     82# define _ERR_CHECK_ASSERT(_t, _e) do { \
     83        if (g_VBoxVDbgBreakOn##_t) { _ERR_ASSERT(_e); } \
     84    } while (0)
     85
     86# define ERR_D3D() _ERR_CHECK_BREAK(D3DErr)
     87# define ASSERT_D3D(_e) _ERR_CHECK_ASSERT(D3DErr, _e)
     88#else
     89# define ERR_D3D() do {} while (0)
     90# define ASSERT_D3D(_e) do {} while (0)
     91#endif /* #ifdef VBOX_WINE_DEBUG */
    6292
    6393/*

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/libWineStub/include/d3d9.h

    r35052 r39570  
    3434#endif
    3535
     36
     37
     38#ifndef VBOX_WINE_WITHOUT_LIBWINE
    3639#include <stdlib.h>
    3740
    … …  
    3942#include <objbase.h>
    4043
    41 #ifndef __WINESRC__
     44# ifndef __WINESRC__
    4245# include <windows.h>
    43 #endif
    44 
     46# endif
     47#endif
    4548#include <d3d9types.h>
    4649#include <d3d9caps.h>
     50#ifdef VBOX_WINE_WITHOUT_LIBWINE
     51# include <d3dhal.h>
     52# include <d3dtypes.h>
     53# include <d3dcaps.h>
     54#endif
    4755
    4856/*****************************************************************************

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/libWineStub/include/wine/debug.h

    r39173 r39570  
    4040#endif
    4141
    42 #ifdef VBOX_WITH_WDDM
    43 # ifdef VBOX_WINE_WITH_IPRT
    44 #  include <iprt/assert.h>
    45 # else
    46 #  define AssertBreakpoint() do { } while (0)
    47 #  define Assert(_expr) do { } while (0)
    48 #  ifdef DEBUG_misha
    49 #   include <iprt/cdefs.h>
    50 #  endif
     42#ifdef VBOX_WINE_WITH_IPRT
     43# include <iprt/assert.h>
     44#else
     45# define AssertBreakpoint() do { } while (0)
     46# define Assert(_expr) do { } while (0)
     47# ifdef DEBUG_misha
     48#  include <iprt/cdefs.h>
    5149# endif
    5250#endif
    … …  
    5755
    5856struct _GUID;
     57
     58#ifdef DEBUG
     59# define VBOX_WINE_DEBUG
     60#endif
     61
     62#ifdef VBOX_WINE_DEBUG
     63# ifndef VBOX_WINE_DEBUG_DEFINES
     64extern DWORD g_VBoxVDbgBreakOnD3DErr;
     65# else
     66#  ifdef DEBUG_misha
     67#   define _ERR_BREAK_DEFAULT 1
     68#  else
     69#   define _ERR_BREAK_DEFAULT 0
     70#  endif
     71DWORD g_VBoxVDbgBreakOnD3DErr = _ERR_BREAK_DEFAULT;
     72# endif
     73
     74# define _ERR_BREAK() Assert(0)
     75# define _ERR_ASSERT(_e) Assert((_e))
     76# define _ERR_CHECK_BREAK(_t) do { \
     77        if (g_VBoxVDbgBreakOn##_t) { _ERR_BREAK(); } \
     78    } while (0)
     79# define _ERR_CHECK_ASSERT(_t, _e) do { \
     80        if (g_VBoxVDbgBreakOn##_t) { _ERR_ASSERT(_e); } \
     81    } while (0)
     82
     83# define ERR_D3D() _ERR_CHECK_BREAK(D3DErr)
     84# define ASSERT_D3D(_e) _ERR_CHECK_ASSERT(D3DErr, _e)
     85#else
     86# define ERR_D3D() do {} while (0)
     87# define ASSERT_D3D(_e) do {} while (0)
     88#endif /* #ifdef VBOX_WINE_DEBUG */
    5989
    6090#ifdef inline

  • trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_main.c

    r39257 r39570  
    3131 * of the LGPL is applied is otherwise unspecified.
    3232 */
     33#define VBOX_WINE_DEBUG_DEFINES
    3334
    3435#include "config.h"
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette