ddraw_main.c

winNT技术操作系统,国外开放的原代码和LIUX一样

/* $Id: ddraw_main.c 25184 2006-12-17 13:53:19Z greatlrd $
 *
 * COPYRIGHT:            See COPYING in the top level directory
 * PROJECT:              ReactOS
 * FILE:                 lib/ddraw/main/ddraw.c
 * PURPOSE:              IDirectDraw7 Implementation 
 * PROGRAMMER:           Magnus Olsen, Maarten Bosma
 *
 */


#include "../rosdraw.h"

HRESULT 
WINAPI 
Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 iface, 
                                REFIID id, 
                                LPVOID *obj) 
{   
    LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;

    DX_WINDBG_trace();
    
    /* fixme 
       the D3D object cab be optain from here 
       Direct3D7 
    */
    if (IsEqualGUID(&IID_IDirectDraw7, id))
    {
        /* DirectDraw7 Vtable */
        This->lpVtbl = &DirectDraw7_Vtable;
        *obj = &This->lpVtbl;
    }
    else
    {
        *obj = NULL;
        return E_NOINTERFACE;
    }

    Main_DirectDraw_AddRef(iface);
    return S_OK;
}

/*
 * IMPLEMENT
 * Status ok
 */
ULONG
WINAPI 
Main_DirectDraw_AddRef (LPDIRECTDRAW7 iface) 
{    
    LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;

    DX_WINDBG_trace();

    if (iface!=NULL)
    {
        This->dwIntRefCnt++;
        This->lpLcl->dwLocalRefCnt++;

        if (This->lpLcl->lpGbl != NULL)
        {
            This->lpLcl->lpGbl->dwRefCnt++;
        }
    }
    return This->dwIntRefCnt;
}


ULONG 
WINAPI 
Main_DirectDraw_Release (LPDIRECTDRAW7 iface) 
{    
    LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;

    DX_WINDBG_trace();

    if (iface!=NULL)
    {
        This->lpLcl->dwLocalRefCnt--;
        This->dwIntRefCnt--;

        if (This->lpLcl->lpGbl != NULL)
        {
            This->lpLcl->lpGbl->dwRefCnt--;
        }

        if ( This->lpLcl->lpGbl->dwRefCnt == 0)
        {
            // set resoltion back to the one in registry
            /*if(This->cooperative_level & DDSCL_EXCLUSIVE)
            {
                ChangeDisplaySettings(NULL, 0);
            }*/
            
            Cleanup(iface);
            return 0;
        }
    }
    return This->dwIntRefCnt;
}

/*
 * IMPLEMENT
 * Status ok
 */
HRESULT 
WINAPI 
Main_DirectDraw_Compact(LPDIRECTDRAW7 iface) 
{
    /* MSDN say not implement but my question what does it return then */
    DX_WINDBG_trace();
    return DD_OK;
}

/*
 * IMPLEMENT
 * Status ok
 */
HRESULT 
WINAPI 
Main_DirectDraw_CreateClipper(LPDIRECTDRAW7 iface, 
                              DWORD dwFlags, 
                              LPDIRECTDRAWCLIPPER *ppClipper, 
                              IUnknown *pUnkOuter)
{
    //LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
    LPDDRAWI_DDRAWCLIPPER_INT  That; 

    DX_WINDBG_trace();

    if (pUnkOuter!=NULL) 
    {
        return CLASS_E_NOAGGREGATION; 
    }

    That = (LPDDRAWI_DDRAWCLIPPER_INT) DxHeapMemAlloc(sizeof(DDRAWI_DDRAWCLIPPER_INT));
    if (That == NULL) 
    {
        return  DDERR_OUTOFMEMORY;  //E_OUTOFMEMORY;
    }

    That->lpVtbl = &DirectDrawClipper_Vtable;

    *ppClipper = (LPDIRECTDRAWCLIPPER)That;

    DirectDrawClipper_AddRef((LPDIRECTDRAWCLIPPER)That);

    return DirectDrawClipper_Initialize((LPDIRECTDRAWCLIPPER)That, (LPDIRECTDRAW)iface, dwFlags);
}

HRESULT WINAPI Main_DirectDraw_CreatePalette(LPDIRECTDRAW7 iface, DWORD dwFlags,
                  LPPALETTEENTRY palent, LPDIRECTDRAWPALETTE* ppPalette, LPUNKNOWN pUnkOuter)
{
    DX_WINDBG_trace();

    DX_STUB;
}


/*
 * stub
 * Status not done
 */
HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD,
                                            LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter) 
{
    
    LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
    LPDDRAWI_DDRAWSURFACE_INT *That = NULL;
    LPDDRAWI_DDRAWSURFACE_LCL *lpLcl;
    DWORD dwHowManySurface = 1;
    DWORD i;
    LPDDRAWI_DDRAWSURFACE_LCL *xlpLcl;
    if (pUnkOuter!=NULL) 
    {
        return CLASS_E_NOAGGREGATION; 
    }
    if (IsBadWritePtr( ppSurf, sizeof( LPDIRECTDRAWSURFACE7 )) )
    {
        return DDERR_INVALIDPARAMS;
    }
    if (IsBadWritePtr( pDDSD, sizeof( LPDDSURFACEDESC2 )) )
    {
        return DDERR_INVALIDPARAMS;
    }
    if (IsBadReadPtr(pDDSD, sizeof( LPDDSURFACEDESC2 )) )
    {
        return DDERR_INVALIDPARAMS;
    }
    if (sizeof(DDSURFACEDESC2)!=pDDSD->dwSize)
    {
        return DDERR_UNSUPPORTED;
    }
     if( (pDDSD->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) && 
        (pDDSD->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY ) )
    {
        return DDERR_INVALIDCAPS;
    }


    /* this two line should be move to startup code */
    ddSurfGbl.lpDD       = &ddgbl;
    ddSurfGbl.lpDDHandle = &ddgbl;

    /* Detecte if we are in fullscreen or not and extract thuse data */
    if (This->lpLcl->dwLocalFlags & DDRAWILCL_ISFULLSCREEN)
    {
        ddSurfGbl.wWidth  = This->lpLcl->lpGbl->vmiData.dwDisplayWidth;
        ddSurfGbl.wHeight = This->lpLcl->lpGbl->vmiData.dwDisplayHeight;
        ddSurfGbl.lPitch  = This->lpLcl->lpGbl->vmiData.lDisplayPitch;
    }
    else
    {
        RECT rect;
        if(GetWindowRect((HWND)This->lpLcl->hWnd, &rect))
        {
            ddSurfGbl.wWidth  = rect.right - rect.left;
            ddSurfGbl.wHeight = rect.bottom - rect.top;
            ddSurfGbl.lPitch  = This->lpLcl->lpGbl->vmiData.lDisplayPitch;
        }
    }

    /* setup diffent pixel format */
    if  (pDDSD->dwFlags & DDSD_PIXELFORMAT)
    {
        if (pDDSD->ddpfPixelFormat.dwSize != sizeof(DDPIXELFORMAT))
        {
            return DDERR_INVALIDPIXELFORMAT;
        }
        memcpy(&ddSurfGbl.ddpfSurface,&pDDSD->ddpfPixelFormat, sizeof(DDPIXELFORMAT));
    }

    /* Calc how many surface we need setup */
    if (pDDSD->ddsCaps.dwCaps &DDSD_BACKBUFFERCOUNT)
    {
       /* One primary + xx backbuffer */
       dwHowManySurface |= pDDSD->dwBackBufferCount;
    }

    /* Alloc all memory we need for all createsurface here */
    lpLcl = DxHeapMemAlloc(sizeof(LPDDRAWI_DDRAWSURFACE_LCL) * dwHowManySurface);
    if (lpLcl == NULL)
    {
        return DDERR_OUTOFMEMORY;
    }

    That = DxHeapMemAlloc(sizeof(LPDDRAWI_DDRAWSURFACE_INT) * dwHowManySurface);
    if (That == NULL)
    {
        return DDERR_OUTOFMEMORY;
    }

    for (i=0;i<dwHowManySurface+1;i++)
    {
        That[i] = (LPDDRAWI_DDRAWSURFACE_INT) DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_INT));
        lpLcl[i] = (LPDDRAWI_DDRAWSURFACE_LCL) DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_LCL));
        if ( (lpLcl[i] == NULL) ||
             (That[i] == NULL))
        {
            return DDERR_OUTOFMEMORY;
        }
        That[i]->lpLcl = lpLcl[i];

        That[i]->lpLcl->lpGbl = &ddSurfGbl;
        //That[i]->lpLcl->lpGbl = (LPDDRAWI_DDRAWSURFACE_GBL) DxHeapMemAlloc(sizeof(LPDDRAWI_DDRAWSURFACE_GBL));
        //if (That[i]->lpLcl->lpGbl == NULL)
        //{
        //    return DDERR_OUTOFMEMORY;
        //}

        //That[i]->lpLcl->lpGbl->lpDD = &ddgbl;
        //That[i]->lpLcl->lpGbl->lpDDHandle =  This->lpLcl->lpGbl;
        //memmove(That[i]->lpLcl->lpGbl,&ddSurfGbl,sizeof(LPDDRAWI_DDRAWSURFACE_GBL));
    }



   /* here we need start fixing bugs
    * the code above is 100% correct behovir
    * checked how ms ddraw behivor
    */



    /* Create the surface */
    if (((pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
        && (!(pDDSD->ddsCaps.dwCaps & DDSCAPS_BACKBUFFER)))
    {
        CreatePrimarySurface(This,That,lpLcl,pDDSD);
    }
    if (pDDSD->ddsCaps.dwCaps & DDSCAPS_OVERLAY)
    {       
        CreateOverlaySurface(This, That, pDDSD);
    }
    if (pDDSD->ddsCaps.dwCaps & DDSCAPS_BACKBUFFER)
    {
        This->lpLcl->lpGbl->dsList = NULL;
        DX_STUB_str( "ok");

        if (pDDSD->dwFlags & DDSD_BACKBUFFERCOUNT)
        {
            HRESULT retValue;
            DX_STUB_str( "ok");

            if (! pDDSD->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_COMPLEX))
            {
                return DDERR_INVALIDPARAMS;
            }

            if (pDDSD->dwBackBufferCount != 0)
            {
                This->lpLcl->lpGbl->dsList = This->lpLcl->lpPrimary;
            }
            else
            {
                return DDERR_INVALIDSURFACETYPE;
            }
            retValue = CreateBackBufferSurface(This,That,lpLcl,pDDSD);
            //CreatePrimarySurface(This,That,lpLcl,pDDSD);
            if (retValue != DD_OK)
            {
                DX_STUB_str( "Fail to create backbuffer surface");
                return retValue;
            }
        }
    }

    if (pDDSD->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
    {
        DX_STUB_str( "Can not create texture surface");
    }
    if (pDDSD->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
    {
        DX_STUB_str( "Can not create zbuffer surface");
    }
    if (pDDSD->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN) 
    {
        DX_STUB_str( "Can not create offscreenplain surface");
    }

    *ppSurf = (LPDIRECTDRAWSURFACE7)That[0];
    return DD_OK;
   
}


/*
 * stub
 * Status not done
 */
HRESULT WINAPI Main_DirectDraw_DuplicateSurface(LPDIRECTDRAW7 iface, LPDIRECTDRAWSURFACE7 src,
                 LPDIRECTDRAWSURFACE7* dst) 
{
    DX_WINDBG_trace();
    DX_STUB;    
}

/*
 * IMPLEMENT
 * Status ok
 */
HRESULT WINAPI Main_DirectDraw_EnumDisplayModes(LPDIRECTDRAW7 iface, DWORD dwFlags,
                 LPDDSURFACEDESC2 pDDSD, LPVOID context, LPDDENUMMODESCALLBACK2 callback) 
{

    DX_STUB_DD_OK;