Ros-diffs

ros-diffs@reactos.org

81390 discussions

[gedmurphy] 30397: fix RosBE build
by gedmurphy＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: gedmurphy Date: Mon Nov 12 19:08:54 2007 New Revision: 30397 URL: http://svn.reactos.org/svn/reactos?rev=30397&view=rev Log: fix RosBE build Modified: trunk/reactos/base/applications/mstsc/connectdialog.c trunk/reactos/base/applications/mstsc/win32.c Modified: trunk/reactos/base/applications/mstsc/connectdialog.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/mstsc/co… ============================================================================== --- trunk/reactos/base/applications/mstsc/connectdialog.c (original) +++ trunk/reactos/base/applications/mstsc/connectdialog.c Mon Nov 12 19:08:54 2007 @@ -24,8 +24,8 @@ HINSTANCE hInst; -VOID ReLoadGeneralPage(PINFO pInfo); -VOID ReLoadDisplayPage(PINFO pInfo); +static VOID ReLoadGeneralPage(PINFO pInfo); +static VOID ReLoadDisplayPage(PINFO pInfo); static VOID Modified: trunk/reactos/base/applications/mstsc/win32.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/mstsc/wi… ============================================================================== --- trunk/reactos/base/applications/mstsc/win32.c (original) +++ trunk/reactos/base/applications/mstsc/win32.c Mon Nov 12 19:08:54 2007 @@ -22,7 +22,9 @@ #include <precomp.h> //FIXME: remove eventually +#ifndef _UNICODE #define _UNICODE +#endif #include <tchar.h>

1 0

[gedmurphy] 30396: implement opening of existing .rdp settings
by gedmurphy＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: gedmurphy Date: Mon Nov 12 19:04:06 2007 New Revision: 30396 URL: http://svn.reactos.org/svn/reactos?rev=30396&view=rev Log: implement opening of existing .rdp settings Modified: trunk/reactos/base/applications/mstsc/connectdialog.c Modified: trunk/reactos/base/applications/mstsc/connectdialog.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/mstsc/co… ============================================================================== --- trunk/reactos/base/applications/mstsc/connectdialog.c (original) +++ trunk/reactos/base/applications/mstsc/connectdialog.c Mon Nov 12 19:04:06 2007 @@ -24,10 +24,39 @@ HINSTANCE hInst; +VOID ReLoadGeneralPage(PINFO pInfo); +VOID ReLoadDisplayPage(PINFO pInfo); + + +static VOID +DoOpenFile(PINFO pInfo) +{ + OPENFILENAMEW ofn; + WCHAR szFileName[MAX_PATH] = L""; + static WCHAR szFilter[] = L"Remote Desktop Files (*rdp)\0*.rdp\0"; + + ZeroMemory(&ofn, sizeof(ofn)); + ofn.lStructSize = sizeof(OPENFILENAME); + ofn.hwndOwner = pInfo->hGeneralPage; + ofn.nMaxFile = MAX_PATH; + ofn.nMaxFileTitle = MAX_PATH; + ofn.lpstrDefExt = L"rdp"; + ofn.lpstrFilter = szFilter; + ofn.lpstrFile = szFileName; + ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST; + + if (GetOpenFileNameW(&ofn)) + { + LoadRdpSettingsFromFile(pInfo->pRdpSettings, szFileName); + ReLoadGeneralPage(pInfo); + ReLoadDisplayPage(pInfo); + } +} + static VOID DoSaveAs(PINFO pInfo) { - OPENFILENAME ofn; + OPENFILENAMEW ofn; WCHAR szFileName[MAX_PATH] = L""; static WCHAR szFilter[] = L"Remote Desktop Files (*rdp)\0*.rdp\0"; @@ -41,12 +70,13 @@ ofn.lpstrFile = szFileName; ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT; - if (GetSaveFileName(&ofn)) + if (GetSaveFileNameW(&ofn)) { SaveAllSettings(pInfo); SaveRdpSettingsToFile(szFileName, pInfo->pRdpSettings); } } + static VOID OnTabWndSelChange(PINFO pInfo) @@ -149,10 +179,25 @@ static VOID +ReLoadGeneralPage(PINFO pInfo) +{ + LPWSTR lpText; + + /* add file address */ + lpText = GetStringFromSettings(pInfo->pRdpSettings, + L"full address"); + if (lpText) + { + SetDlgItemTextW(pInfo->hGeneralPage, + IDC_SERVERCOMBO, + lpText); + } +} + + +static VOID GeneralOnInit(PINFO pInfo) { - LPWSTR lpText; - SetWindowPos(pInfo->hGeneralPage, NULL, 13, @@ -192,17 +237,7 @@ } FillServerAddesssCombo(pInfo); - - /* add file address */ - lpText = GetStringFromSettings(pInfo->pRdpSettings, - L"full address"); - if (lpText) - { - SetDlgItemTextW(pInfo->hGeneralPage, - IDC_SERVERCOMBO, - lpText); - } - + ReLoadGeneralPage(pInfo); } @@ -255,6 +290,10 @@ case IDC_SAVEAS: DoSaveAs(pInfo); + break; + + case IDC_OPEN: + DoOpenFile(pInfo); break; } @@ -540,11 +579,8 @@ FillResolutionsAndColors(PINFO pInfo) { PSETTINGS_ENTRY Current; - WCHAR Buffer[64]; - WCHAR Pixel[64]; DWORD index, i, num; DWORD MaxBpp = 0; - INT width, height, pos = 0; UINT types[4]; pInfo->CurrentDisplayDevice = pInfo->DisplayDeviceList; /* Update global variable */ @@ -624,6 +660,19 @@ TRUE, MAKELONG(0, pInfo->DisplayDeviceList->ResolutionsCount)); //extra 1 for full screen + +} + + +static VOID +ReLoadDisplayPage(PINFO pInfo) +{ + DWORD index; + INT width, height, pos = 0; + INT bpp, num, i; + BOOL bSet = FALSE; + + /* set trackbar position */ width = GetIntegerFromSettings(pInfo->pRdpSettings, L"desktopwidth"); height = GetIntegerFromSettings(pInfo->pRdpSettings, L"desktopheight"); @@ -648,6 +697,43 @@ pos); OnResolutionChanged(pInfo, pos); + + + /* set color combo */ + bpp = GetIntegerFromSettings(pInfo->pRdpSettings, L"session bpp"); + + num = SendDlgItemMessageW(pInfo->hDisplayPage, + IDC_BPPCOMBO, + CB_GETCOUNT, + 0, + 0); + for (i = 0; i < num; i++) + { + INT data = SendDlgItemMessageW(pInfo->hDisplayPage, + IDC_BPPCOMBO, + CB_GETITEMDATA, + i, + 0); + if (data == bpp) + { + SendDlgItemMessageW(pInfo->hDisplayPage, + IDC_BPPCOMBO, + CB_SETCURSEL, + i, + 0); + bSet = TRUE; + break; + } + } + + if (!bSet) + { + SendDlgItemMessageW(pInfo->hDisplayPage, + IDC_BPPCOMBO, + CB_SETCURSEL, + num - 1, + 0); + } } @@ -723,46 +809,8 @@ if (GotDev) { - INT bpp, num, i; - BOOL bSet = FALSE; - FillResolutionsAndColors(pInfo); - - /* set color combo */ - bpp = GetIntegerFromSettings(pInfo->pRdpSettings, L"session bpp"); - - num = SendDlgItemMessageW(pInfo->hDisplayPage, - IDC_BPPCOMBO, - CB_GETCOUNT, - 0, - 0); - for (i = 0; i < num; i++) - { - INT data = SendDlgItemMessageW(pInfo->hDisplayPage, - IDC_BPPCOMBO, - CB_GETITEMDATA, - i, - 0); - if (data == bpp) - { - SendDlgItemMessageW(pInfo->hDisplayPage, - IDC_BPPCOMBO, - CB_SETCURSEL, - i, - 0); - bSet = TRUE; - break; - } - } - - if (!bSet) - { - SendDlgItemMessageW(pInfo->hDisplayPage, - IDC_BPPCOMBO, - CB_SETCURSEL, - num - 1, - 0); - } + ReLoadDisplayPage(pInfo); } } @@ -862,7 +910,6 @@ PINFO pInfo; TCITEMW item; BOOL bRet = FALSE; - HWND hUnderGry, hUnderWht; pInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,

1 0

[gedmurphy] 30395: fix build
by gedmurphy＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: gedmurphy Date: Mon Nov 12 18:31:57 2007 New Revision: 30395 URL: http://svn.reactos.org/svn/reactos?rev=30395&view=rev Log: fix build Modified: trunk/reactos/base/applications/mstsc/mstsc.rbuild Modified: trunk/reactos/base/applications/mstsc/mstsc.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/mstsc/ms… ============================================================================== --- trunk/reactos/base/applications/mstsc/mstsc.rbuild (original) +++ trunk/reactos/base/applications/mstsc/mstsc.rbuild Mon Nov 12 18:31:57 2007 @@ -12,6 +12,7 @@ <library>advapi32</library> <library>shell32</library> <library>ole32</library> + <library>comdlg32</library> <compilationunit name="unit.c"> <file>bitmap.c</file> <file>bsops.c</file>

1 0

[greatlrd] 30394: forget this file sorry
by greatlrd＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: greatlrd Date: Mon Nov 12 18:17:07 2007 New Revision: 30394 URL: http://svn.reactos.org/svn/reactos?rev=30394&view=rev Log: forget this file sorry Added: trunk/reactos/dll/directx/wine/wined3d/surface_base.c (with props) Added: trunk/reactos/dll/directx/wine/wined3d/surface_base.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/surface_base.c (added) +++ trunk/reactos/dll/directx/wine/wined3d/surface_base.c Mon Nov 12 18:17:07 2007 @@ -1,0 +1,1630 @@ +/* + * IWineD3DSurface Implementation of management(non-rendering) functions + * + * Copyright 1998 Lionel Ulmer + * Copyright 2000-2001 TransGaming Technologies Inc. + * Copyright 2002-2005 Jason Edmeades + * Copyright 2002-2003 Raphael Junqueira + * Copyright 2004 Christian Costa + * Copyright 2005 Oliver Stieber + * Copyright 2006-2007 Stefan Dösinger for CodeWeavers + * Copyright 2007 Henri Verbeet + * Copyright 2006-2007 Roderick Colenbrander + * + * 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 "wined3d_private.h" + +#include <assert.h> + +WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface); + +/* Do NOT define GLINFO_LOCATION in this file. THIS CODE MUST NOT USE IT */ + +/* ******************************************* + IWineD3DSurface IUnknown parts follow + ******************************************* */ +HRESULT WINAPI IWineD3DBaseSurfaceImpl_QueryInterface(IWineD3DSurface *iface, REFIID riid, LPVOID *ppobj) +{ + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + /* Warn ,but be nice about things */ + TRACE("(%p)->(%s,%p)\n", This,debugstr_guid(riid),ppobj); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IWineD3DBase) + || IsEqualGUID(riid, &IID_IWineD3DResource) + || IsEqualGUID(riid, &IID_IWineD3DSurface)) { + IUnknown_AddRef((IUnknown*)iface); + *ppobj = This; + return S_OK; + } + *ppobj = NULL; + return E_NOINTERFACE; +} + +ULONG WINAPI IWineD3DBaseSurfaceImpl_AddRef(IWineD3DSurface *iface) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + ULONG ref = InterlockedIncrement(&This->resource.ref); + TRACE("(%p) : AddRef increasing from %d\n", This,ref - 1); + return ref; +} + +/* **************************************************** + IWineD3DSurface IWineD3DResource parts follow + **************************************************** */ +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetDevice(IWineD3DSurface *iface, IWineD3DDevice** ppDevice) { + return IWineD3DResourceImpl_GetDevice((IWineD3DResource *)iface, ppDevice); +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPrivateData(IWineD3DSurface *iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + return IWineD3DResourceImpl_SetPrivateData((IWineD3DResource *)iface, refguid, pData, SizeOfData, Flags); +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPrivateData(IWineD3DSurface *iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + return IWineD3DResourceImpl_GetPrivateData((IWineD3DResource *)iface, refguid, pData, pSizeOfData); +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_FreePrivateData(IWineD3DSurface *iface, REFGUID refguid) { + return IWineD3DResourceImpl_FreePrivateData((IWineD3DResource *)iface, refguid); +} + +DWORD WINAPI IWineD3DBaseSurfaceImpl_SetPriority(IWineD3DSurface *iface, DWORD PriorityNew) { + return IWineD3DResourceImpl_SetPriority((IWineD3DResource *)iface, PriorityNew); +} + +DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface *iface) { + return IWineD3DResourceImpl_GetPriority((IWineD3DResource *)iface); +} + +WINED3DRESOURCETYPE WINAPI IWineD3DBaseSurfaceImpl_GetType(IWineD3DSurface *iface) { + TRACE("(%p) : calling resourceimpl_GetType\n", iface); + return IWineD3DResourceImpl_GetType((IWineD3DResource *)iface); +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface *iface, IUnknown **pParent) { + TRACE("(%p) : calling resourceimpl_GetParent\n", iface); + return IWineD3DResourceImpl_GetParent((IWineD3DResource *)iface, pParent); +} + +/* ****************************************************** + IWineD3DSurface IWineD3DSurface parts follow + ****************************************************** */ + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetContainer(IWineD3DSurface* iface, REFIID riid, void** ppContainer) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + IWineD3DBase *container = 0; + + TRACE("(This %p, riid %s, ppContainer %p)\n", This, debugstr_guid(riid), ppContainer); + + if (!ppContainer) { + ERR("Called without a valid ppContainer.\n"); + } + + /** From MSDN: + * If the surface is created using CreateImageSurface/CreateOffscreenPlainSurface, CreateRenderTarget, + * or CreateDepthStencilSurface, the surface is considered stand alone. In this case, + * GetContainer will return the Direct3D device used to create the surface. + */ + if (This->container) { + container = This->container; + } else { + container = (IWineD3DBase *)This->resource.wineD3DDevice; + } + + TRACE("Relaying to QueryInterface\n"); + return IUnknown_QueryInterface(container, riid, ppContainer); +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *pDesc) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + + TRACE("(%p) : copying into %p\n", This, pDesc); + if(pDesc->Format != NULL) *(pDesc->Format) = This->resource.format; + if(pDesc->Type != NULL) *(pDesc->Type) = This->resource.resourceType; + if(pDesc->Usage != NULL) *(pDesc->Usage) = This->resource.usage; + if(pDesc->Pool != NULL) *(pDesc->Pool) = This->resource.pool; + if(pDesc->Size != NULL) *(pDesc->Size) = This->resource.size; /* dx8 only */ + if(pDesc->MultiSampleType != NULL) *(pDesc->MultiSampleType) = This->currentDesc.MultiSampleType; + if(pDesc->MultiSampleQuality != NULL) *(pDesc->MultiSampleQuality) = This->currentDesc.MultiSampleQuality; + if(pDesc->Width != NULL) *(pDesc->Width) = This->currentDesc.Width; + if(pDesc->Height != NULL) *(pDesc->Height) = This->currentDesc.Height; + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetBltStatus(IWineD3DSurface *iface, DWORD Flags) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + TRACE("(%p)->(%x)\n", This, Flags); + + switch (Flags) + { + case WINEDDGBS_CANBLT: + case WINEDDGBS_ISBLTDONE: + return WINED3D_OK; + + default: + return WINED3DERR_INVALIDCALL; + } +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetFlipStatus(IWineD3DSurface *iface, DWORD Flags) { + /* XXX: DDERR_INVALIDSURFACETYPE */ + + TRACE("(%p)->(%08x)\n",iface,Flags); + switch (Flags) { + case WINEDDGFS_CANFLIP: + case WINEDDGFS_ISFLIPDONE: + return WINED3D_OK; + + default: + return WINED3DERR_INVALIDCALL; + } +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_IsLost(IWineD3DSurface *iface) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + TRACE("(%p)\n", This); + + /* D3D8 and 9 loose full devices, ddraw only surfaces */ + return This->Flags & SFLAG_LOST ? WINED3DERR_DEVICELOST : WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_Restore(IWineD3DSurface *iface) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + TRACE("(%p)\n", This); + + /* So far we don't lose anything :) */ + This->Flags &= ~SFLAG_LOST; + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPalette(IWineD3DSurface *iface, IWineD3DPalette *Pal) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + IWineD3DPaletteImpl *PalImpl = (IWineD3DPaletteImpl *) Pal; + TRACE("(%p)->(%p)\n", This, Pal); + + if(This->palette != NULL) + if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) + This->palette->Flags &= ~WINEDDPCAPS_PRIMARYSURFACE; + + if(PalImpl != NULL) { + if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) { + /* Set the device's main palette if the palette + * wasn't a primary palette before + */ + if(!(PalImpl->Flags & WINEDDPCAPS_PRIMARYSURFACE)) { + IWineD3DDeviceImpl *device = This->resource.wineD3DDevice; + unsigned int i; + + for(i=0; i < 256; i++) { + device->palettes[device->currentPalette][i] = PalImpl->palents[i]; + } + } + + (PalImpl)->Flags |= WINEDDPCAPS_PRIMARYSURFACE; + } + } + This->palette = PalImpl; + + return IWineD3DSurface_RealizePalette(iface); +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetColorKey(IWineD3DSurface *iface, DWORD Flags, WINEDDCOLORKEY *CKey) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + TRACE("(%p)->(%08x,%p)\n", This, Flags, CKey); + + if ((Flags & WINEDDCKEY_COLORSPACE) != 0) { + FIXME(" colorkey value not supported (%08x) !\n", Flags); + return WINED3DERR_INVALIDCALL; + } + + /* Dirtify the surface, but only if a key was changed */ + if(CKey) { + switch (Flags & ~WINEDDCKEY_COLORSPACE) { + case WINEDDCKEY_DESTBLT: + This->DestBltCKey = *CKey; + This->CKeyFlags |= WINEDDSD_CKDESTBLT; + break; + + case WINEDDCKEY_DESTOVERLAY: + This->DestOverlayCKey = *CKey; + This->CKeyFlags |= WINEDDSD_CKDESTOVERLAY; + break; + + case WINEDDCKEY_SRCOVERLAY: + This->SrcOverlayCKey = *CKey; + This->CKeyFlags |= WINEDDSD_CKSRCOVERLAY; + break; + + case WINEDDCKEY_SRCBLT: + This->SrcBltCKey = *CKey; + This->CKeyFlags |= WINEDDSD_CKSRCBLT; + break; + } + } + else { + switch (Flags & ~WINEDDCKEY_COLORSPACE) { + case WINEDDCKEY_DESTBLT: + This->CKeyFlags &= ~WINEDDSD_CKDESTBLT; + break; + + case WINEDDCKEY_DESTOVERLAY: + This->CKeyFlags &= ~WINEDDSD_CKDESTOVERLAY; + break; + + case WINEDDCKEY_SRCOVERLAY: + This->CKeyFlags &= ~WINEDDSD_CKSRCOVERLAY; + break; + + case WINEDDCKEY_SRCBLT: + This->CKeyFlags &= ~WINEDDSD_CKSRCBLT; + break; + } + } + + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPalette(IWineD3DSurface *iface, IWineD3DPalette **Pal) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + TRACE("(%p)->(%p)\n", This, Pal); + + *Pal = (IWineD3DPalette *) This->palette; + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_RealizePalette(IWineD3DSurface *iface) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + RGBQUAD col[256]; + IWineD3DPaletteImpl *pal = This->palette; + unsigned int n; + TRACE("(%p)\n", This); + + if(This->resource.format == WINED3DFMT_P8 || + This->resource.format == WINED3DFMT_A8P8) + { + if(!This->Flags & SFLAG_INSYSMEM) { + FIXME("Palette changed with surface that does not have an up to date system memory copy\n"); + } + TRACE("Dirtifying surface\n"); + IWineD3DSurface_ModifyLocation(iface, SFLAG_INSYSMEM, TRUE); + } + + if(This->Flags & SFLAG_DIBSECTION) { + TRACE("(%p): Updating the hdc's palette\n", This); + for (n=0; n<256; n++) { + if(pal) { + col[n].rgbRed = pal->palents[n].peRed; + col[n].rgbGreen = pal->palents[n].peGreen; + col[n].rgbBlue = pal->palents[n].peBlue; + } else { + IWineD3DDeviceImpl *device = This->resource.wineD3DDevice; + /* Use the default device palette */ + col[n].rgbRed = device->palettes[device->currentPalette][n].peRed; + col[n].rgbGreen = device->palettes[device->currentPalette][n].peGreen; + col[n].rgbBlue = device->palettes[device->currentPalette][n].peBlue; + } + col[n].rgbReserved = 0; + } + SetDIBColorTable(This->hDC, 0, 256, col); + } + + return WINED3D_OK; +} + +DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPitch(IWineD3DSurface *iface) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + DWORD ret; + TRACE("(%p)\n", This); + + /* DXTn formats don't have exact pitches as they are to the new row of blocks, + where each block is 4x4 pixels, 8 bytes (dxt1) and 16 bytes (dxt2/3/4/5) + ie pitch = (width/4) * bytes per block */ + if (This->resource.format == WINED3DFMT_DXT1) /* DXT1 is 8 bytes per block */ + ret = ((This->currentDesc.Width + 3) >> 2) << 3; + else if (This->resource.format == WINED3DFMT_DXT2 || This->resource.format == WINED3DFMT_DXT3 || + This->resource.format == WINED3DFMT_DXT4 || This->resource.format == WINED3DFMT_DXT5) /* DXT2/3/4/5 is 16 bytes per block */ + ret = ((This->currentDesc.Width + 3) >> 2) << 4; + else { + unsigned char alignment = This->resource.wineD3DDevice->surface_alignment; + ret = This->bytesPerPixel * This->currentDesc.Width; /* Bytes / row */ + ret = (ret + alignment - 1) & ~(alignment - 1); + } + TRACE("(%p) Returning %d\n", This, ret); + return ret; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetOverlayPosition(IWineD3DSurface *iface, LONG X, LONG Y) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + + FIXME("(%p)->(%d,%d) Stub!\n", This, X, Y); + + if(!(This->resource.usage & WINED3DUSAGE_OVERLAY)) + { + TRACE("(%p): Not an overlay surface\n", This); + return WINEDDERR_NOTAOVERLAYSURFACE; + } + + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetOverlayPosition(IWineD3DSurface *iface, LONG *X, LONG *Y) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + + FIXME("(%p)->(%p,%p) Stub!\n", This, X, Y); + + if(!(This->resource.usage & WINED3DUSAGE_OVERLAY)) + { + TRACE("(%p): Not an overlay surface\n", This); + return WINEDDERR_NOTAOVERLAYSURFACE; + } + + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder(IWineD3DSurface *iface, DWORD Flags, IWineD3DSurface *Ref) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + IWineD3DSurfaceImpl *RefImpl = (IWineD3DSurfaceImpl *) Ref; + + FIXME("(%p)->(%08x,%p) Stub!\n", This, Flags, RefImpl); + + if(!(This->resource.usage & WINED3DUSAGE_OVERLAY)) + { + TRACE("(%p): Not an overlay surface\n", This); + return WINEDDERR_NOTAOVERLAYSURFACE; + } + + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlay(IWineD3DSurface *iface, RECT *SrcRect, IWineD3DSurface *DstSurface, RECT *DstRect, DWORD Flags, WINEDDOVERLAYFX *FX) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + IWineD3DSurfaceImpl *Dst = (IWineD3DSurfaceImpl *) DstSurface; + FIXME("(%p)->(%p, %p, %p, %08x, %p)\n", This, SrcRect, Dst, DstRect, Flags, FX); + + if(!(This->resource.usage & WINED3DUSAGE_OVERLAY)) + { + TRACE("(%p): Not an overlay surface\n", This); + return WINEDDERR_NOTAOVERLAYSURFACE; + } + + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetClipper(IWineD3DSurface *iface, IWineD3DClipper *clipper) +{ + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + TRACE("(%p)->(%p)\n", This, clipper); + + This->clipper = clipper; + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetClipper(IWineD3DSurface *iface, IWineD3DClipper **clipper) +{ + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + TRACE("(%p)->(%p)\n", This, clipper); + + *clipper = This->clipper; + if(*clipper) { + IWineD3DClipper_AddRef(*clipper); + } + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetContainer(IWineD3DSurface *iface, IWineD3DBase *container) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + + TRACE("This %p, container %p\n", This, container); + + /* We can't keep a reference to the container, since the container already keeps a reference to us. */ + + TRACE("Setting container to %p from %p\n", container, This->container); + This->container = container; + + return WINED3D_OK; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + const StaticPixelFormatDesc *formatEntry = getFormatDescEntry(format, NULL, NULL); + + if (This->resource.format != WINED3DFMT_UNKNOWN) { + FIXME("(%p) : The format of the surface must be WINED3DFORMAT_UNKNOWN\n", This); + return WINED3DERR_INVALIDCALL; + } + + TRACE("(%p) : Setting texture format to (%d,%s)\n", This, format, debug_d3dformat(format)); + if (format == WINED3DFMT_UNKNOWN) { + This->resource.size = 0; + } else if (format == WINED3DFMT_DXT1) { + /* DXT1 is half byte per pixel */ + This->resource.size = ((max(This->pow2Width, 4) * formatEntry->bpp) * max(This->pow2Height, 4)) >> 1; + + } else if (format == WINED3DFMT_DXT2 || format == WINED3DFMT_DXT3 || + format == WINED3DFMT_DXT4 || format == WINED3DFMT_DXT5) { + This->resource.size = ((max(This->pow2Width, 4) * formatEntry->bpp) * max(This->pow2Height, 4)); + } else { + unsigned char alignment = This->resource.wineD3DDevice->surface_alignment; + This->resource.size = ((This->pow2Width * formatEntry->bpp) + alignment - 1) & ~(alignment - 1); + This->resource.size *= This->pow2Height; + } + + if (format != WINED3DFMT_UNKNOWN) { + This->bytesPerPixel = formatEntry->bpp; + } else { + This->bytesPerPixel = 0; + } + + This->Flags |= (WINED3DFMT_D16_LOCKABLE == format) ? SFLAG_LOCKABLE : 0; + + This->resource.format = format; + + TRACE("(%p) : Size %d, bytesPerPixel %d\n", This, This->resource.size, This->bytesPerPixel); + + return WINED3D_OK; +} + +HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface) { + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + int extraline = 0; + SYSTEM_INFO sysInfo; + BITMAPINFO* b_info; + HDC ddc; + DWORD *masks; + const StaticPixelFormatDesc *formatEntry = getFormatDescEntry(This->resource.format, NULL, NULL); + UINT usage; + + switch (This->bytesPerPixel) { + case 2: + case 4: + /* Allocate extra space to store the RGB bit masks. */ + b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD)); + break; + + case 3: + b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER)); + break; + + default: + /* Allocate extra space for a palette. */ + b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + sizeof(BITMAPINFOHEADER) + + sizeof(RGBQUAD) + * (1 << (This->bytesPerPixel * 8))); + break; + } + + if (!b_info) + return E_OUTOFMEMORY; + + /* Some apps access the surface in via DWORDs, and do not take the necessary care at the end of the + * surface. So we need at least extra 4 bytes at the end of the surface. Check against the page size, + * if the last page used for the surface has at least 4 spare bytes we're safe, otherwise + * add an extra line to the dib section + */ + GetSystemInfo(&sysInfo); + if( ((This->resource.size + 3) % sysInfo.dwPageSize) < 4) { + extraline = 1; + TRACE("Adding an extra line to the dib section\n"); + } + + b_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + /* TODO: Is there a nicer way to force a specific alignment? (8 byte for ddraw) */ + b_info->bmiHeader.biWidth = IWineD3DSurface_GetPitch(iface) / This->bytesPerPixel; + b_info->bmiHeader.biHeight = -This->currentDesc.Height -extraline; + b_info->bmiHeader.biSizeImage = ( This->currentDesc.Height + extraline) * IWineD3DSurface_GetPitch(iface); + b_info->bmiHeader.biPlanes = 1; + b_info->bmiHeader.biBitCount = This->bytesPerPixel * 8; + + b_info->bmiHeader.biXPelsPerMeter = 0; + b_info->bmiHeader.biYPelsPerMeter = 0; + b_info->bmiHeader.biClrUsed = 0; + b_info->bmiHeader.biClrImportant = 0; + + /* Get the bit masks */ + masks = (DWORD *) &(b_info->bmiColors); + switch (This->resource.format) { + case WINED3DFMT_R8G8B8: + usage = DIB_RGB_COLORS; + b_info->bmiHeader.biCompression = BI_RGB; + break; + + case WINED3DFMT_X1R5G5B5: + case WINED3DFMT_A1R5G5B5: + case WINED3DFMT_A4R4G4B4: + case WINED3DFMT_X4R4G4B4: + case WINED3DFMT_R3G3B2: + case WINED3DFMT_A8R3G3B2: + case WINED3DFMT_A2B10G10R10: + case WINED3DFMT_A8B8G8R8: + case WINED3DFMT_X8B8G8R8: + case WINED3DFMT_A2R10G10B10: + case WINED3DFMT_R5G6B5: + case WINED3DFMT_A16B16G16R16: + usage = 0; + b_info->bmiHeader.biCompression = BI_BITFIELDS; + masks[0] = formatEntry->redMask; + masks[1] = formatEntry->greenMask; + masks[2] = formatEntry->blueMask; + break; + + default: + /* Don't know palette */ + b_info->bmiHeader.biCompression = BI_RGB; + usage = 0; + break; + } + + ddc = GetDC(0); + if (ddc == 0) { + HeapFree(GetProcessHeap(), 0, b_info); + return HRESULT_FROM_WIN32(GetLastError()); + } + + TRACE("Creating a DIB section with size %dx%dx%d, size=%d\n", b_info->bmiHeader.biWidth, b_info->bmiHeader.biHeight, b_info->bmiHeader.biBitCount, b_info->bmiHeader.biSizeImage); + This->dib.DIBsection = CreateDIBSection(ddc, b_info, usage, &This->dib.bitmap_data, 0 /* Handle */, 0 /* Offset */); + ReleaseDC(0, ddc); + + if (!This->dib.DIBsection) { + ERR("CreateDIBSection failed!\n"); + HeapFree(GetProcessHeap(), 0, b_info); + return HRESULT_FROM_WIN32(GetLastError()); + } + + TRACE("DIBSection at : %p\n", This->dib.bitmap_data); + /* copy the existing surface to the dib section */ + if(This->resource.allocatedMemory) { + memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, b_info->bmiHeader.biSizeImage); + } else { + /* This is to make LockRect read the gl Texture although memory is allocated */ + This->Flags &= ~SFLAG_INSYSMEM; + } + This->dib.bitmap_size = b_info->bmiHeader.biSizeImage; + + HeapFree(GetProcessHeap(), 0, b_info); + + /* Now allocate a HDC */ + This->hDC = CreateCompatibleDC(0); + This->dib.holdbitmap = SelectObject(This->hDC, This->dib.DIBsection); + TRACE("using wined3d palette %p\n", This->palette); + SelectPalette(This->hDC, + This->palette ? This->palette->hpal : 0, + FALSE); + + This->Flags |= SFLAG_DIBSECTION; + + HeapFree(GetProcessHeap(), 0, This->resource.heapMemory); + This->resource.heapMemory = NULL; + + return WINED3D_OK; +} + +/***************************************************************************** + * _Blt_ColorFill + * + * Helper function that fills a memory area with a specific color + * + * Params: + * buf: memory address to start filling at + * width, height: Dimensions of the area to fill + * bpp: Bit depth of the surface + * lPitch: pitch of the surface + * color: Color to fill with + * + *****************************************************************************/ +static HRESULT + _Blt_ColorFill(BYTE *buf, + int width, int height, + int bpp, LONG lPitch, + DWORD color) +{ + int x, y; + LPBYTE first; + + /* Do first row */ + +#define COLORFILL_ROW(type) \ + { \ + type *d = (type *) buf; \ + for (x = 0; x < width; x++) \ + d[x] = (type) color; \ + break; \ +} + switch(bpp) + { + case 1: COLORFILL_ROW(BYTE) + case 2: COLORFILL_ROW(WORD) + case 3: + { + BYTE *d = (BYTE *) buf; + for (x = 0; x < width; x++,d+=3) + { + d[0] = (color ) & 0xFF; + d[1] = (color>> 8) & 0xFF; + d[2] = (color>>16) & 0xFF; + } + break; + } + case 4: COLORFILL_ROW(DWORD) + default: + FIXME("Color fill not implemented for bpp %d!\n", bpp*8); + return WINED3DERR_NOTAVAILABLE; + } + +#undef COLORFILL_ROW + + /* Now copy first row */ + first = buf; + for (y = 1; y < height; y++) + { + buf += lPitch; + memcpy(buf, first, width * bpp); + } + return WINED3D_OK; +} + +/***************************************************************************** + * IWineD3DSurface::Blt, SW emulation version + * + * Performs blits to a surface, eigher from a source of source-less blts + * This is the main functionality of DirectDraw + * + * Params: + * DestRect: Destination rectangle to write to + * SrcSurface: Source surface, can be NULL + * SrcRect: Source rectangle + *****************************************************************************/ +HRESULT WINAPI +IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, + RECT *DestRect, + IWineD3DSurface *SrcSurface, + RECT *SrcRect, + DWORD Flags, + WINEDDBLTFX *DDBltFx, + WINED3DTEXTUREFILTERTYPE Filter) +{ + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface; + RECT xdst,xsrc; + HRESULT ret = WINED3D_OK; + WINED3DLOCKED_RECT dlock, slock; + WINED3DFORMAT dfmt = WINED3DFMT_UNKNOWN, sfmt = WINED3DFMT_UNKNOWN; + int bpp, srcheight, srcwidth, dstheight, dstwidth, width; + int x, y; + const StaticPixelFormatDesc *sEntry, *dEntry; + LPBYTE dbuf, sbuf; + TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This, DestRect, Src, SrcRect, Flags, DDBltFx); + + if (TRACE_ON(d3d_surface)) + { + if (DestRect) TRACE("\tdestrect :%dx%d-%dx%d\n", + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom); + if (SrcRect) TRACE("\tsrcrect :%dx%d-%dx%d\n", + SrcRect->left, SrcRect->top, SrcRect->right, SrcRect->bottom); +#if 0 + TRACE("\tflags: "); + DDRAW_dump_DDBLT(Flags); + if (Flags & WINEDDBLT_DDFX) + { + TRACE("\tblitfx: "); + DDRAW_dump_DDBLTFX(DDBltFx->dwDDFX); + } +#endif + } + + if ( (This->Flags & SFLAG_LOCKED) || ((Src != NULL) && (Src->Flags & SFLAG_LOCKED))) + { + WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n"); + return WINEDDERR_SURFACEBUSY; + } + + if(Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) { + /* Can happen when d3d9 apps do a StretchRect call which isn't handled in gl */ + FIXME("Filters not supported in software blit\n"); + } + + if (Src == This) + { + IWineD3DSurface_LockRect(iface, &dlock, NULL, 0); + dfmt = This->resource.format; + slock = dlock; + sfmt = dfmt; + sEntry = getFormatDescEntry(sfmt, NULL, NULL); + dEntry = sEntry; + } + else + { + if (Src) + { + IWineD3DSurface_LockRect(SrcSurface, &slock, NULL, WINED3DLOCK_READONLY); + sfmt = Src->resource.format; + } + sEntry = getFormatDescEntry(sfmt, NULL, NULL); + dfmt = This->resource.format; + dEntry = getFormatDescEntry(dfmt, NULL, NULL); + IWineD3DSurface_LockRect(iface, &dlock,NULL,0); + } + + if (!DDBltFx || !(DDBltFx->dwDDFX)) Flags &= ~WINEDDBLT_DDFX; + + if (sEntry->isFourcc && dEntry->isFourcc) + { + if (sfmt != dfmt) + { + FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n"); + ret = WINED3DERR_WRONGTEXTUREFORMAT; + goto release; + } + memcpy(dlock.pBits, slock.pBits, This->resource.size); + goto release; + } + + if (sEntry->isFourcc && !dEntry->isFourcc) + { + FIXME("DXTC decompression not supported right now\n"); + goto release; + } + + if (DestRect) + { + memcpy(&xdst,DestRect,sizeof(xdst)); + } + else + { + xdst.top = 0; + xdst.bottom = This->currentDesc.Height; + xdst.left = 0; + xdst.right = This->currentDesc.Width; + } + + if (SrcRect) + { + memcpy(&xsrc,SrcRect,sizeof(xsrc)); + } + else + { + if (Src) + { + xsrc.top = 0; + xsrc.bottom = Src->currentDesc.Height; + xsrc.left = 0; + xsrc.right = Src->currentDesc.Width; + } + else + { + memset(&xsrc,0,sizeof(xsrc)); + } + } + + /* First check for the validity of source / destination rectangles. This was + * verified using a test application + by MSDN. + */ + if ((Src != NULL) && + ((xsrc.bottom > Src->currentDesc.Height) || (xsrc.bottom < 0) || + (xsrc.top > Src->currentDesc.Height) || (xsrc.top < 0) || + (xsrc.left > Src->currentDesc.Width) || (xsrc.left < 0) || + (xsrc.right > Src->currentDesc.Width) || (xsrc.right < 0) || + (xsrc.right < xsrc.left) || (xsrc.bottom < xsrc.top))) + { + WARN("Application gave us bad source rectangle for Blt.\n"); + ret = WINEDDERR_INVALIDRECT; + goto release; + } + /* For the Destination rect, it can be out of bounds on the condition that a clipper + * is set for the given surface. + */ + if ((/*This->clipper == NULL*/ TRUE) && + ((xdst.bottom > This->currentDesc.Height) || (xdst.bottom < 0) || + (xdst.top > This->currentDesc.Height) || (xdst.top < 0) || + (xdst.left > This->currentDesc.Width) || (xdst.left < 0) || + (xdst.right > This->currentDesc.Width) || (xdst.right < 0) || + (xdst.right < xdst.left) || (xdst.bottom < xdst.top))) + { + WARN("Application gave us bad destination rectangle for Blt without a clipper set.\n"); + ret = WINEDDERR_INVALIDRECT; + goto release; + } + + /* Now handle negative values in the rectangles. Warning: only supported for now + in the 'simple' cases (ie not in any stretching / rotation cases). + + First, the case where nothing is to be done. + */ + if (((xdst.bottom <= 0) || (xdst.right <= 0) || + (xdst.top >= (int) This->currentDesc.Height) || + (xdst.left >= (int) This->currentDesc.Width)) || + ((Src != NULL) && + ((xsrc.bottom <= 0) || (xsrc.right <= 0) || + (xsrc.top >= (int) Src->currentDesc.Height) || + (xsrc.left >= (int) Src->currentDesc.Width)) )) + { + TRACE("Nothing to be done !\n"); + goto release; + } + + /* The easy case : the source-less blits.... */ + if (Src == NULL) + { + RECT full_rect; + RECT temp_rect; /* No idea if intersect rect can be the same as one of the source rect */ + + full_rect.left = 0; + full_rect.top = 0; + full_rect.right = This->currentDesc.Width; + full_rect.bottom = This->currentDesc.Height; + IntersectRect(&temp_rect, &full_rect, &xdst); + xdst = temp_rect; + } + else + { + /* Only handle clipping on the destination rectangle */ + int clip_horiz = (xdst.left < 0) || (xdst.right > (int) This->currentDesc.Width ); + int clip_vert = (xdst.top < 0) || (xdst.bottom > (int) This->currentDesc.Height); + if (clip_vert || clip_horiz) + { + /* Now check if this is a special case or not... */ + if ((((xdst.bottom - xdst.top ) != (xsrc.bottom - xsrc.top )) && clip_vert ) || + (((xdst.right - xdst.left) != (xsrc.right - xsrc.left)) && clip_horiz) || + (Flags & WINEDDBLT_DDFX)) + { + WARN("Out of screen rectangle in special case. Not handled right now.\n"); + goto release; + } + + if (clip_horiz) + { + if (xdst.left < 0) { xsrc.left -= xdst.left; xdst.left = 0; } + if (xdst.right > This->currentDesc.Width) + { + xsrc.right -= (xdst.right - (int) This->currentDesc.Width); + xdst.right = (int) This->currentDesc.Width; + } + } + if (clip_vert) + { + if (xdst.top < 0) + { + xsrc.top -= xdst.top; + xdst.top = 0; + } + if (xdst.bottom > This->currentDesc.Height) + { + xsrc.bottom -= (xdst.bottom - (int) This->currentDesc.Height); + xdst.bottom = (int) This->currentDesc.Height; + } + } + /* And check if after clipping something is still to be done... */ + if ((xdst.bottom <= 0) || (xdst.right <= 0) || + (xdst.top >= (int) This->currentDesc.Height) || + (xdst.left >= (int) This->currentDesc.Width) || + (xsrc.bottom <= 0) || (xsrc.right <= 0) || + (xsrc.top >= (int) Src->currentDesc.Height) || + (xsrc.left >= (int) Src->currentDesc.Width)) + { + TRACE("Nothing to be done after clipping !\n"); + goto release; + } + } + } + + bpp = This->bytesPerPixel; + srcheight = xsrc.bottom - xsrc.top; + srcwidth = xsrc.right - xsrc.left; + dstheight = xdst.bottom - xdst.top; + dstwidth = xdst.right - xdst.left; + width = (xdst.right - xdst.left) * bpp; + + assert(width <= dlock.Pitch); + + dbuf = (BYTE*)dlock.pBits+(xdst.top*dlock.Pitch)+(xdst.left*bpp); + + if (Flags & WINEDDBLT_WAIT) + { + Flags &= ~WINEDDBLT_WAIT; + } + if (Flags & WINEDDBLT_ASYNC) + { + static BOOL displayed = FALSE; + if (!displayed) + FIXME("Can't handle WINEDDBLT_ASYNC flag right now.\n"); + displayed = TRUE; + Flags &= ~WINEDDBLT_ASYNC; + } + if (Flags & WINEDDBLT_DONOTWAIT) + { + /* WINEDDBLT_DONOTWAIT appeared in DX7 */ + static BOOL displayed = FALSE; + if (!displayed) + FIXME("Can't handle WINEDDBLT_DONOTWAIT flag right now.\n"); + displayed = TRUE; + Flags &= ~WINEDDBLT_DONOTWAIT; + } + + /* First, all the 'source-less' blits */ + if (Flags & WINEDDBLT_COLORFILL) + { + ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp, + dlock.Pitch, DDBltFx->u5.dwFillColor); + Flags &= ~WINEDDBLT_COLORFILL; + } + + if (Flags & WINEDDBLT_DEPTHFILL) + { + FIXME("DDBLT_DEPTHFILL needs to be implemented!\n"); + } + if (Flags & WINEDDBLT_ROP) + { + /* Catch some degenerate cases here */ + switch(DDBltFx->dwROP) + { + case BLACKNESS: + ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,dlock.Pitch,0); + break; + case 0xAA0029: /* No-op */ + break; + case WHITENESS: + ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,dlock.Pitch,~0); + break; + case SRCCOPY: /* well, we do that below ? */ + break; + default: + FIXME("Unsupported raster op: %08x Pattern: %p\n", DDBltFx->dwROP, DDBltFx->u5.lpDDSPattern); + goto error; + } + Flags &= ~WINEDDBLT_ROP; + } + if (Flags & WINEDDBLT_DDROPS) + { + FIXME("\tDdraw Raster Ops: %08x Pattern: %p\n", DDBltFx->dwDDROP, DDBltFx->u5.lpDDSPattern); + } + /* Now the 'with source' blits */ + if (Src) + { + LPBYTE sbase; + int sx, xinc, sy, yinc; + + if (!dstwidth || !dstheight) /* hmm... stupid program ? */ + goto release; + sbase = (BYTE*)slock.pBits+(xsrc.top*slock.Pitch)+xsrc.left*bpp; + xinc = (srcwidth << 16) / dstwidth; + yinc = (srcheight << 16) / dstheight; + + if (!Flags) + { + /* No effects, we can cheat here */ + if (dstwidth == srcwidth) + { + if (dstheight == srcheight) + { + /* No stretching in either direction. This needs to be as + * fast as possible */ + sbuf = sbase; + + /* check for overlapping surfaces */ + if (SrcSurface != iface || xdst.top < xsrc.top || + xdst.right <= xsrc.left || xsrc.right <= xdst.left) + { + /* no overlap, or dst above src, so copy from top downwards */ + for (y = 0; y < dstheight; y++) + { + memcpy(dbuf, sbuf, width); + sbuf += slock.Pitch; + dbuf += dlock.Pitch; + } + } + else if (xdst.top > xsrc.top) /* copy from bottom upwards */ + { + sbuf += (slock.Pitch*dstheight); + dbuf += (dlock.Pitch*dstheight); + for (y = 0; y < dstheight; y++) + { + sbuf -= slock.Pitch; + dbuf -= dlock.Pitch; + memcpy(dbuf, sbuf, width); + } + } + else /* src and dst overlapping on the same line, use memmove */ + { + for (y = 0; y < dstheight; y++) + { + memmove(dbuf, sbuf, width); + sbuf += slock.Pitch; + dbuf += dlock.Pitch; + } + } + } else { + /* Stretching in Y direction only */ + for (y = sy = 0; y < dstheight; y++, sy += yinc) { + sbuf = sbase + (sy >> 16) * slock.Pitch; + memcpy(dbuf, sbuf, width); + dbuf += dlock.Pitch; + } + } + } + else + { + /* Stretching in X direction */ + int last_sy = -1; + for (y = sy = 0; y < dstheight; y++, sy += yinc) + { + sbuf = sbase + (sy >> 16) * slock.Pitch; + + if ((sy >> 16) == (last_sy >> 16)) + { + /* this sourcerow is the same as last sourcerow - + * copy already stretched row + */ + memcpy(dbuf, dbuf - dlock.Pitch, width); + } + else + { +#define STRETCH_ROW(type) { \ + type *s = (type *) sbuf, *d = (type *) dbuf; \ + for (x = sx = 0; x < dstwidth; x++, sx += xinc) \ + d[x] = s[sx >> 16]; \ + break; } + + switch(bpp) + { + case 1: STRETCH_ROW(BYTE) + case 2: STRETCH_ROW(WORD) + case 4: STRETCH_ROW(DWORD) + case 3: + { + LPBYTE s,d = dbuf; + for (x = sx = 0; x < dstwidth; x++, sx+= xinc) + { + DWORD pixel; + + s = sbuf+3*(sx>>16); + pixel = s[0]|(s[1]<<8)|(s[2]<<16); + d[0] = (pixel )&0xff; + d[1] = (pixel>> 8)&0xff; + d[2] = (pixel>>16)&0xff; + d+=3; + } + break; + } + default: + FIXME("Stretched blit not implemented for bpp %d!\n", bpp*8); + ret = WINED3DERR_NOTAVAILABLE; + goto error; + } +#undef STRETCH_ROW + } + dbuf += dlock.Pitch; + last_sy = sy; + } + } + } + else + { + LONG dstyinc = dlock.Pitch, dstxinc = bpp; + DWORD keylow = 0xFFFFFFFF, keyhigh = 0, keymask = 0xFFFFFFFF; + DWORD destkeylow = 0x0, destkeyhigh = 0xFFFFFFFF, destkeymask = 0xFFFFFFFF; + if (Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYDEST | WINEDDBLT_KEYSRCOVERRIDE | WINEDDBLT_KEYDESTOVERRIDE)) + { + /* The color keying flags are checked for correctness in ddraw */ + if (Flags & WINEDDBLT_KEYSRC) + { + keylow = Src->SrcBltCKey.dwColorSpaceLowValue; + keyhigh = Src->SrcBltCKey.dwColorSpaceHighValue; + } + else if (Flags & WINEDDBLT_KEYSRCOVERRIDE) + { + keylow = DDBltFx->ddckSrcColorkey.dwColorSpaceLowValue; + keyhigh = DDBltFx->ddckSrcColorkey.dwColorSpaceHighValue; + } + + if (Flags & WINEDDBLT_KEYDEST) + { + /* Destination color keys are taken from the source surface ! */ + destkeylow = Src->DestBltCKey.dwColorSpaceLowValue; + destkeyhigh = Src->DestBltCKey.dwColorSpaceHighValue; + } + else if (Flags & WINEDDBLT_KEYDESTOVERRIDE) + { + destkeylow = DDBltFx->ddckDestColorkey.dwColorSpaceLowValue; + destkeyhigh = DDBltFx->ddckDestColorkey.dwColorSpaceHighValue; + } + + if(bpp == 1) + { + keymask = 0xff; + } + else + { + keymask = sEntry->redMask | + sEntry->greenMask | + sEntry->blueMask; + } + Flags &= ~(WINEDDBLT_KEYSRC | WINEDDBLT_KEYDEST | WINEDDBLT_KEYSRCOVERRIDE | WINEDDBLT_KEYDESTOVERRIDE); + } + + if (Flags & WINEDDBLT_DDFX) + { + LPBYTE dTopLeft, dTopRight, dBottomLeft, dBottomRight, tmp; + LONG tmpxy; + dTopLeft = dbuf; + dTopRight = dbuf+((dstwidth-1)*bpp); + dBottomLeft = dTopLeft+((dstheight-1)*dlock.Pitch); + dBottomRight = dBottomLeft+((dstwidth-1)*bpp); + + if (DDBltFx->dwDDFX & WINEDDBLTFX_ARITHSTRETCHY) + { + /* I don't think we need to do anything about this flag */ + WARN("Flags=DDBLT_DDFX nothing done for WINEDDBLTFX_ARITHSTRETCHY\n"); + } + if (DDBltFx->dwDDFX & WINEDDBLTFX_MIRRORLEFTRIGHT) + { + tmp = dTopRight; + dTopRight = dTopLeft; + dTopLeft = tmp; + tmp = dBottomRight; + dBottomRight = dBottomLeft; + dBottomLeft = tmp; + dstxinc = dstxinc *-1; + } + if (DDBltFx->dwDDFX & WINEDDBLTFX_MIRRORUPDOWN) + { + tmp = dTopLeft; + dTopLeft = dBottomLeft; + dBottomLeft = tmp; + tmp = dTopRight; + dTopRight = dBottomRight; + dBottomRight = tmp; + dstyinc = dstyinc *-1; + } + if (DDBltFx->dwDDFX & WINEDDBLTFX_NOTEARING) + { + /* I don't think we need to do anything about this flag */ + WARN("Flags=DDBLT_DDFX nothing done for WINEDDBLTFX_NOTEARING\n"); + } + if (DDBltFx->dwDDFX & WINEDDBLTFX_ROTATE180) + { + tmp = dBottomRight; + dBottomRight = dTopLeft; + dTopLeft = tmp; + tmp = dBottomLeft; + dBottomLeft = dTopRight; + dTopRight = tmp; + dstxinc = dstxinc * -1; + dstyinc = dstyinc * -1; + } + if (DDBltFx->dwDDFX & WINEDDBLTFX_ROTATE270) + { + tmp = dTopLeft; + dTopLeft = dBottomLeft; + dBottomLeft = dBottomRight; + dBottomRight = dTopRight; + dTopRight = tmp; + tmpxy = dstxinc; + dstxinc = dstyinc; + dstyinc = tmpxy; + dstxinc = dstxinc * -1; + } + if (DDBltFx->dwDDFX & WINEDDBLTFX_ROTATE90) + { + tmp = dTopLeft; + dTopLeft = dTopRight; + dTopRight = dBottomRight; + dBottomRight = dBottomLeft; + dBottomLeft = tmp; + tmpxy = dstxinc; + dstxinc = dstyinc; + dstyinc = tmpxy; + dstyinc = dstyinc * -1; + } + if (DDBltFx->dwDDFX & WINEDDBLTFX_ZBUFFERBASEDEST) + { + /* I don't think we need to do anything about this flag */ + WARN("Flags=WINEDDBLT_DDFX nothing done for WINEDDBLTFX_ZBUFFERBASEDEST\n"); + } + dbuf = dTopLeft; + Flags &= ~(WINEDDBLT_DDFX); + } + +#define COPY_COLORKEY_FX(type) { \ + type *s, *d = (type *) dbuf, *dx, tmp; \ + for (y = sy = 0; y < dstheight; y++, sy += yinc) { \ + s = (type*)(sbase + (sy >> 16) * slock.Pitch); \ + dx = d; \ + for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \ + tmp = s[sx >> 16]; \ + if (((tmp & keymask) < keylow || (tmp & keymask) > keyhigh) && \ + ((dx[0] & destkeymask) >= destkeylow && (dx[0] & destkeymask) <= destkeyhigh)) { \ + dx[0] = tmp; \ + } \ + dx = (type*)(((LPBYTE)dx)+dstxinc); \ + } \ + d = (type*)(((LPBYTE)d)+dstyinc); \ + } \ + break; } + + switch (bpp) { + case 1: COPY_COLORKEY_FX(BYTE) + case 2: COPY_COLORKEY_FX(WORD) + case 4: COPY_COLORKEY_FX(DWORD) + case 3: + { + LPBYTE s,d = dbuf, dx; + for (y = sy = 0; y < dstheight; y++, sy += yinc) + { + sbuf = sbase + (sy >> 16) * slock.Pitch; + dx = d; + for (x = sx = 0; x < dstwidth; x++, sx+= xinc) + { + DWORD pixel, dpixel = 0; + s = sbuf+3*(sx>>16); + pixel = s[0]|(s[1]<<8)|(s[2]<<16); + dpixel = dx[0]|(dx[1]<<8)|(dx[2]<<16); + if (((pixel & keymask) < keylow || (pixel & keymask) > keyhigh) && + ((dpixel & keymask) >= destkeylow || (dpixel & keymask) <= keyhigh)) + { + dx[0] = (pixel )&0xff; + dx[1] = (pixel>> 8)&0xff; + dx[2] = (pixel>>16)&0xff; + } + dx+= dstxinc; + } + d += dstyinc; + } + break; + } + default: + FIXME("%s color-keyed blit not implemented for bpp %d!\n", + (Flags & WINEDDBLT_KEYSRC) ? "Source" : "Destination", bpp*8); + ret = WINED3DERR_NOTAVAILABLE; + goto error; +#undef COPY_COLORKEY_FX + } + } + } + +error: + if (Flags && FIXME_ON(d3d_surface)) + { + FIXME("\tUnsupported flags: %08x\n", Flags); + } + +release: + IWineD3DSurface_UnlockRect(iface); + if (SrcSurface && SrcSurface != iface) IWineD3DSurface_UnlockRect(SrcSurface); + return ret; +} + +/***************************************************************************** + * IWineD3DSurface::BltFast, SW emulation version + * + * This is the software implementation of BltFast, as used by GDI surfaces + * and as a fallback for OpenGL surfaces. This code is taken from the old + * DirectDraw code, and was originally written by TransGaming. + * + * Params: + * dstx: + * dsty: + * Source: Source surface to copy from + * rsrc: Source rectangle + * trans: Some Flags + * + * Returns: + * WINED3D_OK on success + * + *****************************************************************************/ +HRESULT WINAPI +IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, + DWORD dstx, + DWORD dsty, + IWineD3DSurface *Source, + RECT *rsrc, + DWORD trans) +{ + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface; + IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) Source; + + int bpp, w, h, x, y; + WINED3DLOCKED_RECT dlock,slock; + HRESULT ret = WINED3D_OK; + RECT rsrc2; + RECT lock_src, lock_dst, lock_union; + BYTE *sbuf, *dbuf; + const StaticPixelFormatDesc *sEntry, *dEntry; + + if (TRACE_ON(d3d_surface)) + { + TRACE("(%p)->(%d,%d,%p,%p,%08x)\n", This,dstx,dsty,Src,rsrc,trans); + + if (rsrc) + { + TRACE("\tsrcrect: %dx%d-%dx%d\n",rsrc->left,rsrc->top, + rsrc->right,rsrc->bottom); + } + else + { + TRACE(" srcrect: NULL\n"); + } + } + + if ((This->Flags & SFLAG_LOCKED) || + ((Src != NULL) && (Src->Flags & SFLAG_LOCKED))) + { + WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n"); + return WINEDDERR_SURFACEBUSY; + } + + if (!rsrc) + { + WARN("rsrc is NULL!\n"); + rsrc = &rsrc2; + rsrc->left = 0; + rsrc->top = 0; + rsrc->right = Src->currentDesc.Width; + rsrc->bottom = Src->currentDesc.Height; + } + + /* Check source rect for validity. Copied from normal Blt. Fixes Baldur's Gate.*/ + if ((rsrc->bottom > Src->currentDesc.Height) || (rsrc->bottom < 0) || + (rsrc->top > Src->currentDesc.Height) || (rsrc->top < 0) || + (rsrc->left > Src->currentDesc.Width) || (rsrc->left < 0) || + (rsrc->right > Src->currentDesc.Width) || (rsrc->right < 0) || + (rsrc->right < rsrc->left) || (rsrc->bottom < rsrc->top)) + { + WARN("Application gave us bad source rectangle for BltFast.\n"); + return WINEDDERR_INVALIDRECT; + } + + h = rsrc->bottom - rsrc->top; + if (h > This->currentDesc.Height-dsty) h = This->currentDesc.Height-dsty; + if (h > Src->currentDesc.Height-rsrc->top) h=Src->currentDesc.Height-rsrc->top; + if (h <= 0) return WINEDDERR_INVALIDRECT; + + w = rsrc->right - rsrc->left; + if (w > This->currentDesc.Width-dstx) w = This->currentDesc.Width-dstx; + if (w > Src->currentDesc.Width-rsrc->left) w = Src->currentDesc.Width-rsrc->left; + if (w <= 0) return WINEDDERR_INVALIDRECT; + + /* Now compute the locking rectangle... */ + lock_src.left = rsrc->left; + lock_src.top = rsrc->top; + lock_src.right = lock_src.left + w; + lock_src.bottom = lock_src.top + h; + + lock_dst.left = dstx; + lock_dst.top = dsty; + lock_dst.right = dstx + w; + lock_dst.bottom = dsty + h; + + bpp = This->bytesPerPixel; + + /* We need to lock the surfaces, or we won't get refreshes when done. */ + if (Src == This) + { + int pitch; + + UnionRect(&lock_union, &lock_src, &lock_dst); + + /* Lock the union of the two rectangles */ + ret = IWineD3DSurface_LockRect(iface, &dlock, &lock_union, 0); + if(ret != WINED3D_OK) goto error; + + pitch = dlock.Pitch; + slock.Pitch = dlock.Pitch; + + /* Since slock was originally copied from this surface's description, we can just reuse it */ + assert(This->resource.allocatedMemory != NULL); + sbuf = (BYTE *)This->resource.allocatedMemory + lock_src.top * pitch + lock_src.left * bpp; + dbuf = (BYTE *)This->resource.allocatedMemory + lock_dst.top * pitch + lock_dst.left * bpp; + sEntry = getFormatDescEntry(Src->resource.format, NULL, NULL); + dEntry = sEntry; + } + else + { + ret = IWineD3DSurface_LockRect(Source, &slock, &lock_src, WINED3DLOCK_READONLY); + if(ret != WINED3D_OK) goto error; + ret = IWineD3DSurface_LockRect(iface, &dlock, &lock_dst, 0); + if(ret != WINED3D_OK) goto error; + + sbuf = slock.pBits; + dbuf = dlock.pBits; + TRACE("Dst is at %p, Src is at %p\n", dbuf, sbuf); + + sEntry = getFormatDescEntry(Src->resource.format, NULL, NULL); + dEntry = getFormatDescEntry(This->resource.format, NULL, NULL); + } + + /* Handle first the FOURCC surfaces... */ + if (sEntry->isFourcc && dEntry->isFourcc) + { + TRACE("Fourcc -> Fourcc copy\n"); + if (trans) + FIXME("trans arg not supported when a FOURCC surface is involved\n"); + if (dstx || dsty) + FIXME("offset for destination surface is not supported\n"); + if (Src->resource.format != This->resource.format) + { + FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n"); + ret = WINED3DERR_WRONGTEXTUREFORMAT; + goto error; + } + /* FIXME: Watch out that the size is correct for FOURCC surfaces */ + memcpy(dbuf, sbuf, This->resource.size); + goto error; + } + if (sEntry->isFourcc && !dEntry->isFourcc) + { + /* TODO: Use the libtxc_dxtn.so shared library to do + * software decompression + */ + ERR("DXTC decompression not supported by now\n"); + goto error; + } + + if (trans & (WINEDDBLTFAST_SRCCOLORKEY | WINEDDBLTFAST_DESTCOLORKEY)) + { + DWORD keylow, keyhigh; + TRACE("Color keyed copy\n"); + if (trans & WINEDDBLTFAST_SRCCOLORKEY) + { + keylow = Src->SrcBltCKey.dwColorSpaceLowValue; + keyhigh = Src->SrcBltCKey.dwColorSpaceHighValue; + } + else + { + /* I'm not sure if this is correct */ + FIXME("WINEDDBLTFAST_DESTCOLORKEY not fully supported yet.\n"); + keylow = This->DestBltCKey.dwColorSpaceLowValue; + keyhigh = This->DestBltCKey.dwColorSpaceHighValue; + } + +#define COPYBOX_COLORKEY(type) { \ + type *d, *s, tmp; \ + s = (type *) sbuf; \ + d = (type *) dbuf; \ + for (y = 0; y < h; y++) { \ + for (x = 0; x < w; x++) { \ + tmp = s[x]; \ + if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \ + } \ + s = (type *)((BYTE *)s + slock.Pitch); \ + d = (type *)((BYTE *)d + dlock.Pitch); \ + } \ + break; \ + } + + switch (bpp) { + case 1: COPYBOX_COLORKEY(BYTE) + case 2: COPYBOX_COLORKEY(WORD) + case 4: COPYBOX_COLORKEY(DWORD) + case 3: + { + BYTE *d, *s; + DWORD tmp; + s = (BYTE *) sbuf; + d = (BYTE *) dbuf; + for (y = 0; y < h; y++) + { + for (x = 0; x < w * 3; x += 3) + { + tmp = (DWORD)s[x] + ((DWORD)s[x + 1] << 8) + ((DWORD)s[x + 2] << 16); + if (tmp < keylow || tmp > keyhigh) + { + d[x + 0] = s[x + 0]; + d[x + 1] = s[x + 1]; + d[x + 2] = s[x + 2]; + } + } + s += slock.Pitch; + d += dlock.Pitch; + } + break; + } + default: + FIXME("Source color key blitting not supported for bpp %d\n",bpp*8); + ret = WINED3DERR_NOTAVAILABLE; + goto error; + } +#undef COPYBOX_COLORKEY + TRACE("Copy Done\n"); + } + else + { + int width = w * bpp; + TRACE("NO color key copy\n"); + for (y = 0; y < h; y++) + { + /* This is pretty easy, a line for line memcpy */ + memcpy(dbuf, sbuf, width); + sbuf += slock.Pitch; + dbuf += dlock.Pitch; + } + TRACE("Copy done\n"); + } + +error: + if (Src == This) + { + IWineD3DSurface_UnlockRect(iface); + } + else + { + IWineD3DSurface_UnlockRect(iface); + IWineD3DSurface_UnlockRect(Source); + } + + return ret; +} + +HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) +{ + IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; + + TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", + This, pRect, Flags, pLockedRect, This->resource.allocatedMemory); + + pLockedRect->Pitch = IWineD3DSurface_GetPitch(iface); + + if (NULL == pRect) + { + pLockedRect->pBits = This->resource.allocatedMemory; + This->lockedRect.left = 0; + This->lockedRect.top = 0; + This->lockedRect.right = This->currentDesc.Width; + This->lockedRect.bottom = This->currentDesc.Height; + + TRACE("Locked Rect (%p) = l %d, t %d, r %d, b %d\n", + &This->lockedRect, This->lockedRect.left, This->lockedRect.top, + This->lockedRect.right, This->lockedRect.bottom); + } + else + { + TRACE("Lock Rect (%p) = l %d, t %d, r %d, b %d\n", + pRect, pRect->left, pRect->top, pRect->right, pRect->bottom); + + /* DXTn textures are based on compressed blocks of 4x4 pixels, each + * 16 bytes large (8 bytes in case of DXT1). Because of that Pitch has + * slightly different meaning compared to regular textures. For DXTn + * textures Pitch is the size of a row of blocks, 4 high and "width" + * long. The x offset is calculated differently as well, since moving 4 + * pixels to the right actually moves an entire 4x4 block to right, ie + * 16 bytes (8 in case of DXT1). */ + if (This->resource.format == WINED3DFMT_DXT1) + { + pLockedRect->pBits = This->resource.allocatedMemory + (pLockedRect->Pitch * pRect->top / 4) + (pRect->left * 2); + } + else if (This->resource.format == WINED3DFMT_DXT2 || This->resource.format == WINED3DFMT_DXT3 || + This->resource.format == WINED3DFMT_DXT4 || This->resource.format == WINED3DFMT_DXT5) + { + pLockedRect->pBits = This->resource.allocatedMemory + (pLockedRect->Pitch * pRect->top / 4) + (pRect->left * 4); + } + else + { + pLockedRect->pBits = This->resource.allocatedMemory + + (pLockedRect->Pitch * pRect->top) + + (pRect->left * This->bytesPerPixel); + } + This->lockedRect.left = pRect->left; + This->lockedRect.top = pRect->top; + This->lockedRect.right = pRect->right; + This->lockedRect.bottom = pRect->bottom; + } + + /* No dirtifying is needed for this surface implementation */ + TRACE("returning memory@%p, pitch(%d)\n", pLockedRect->pBits, pLockedRect->Pitch); + + return WINED3D_OK; +} Propchange: trunk/reactos/dll/directx/wine/wined3d/surface_base.c ------------------------------------------------------------------------------ svn:eol-style = native

1 0

[greatlrd] 30393: Update wine d3d8 and wined3d to wine release version 0.9.49
by greatlrd＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: greatlrd Date: Mon Nov 12 17:56:05 2007 New Revision: 30393 URL: http://svn.reactos.org/svn/reactos?rev=30393&view=rev Log: Update wine d3d8 and wined3d to wine release version 0.9.49 Modified: trunk/reactos/dll/directx/wine/wined3d/Makefile.in trunk/reactos/dll/directx/wine/wined3d/arb_program_shader.c trunk/reactos/dll/directx/wine/wined3d/baseshader.c trunk/reactos/dll/directx/wine/wined3d/basetexture.c trunk/reactos/dll/directx/wine/wined3d/context.c trunk/reactos/dll/directx/wine/wined3d/cubetexture.c trunk/reactos/dll/directx/wine/wined3d/device.c trunk/reactos/dll/directx/wine/wined3d/directx.c trunk/reactos/dll/directx/wine/wined3d/drawprim.c trunk/reactos/dll/directx/wine/wined3d/glsl_shader.c trunk/reactos/dll/directx/wine/wined3d/pixelshader.c trunk/reactos/dll/directx/wine/wined3d/query.c trunk/reactos/dll/directx/wine/wined3d/resource.c trunk/reactos/dll/directx/wine/wined3d/state.c trunk/reactos/dll/directx/wine/wined3d/stateblock.c trunk/reactos/dll/directx/wine/wined3d/surface.c trunk/reactos/dll/directx/wine/wined3d/surface_gdi.c trunk/reactos/dll/directx/wine/wined3d/swapchain.c trunk/reactos/dll/directx/wine/wined3d/texture.c trunk/reactos/dll/directx/wine/wined3d/utils.c trunk/reactos/dll/directx/wine/wined3d/vertexdeclaration.c trunk/reactos/dll/directx/wine/wined3d/vertexshader.c trunk/reactos/dll/directx/wine/wined3d/volume.c trunk/reactos/dll/directx/wine/wined3d/wined3d.rbuild trunk/reactos/dll/directx/wine/wined3d/wined3d_main.c trunk/reactos/dll/directx/wine/wined3d/wined3d_private.h trunk/reactos/dll/directx/wine/wined3d/wined3d_private_types.h trunk/reactos/include/reactos/wine/wined3d_gl.h trunk/reactos/include/reactos/wine/wined3d_interface.h trunk/reactos/include/reactos/wine/wined3d_types.h [This mail would be too long, it was shortened to contain the URLs only.] Modified: trunk/reactos/dll/directx/wine/wined3d/Makefile.in URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/M… Modified: trunk/reactos/dll/directx/wine/wined3d/arb_program_shader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/a… Modified: trunk/reactos/dll/directx/wine/wined3d/baseshader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/b… Modified: trunk/reactos/dll/directx/wine/wined3d/basetexture.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/b… Modified: trunk/reactos/dll/directx/wine/wined3d/context.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/c… Modified: trunk/reactos/dll/directx/wine/wined3d/cubetexture.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/c… Modified: trunk/reactos/dll/directx/wine/wined3d/device.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/d… Modified: trunk/reactos/dll/directx/wine/wined3d/directx.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/d… Modified: trunk/reactos/dll/directx/wine/wined3d/drawprim.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/d… Modified: trunk/reactos/dll/directx/wine/wined3d/glsl_shader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/g… Modified: trunk/reactos/dll/directx/wine/wined3d/pixelshader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/p… Modified: trunk/reactos/dll/directx/wine/wined3d/query.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/q… Modified: trunk/reactos/dll/directx/wine/wined3d/resource.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/r… Modified: trunk/reactos/dll/directx/wine/wined3d/state.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… Modified: trunk/reactos/dll/directx/wine/wined3d/stateblock.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… Modified: trunk/reactos/dll/directx/wine/wined3d/surface.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… Modified: trunk/reactos/dll/directx/wine/wined3d/surface_gdi.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… Modified: trunk/reactos/dll/directx/wine/wined3d/swapchain.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… Modified: trunk/reactos/dll/directx/wine/wined3d/texture.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/t… Modified: trunk/reactos/dll/directx/wine/wined3d/utils.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/u… Modified: trunk/reactos/dll/directx/wine/wined3d/vertexdeclaration.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/v… Modified: trunk/reactos/dll/directx/wine/wined3d/vertexshader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/v… Modified: trunk/reactos/dll/directx/wine/wined3d/volume.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/v… Modified: trunk/reactos/dll/directx/wine/wined3d/wined3d.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/w… Modified: trunk/reactos/dll/directx/wine/wined3d/wined3d_main.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/w… Modified: trunk/reactos/dll/directx/wine/wined3d/wined3d_private.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/w… Modified: trunk/reactos/dll/directx/wine/wined3d/wined3d_private_types.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/w… Modified: trunk/reactos/include/reactos/wine/wined3d_gl.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/reactos/wine/wined… Modified: trunk/reactos/include/reactos/wine/wined3d_interface.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/reactos/wine/wined… Modified: trunk/reactos/include/reactos/wine/wined3d_types.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/reactos/wine/wined…

1 0

[gedmurphy] 30392: implement Save As dialog
by gedmurphy＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: gedmurphy Date: Mon Nov 12 17:45:20 2007 New Revision: 30392 URL: http://svn.reactos.org/svn/reactos?rev=30392&view=rev Log: implement Save As dialog Modified: trunk/reactos/base/applications/mstsc/connectdialog.c trunk/reactos/base/applications/mstsc/lang/en-US.rc Modified: trunk/reactos/base/applications/mstsc/connectdialog.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/mstsc/co… ============================================================================== --- trunk/reactos/base/applications/mstsc/connectdialog.c (original) +++ trunk/reactos/base/applications/mstsc/connectdialog.c Mon Nov 12 17:45:20 2007 @@ -23,6 +23,30 @@ #define MAX_KEY_NAME 255 HINSTANCE hInst; + +static VOID +DoSaveAs(PINFO pInfo) +{ + OPENFILENAME ofn; + WCHAR szFileName[MAX_PATH] = L""; + static WCHAR szFilter[] = L"Remote Desktop Files (*rdp)\0*.rdp\0"; + + ZeroMemory(&ofn, sizeof(ofn)); + ofn.lStructSize = sizeof(OPENFILENAME); + ofn.hwndOwner = pInfo->hGeneralPage; + ofn.nMaxFile = MAX_PATH; + ofn.nMaxFileTitle = MAX_PATH; + ofn.lpstrDefExt = L"rdp"; + ofn.lpstrFilter = szFilter; + ofn.lpstrFile = szFileName; + ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT; + + if (GetSaveFileName(&ofn)) + { + SaveAllSettings(pInfo); + SaveRdpSettingsToFile(szFileName, pInfo->pRdpSettings); + } +} static VOID OnTabWndSelChange(PINFO pInfo) @@ -228,6 +252,10 @@ SaveAllSettings(pInfo); SaveRdpSettingsToFile(NULL, pInfo->pRdpSettings); break; + + case IDC_SAVEAS: + DoSaveAs(pInfo); + break; } break; @@ -827,7 +855,6 @@ } - static BOOL OnMainCreate(HWND hwnd, PRDPSETTINGS pRdpSettings) @@ -835,6 +862,7 @@ PINFO pInfo; TCITEMW item; BOOL bRet = FALSE; + HWND hUnderGry, hUnderWht; pInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, @@ -889,6 +917,7 @@ &pInfo->headerbitmap); } + /* setup the tabs */ pInfo->hTab = GetDlgItem(hwnd, IDC_TAB); if (pInfo->hTab) { Modified: trunk/reactos/base/applications/mstsc/lang/en-US.rc URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/mstsc/la… ============================================================================== --- trunk/reactos/base/applications/mstsc/lang/en-US.rc (original) +++ trunk/reactos/base/applications/mstsc/lang/en-US.rc Mon Nov 12 17:45:20 2007 @@ -14,7 +14,7 @@ LTEXT "User name:",IDC_STATIC,47,58,38,8 COMBOBOX IDC_SERVERCOMBO,79,39,141,150,CBS_DROPDOWN | WS_VSCROLL | WS_TABSTOP PUSHBUTTON "Save",IDC_SAVE,67,139,50,14 - PUSHBUTTON "SaveAs...",IDC_SAVEAS,123,139,50,14 + PUSHBUTTON "Save As...",IDC_SAVEAS,123,139,50,14 PUSHBUTTON "Open...",IDC_OPEN,177,139,50,14 ICON "", IDC_CONNICON, 16,114,20,20 LTEXT "Save the current connection settings or open an existing config",IDC_STATIC,50,115,172,20

1 0

[gedmurphy] 30391: Be lazy and add an underline to the bitmap header. Its easier than setting 2 coloured static controls
by gedmurphy＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: gedmurphy Date: Mon Nov 12 17:21:20 2007 New Revision: 30391 URL: http://svn.reactos.org/svn/reactos?rev=30391&view=rev Log: Be lazy and add an underline to the bitmap header. Its easier than setting 2 coloured static controls Modified: trunk/reactos/base/applications/mstsc/res/header.bmp Modified: trunk/reactos/base/applications/mstsc/res/header.bmp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/mstsc/re… ============================================================================== Binary files - no diff available.

1 0

[greatlrd] 30390: remove white space commit. for those file are 100% share with wine.
by greatlrd＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: greatlrd Date: Mon Nov 12 17:14:14 2007 New Revision: 30390 URL: http://svn.reactos.org/svn/reactos?rev=30390&view=rev Log: remove white space commit. for those file are 100% share with wine. Modified: trunk/reactos/dll/directx/wine/wined3d/arb_program_shader.c trunk/reactos/dll/directx/wine/wined3d/baseshader.c trunk/reactos/dll/directx/wine/wined3d/basetexture.c trunk/reactos/dll/directx/wine/wined3d/cubetexture.c trunk/reactos/dll/directx/wine/wined3d/device.c trunk/reactos/dll/directx/wine/wined3d/directx.c trunk/reactos/dll/directx/wine/wined3d/drawprim.c trunk/reactos/dll/directx/wine/wined3d/glsl_shader.c trunk/reactos/dll/directx/wine/wined3d/pixelshader.c trunk/reactos/dll/directx/wine/wined3d/resource.c trunk/reactos/dll/directx/wine/wined3d/state.c trunk/reactos/dll/directx/wine/wined3d/stateblock.c trunk/reactos/dll/directx/wine/wined3d/surface.c trunk/reactos/dll/directx/wine/wined3d/surface_gdi.c trunk/reactos/dll/directx/wine/wined3d/vertexshader.c trunk/reactos/dll/directx/wine/wined3d/wined3d.rbuild trunk/reactos/dll/directx/wine/wined3d/wined3d_main.c trunk/reactos/dll/directx/wine/wined3d/wined3d_private.h trunk/reactos/dll/directx/wine/wined3d/wined3d_private_types.h Modified: trunk/reactos/dll/directx/wine/wined3d/arb_program_shader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/a… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/arb_program_shader.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/arb_program_shader.c Mon Nov 12 17:14:14 2007 @@ -41,10 +41,10 @@ * ARB_[vertex/fragment]_program helper functions follow ********************************************************/ -/** +/** * Loads floating point constants into the currently set ARB_vertex/fragment_program. * When constant_list == NULL, it will load all the constants. - * + * * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders) * or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders) */ @@ -93,16 +93,16 @@ /** * Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs. - * - * We only support float constants in ARB at the moment, so don't + * + * We only support float constants in ARB at the moment, so don't * worry about the Integers or Booleans */ void shader_arb_load_constants( IWineD3DDevice* device, char usePixelShader, char useVertexShader) { - - IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device; + + IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device; IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock; WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info; @@ -124,7 +124,7 @@ IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader; /* Load DirectX 9 float constants for pixel shader */ - shader_arb_load_constantsF(pshader, gl_info, GL_FRAGMENT_PROGRAM_ARB, + shader_arb_load_constantsF(pshader, gl_info, GL_FRAGMENT_PROGRAM_ARB, GL_LIMITS(pshader_constantsF), stateBlock->pixelShaderConstantF, &stateBlock->set_pconstantsF); @@ -150,7 +150,7 @@ IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface; DWORD i; char pshader = shader_is_pshader_version(This->baseShader.hex_version); - unsigned max_constantsF = min(This->baseShader.limits.constant_float, + unsigned max_constantsF = min(This->baseShader.limits.constant_float, (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF))); /* Temporary Output register */ Modified: trunk/reactos/dll/directx/wine/wined3d/baseshader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/b… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/baseshader.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/baseshader.c Mon Nov 12 17:14:14 2007 @@ -37,7 +37,7 @@ } int shader_addline( - SHADER_BUFFER* buffer, + SHADER_BUFFER* buffer, const char *format, ...) { char* base = buffer->buffer + buffer->bsize; @@ -48,7 +48,7 @@ rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args); va_end(args); - if (rc < 0 || /* C89 */ + if (rc < 0 || /* C89 */ rc > SHADER_PGMSIZE - 1 - buffer->bsize) { /* C99 */ ERR("The buffer allocated for the shader program string " @@ -90,7 +90,7 @@ } ++i; } - FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n", + FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n", code, code, code & WINED3DSI_OPCODE_MASK, hex_version); return NULL; } @@ -133,10 +133,10 @@ } /* Read the parameters of an unrecognized opcode from the input stream - * Return the number of tokens read. - * + * Return the number of tokens read. + * * Note: This function assumes source or destination token format. - * It will not work with specially-formatted tokens like DEF or DCL, + * It will not work with specially-formatted tokens like DEF or DCL, * but hopefully those would be recognized */ int shader_skip_unrecognized( @@ -292,11 +292,11 @@ WINED3DSIO_REP == curOpcode->opcode) { reg_maps->loop = 1; pToken += curOpcode->num_params; - + /* For subroutine prototypes */ } else if (WINED3DSIO_LABEL == curOpcode->opcode) { - DWORD snum = *pToken & WINED3DSP_REGNUM_MASK; + DWORD snum = *pToken & WINED3DSP_REGNUM_MASK; reg_maps->labels[snum] = 1; pToken += curOpcode->num_params; @@ -313,7 +313,7 @@ int i, limit; /* Declare 1.X samplers implicitly, based on the destination reg. number */ - if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 && + if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 && (WINED3DSIO_TEX == curOpcode->opcode || WINED3DSIO_TEXBEM == curOpcode->opcode || WINED3DSIO_TEXBEML == curOpcode->opcode || @@ -364,10 +364,10 @@ } /* This will loop over all the registers and try to - * make a bitmask of the ones we're interested in. + * make a bitmask of the ones we're interested in. * - * Relative addressing tokens are ignored, but that's - * okay, since we'll catch any address registers when + * Relative addressing tokens are ignored, but that's + * okay, since we'll catch any address registers when * they are initialized (required by spec) */ limit = (opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED)? @@ -406,7 +406,7 @@ static void shader_dump_decl_usage( IWineD3DBaseShaderImpl* This, - DWORD decl, + DWORD decl, DWORD param) { DWORD regtype = shader_get_regtype(param); @@ -420,10 +420,10 @@ case WINED3DSTT_2D: TRACE("_2d"); break; case WINED3DSTT_CUBE: TRACE("_cube"); break; case WINED3DSTT_VOLUME: TRACE("_volume"); break; - default: TRACE("_unknown_ttype(%08x)", ttype); + default: TRACE("_unknown_ttype(%08x)", ttype); } - } else { + } else { DWORD usage = decl & WINED3DSP_DCL_USAGE_MASK; DWORD idx = (decl & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT; @@ -513,7 +513,7 @@ void shader_dump_param( IWineD3DBaseShader *iface, - const DWORD param, + const DWORD param, const DWORD addr_token, int input) { @@ -549,7 +549,7 @@ else if (modifier == WINED3DSPSM_NOT) TRACE("!"); - if (modifier == WINED3DSPSM_ABS || modifier == WINED3DSPSM_ABSNEG) + if (modifier == WINED3DSPSM_ABS || modifier == WINED3DSPSM_ABSNEG) TRACE("abs("); } @@ -570,7 +570,7 @@ break; case WINED3DSPR_TEXTURE: /* vs: case D3DSPR_ADDR */ TRACE("%c%u", (pshader? 't':'a'), reg); - break; + break; case WINED3DSPR_RASTOUT: TRACE("%s", rastout_reg_names[reg]); break; @@ -583,7 +583,7 @@ case WINED3DSPR_ATTROUT: TRACE("oD%u", reg); break; - case WINED3DSPR_TEXCRDOUT: + case WINED3DSPR_TEXCRDOUT: /* Vertex shaders >= 3.0 use general purpose output registers * (WINED3DSPR_OUTPUT), which can include an address token */ @@ -592,7 +592,7 @@ TRACE("o"); shader_dump_arr_entry(iface, param, addr_token, reg, input); } - else + else TRACE("oT%u", reg); break; case WINED3DSPR_CONSTINT: @@ -745,7 +745,7 @@ /* Unknown opcode and its parameters */ if (NULL == curOpcode) { FIXME("Unrecognized opcode: token=%08x\n", hw_arg.opcode_token); - pToken += shader_skip_unrecognized(iface, pToken); + pToken += shader_skip_unrecognized(iface, pToken); /* Nothing to do */ } else if (WINED3DSIO_DCL == curOpcode->opcode || @@ -773,13 +773,13 @@ } /* Predication token */ - if (hw_arg.opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED) + if (hw_arg.opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED) hw_arg.predicate = *pToken++; /* Other source tokens */ for (i = 0; i < (curOpcode->num_params - curOpcode->dst_token); i++) { - DWORD param, addr_token = 0; + DWORD param, addr_token = 0; pToken += shader_get_param(iface, pToken, &param, &addr_token); hw_arg.src[i] = param; hw_arg.src_addr[i] = addr_token; Modified: trunk/reactos/dll/directx/wine/wined3d/basetexture.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/b… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/basetexture.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/basetexture.c Mon Nov 12 17:14:14 2007 @@ -259,7 +259,7 @@ glTexParameteri(textureDimensions, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); } } - + } else { /* this only happened if we've run out of openGL textures */ WARN("This texture doesn't have an openGL texture assigned to it\n"); hr = WINED3DERR_INVALIDCALL; Modified: trunk/reactos/dll/directx/wine/wined3d/cubetexture.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/c… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/cubetexture.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/cubetexture.c Mon Nov 12 17:14:14 2007 @@ -227,8 +227,8 @@ return GL_TEXTURE_CUBE_MAP_ARB; } -static void WINAPI IWineD3DCubeTextureImpl_ApplyStateChanges(IWineD3DCubeTexture *iface, - const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1], +static void WINAPI IWineD3DCubeTextureImpl_ApplyStateChanges(IWineD3DCubeTexture *iface, + const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1], const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1]) { IWineD3DCubeTextureImpl *This = (IWineD3DCubeTextureImpl *)iface; float matrix[16]; Modified: trunk/reactos/dll/directx/wine/wined3d/device.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/d… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/device.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/device.c Mon Nov 12 17:14:14 2007 @@ -290,7 +290,7 @@ return; } -static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexBuffer(IWineD3DDevice *iface, UINT Size, DWORD Usage, +static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexBuffer(IWineD3DDevice *iface, UINT Size, DWORD Usage, DWORD FVF, WINED3DPOOL Pool, IWineD3DVertexBuffer** ppVertexBuffer, HANDLE *sharedHandle, IUnknown *parent) { IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; @@ -331,7 +331,7 @@ * more. In this call we can convert dx7 buffers too. */ conv = ((FVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) || (FVF & (WINED3DFVF_DIFFUSE | WINED3DFVF_SPECULAR)); - if( GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) && Pool != WINED3DPOOL_SYSTEMMEM && !(Usage & WINED3DUSAGE_DYNAMIC) && + if( GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) && Pool != WINED3DPOOL_SYSTEMMEM && !(Usage & WINED3DUSAGE_DYNAMIC) && (dxVersion > 7 || !conv) ) { CreateVBO(object); } @@ -388,7 +388,7 @@ object->vbo = 0; } -static HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT Length, DWORD Usage, +static HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT Length, DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool, IWineD3DIndexBuffer** ppIndexBuffer, HANDLE *sharedHandle, IUnknown *parent) { IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; @@ -406,7 +406,7 @@ CreateIndexBufferVBO(This, object); } - TRACE("(%p) : Len=%d, Use=%x, Format=(%u,%s), Pool=%d - Memory@%p, Iface@%p\n", This, Length, Usage, Format, + TRACE("(%p) : Len=%d, Use=%x, Format=(%u,%s), Pool=%d - Memory@%p, Iface@%p\n", This, Length, Usage, Format, debug_d3dformat(Format), Pool, object, object->resource.allocatedMemory); *ppIndexBuffer = (IWineD3DIndexBuffer *) object; @@ -434,7 +434,7 @@ be freed due to circular dependencies */ return WINED3D_OK; } - + temp_result = allocate_shader_constants(object); if (WINED3D_OK != temp_result) return temp_result; @@ -625,24 +625,24 @@ [in] Render targets are not lockable unless the application specifies TRUE for Lockable. Note that lockable render targets reduce performance on some graphics hardware. Discard - [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise. + [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise. If this flag is set, the contents of the depth stencil buffer will be invalid after calling either IDirect3DDevice9::Present or IDirect3DDevice9::SetDepthStencilSurface with a different depth surface. ******************************** */ - + static HRESULT WINAPI IWineD3DDeviceImpl_CreateSurface(IWineD3DDevice *iface, UINT Width, UINT Height, WINED3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IWineD3DSurface **ppSurface,WINED3DRESOURCETYPE Type, DWORD Usage, WINED3DPOOL Pool, WINED3DMULTISAMPLE_TYPE MultiSample ,DWORD MultisampleQuality, HANDLE* pSharedHandle, WINED3DSURFTYPE Impl, IUnknown *parent) { - IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; + IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; IWineD3DSurfaceImpl *object; /*NOTE: impl ref allowed since this is a create function */ unsigned int Size = 1; const StaticPixelFormatDesc *tableEntry = getFormatDescEntry(Format, NULL, NULL); TRACE("(%p) Create surface\n",This); - - /** FIXME: Check ranges on the inputs are valid + + /** FIXME: Check ranges on the inputs are valid * MSDN * MultisampleQuality * [in] Quality level. The valid range is between zero and one less than the level - * returned by pQualityLevels used by IDirect3D9::CheckDeviceMultiSampleType. + * returned by pQualityLevels used by IDirect3D9::CheckDeviceMultiSampleType. * Passing a larger value returns the error WINED3DERR_INVALIDCALL. The MultisampleQuality * values of paired render targets, depth stencil surfaces, and the MultiSample type * must all match. @@ -813,7 +813,7 @@ TRACE("Format %#x (%s), Pool %#x, ppTexture %p, pSharedHandle %p, parent %p\n", Format, debug_d3dformat(Format), Pool, ppTexture, pSharedHandle, parent); - /* TODO: It should only be possible to create textures for formats + /* TODO: It should only be possible to create textures for formats that are reported as supported */ if (WINED3DFMT_UNKNOWN >= Format) { WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This); @@ -821,7 +821,7 @@ } D3DCREATERESOURCEOBJECTINSTANCE(object, Texture, WINED3DRTYPE_TEXTURE, 0); - D3DINITIALIZEBASETEXTURE(object->baseTexture); + D3DINITIALIZEBASETEXTURE(object->baseTexture); object->width = Width; object->height = Height; @@ -899,7 +899,7 @@ UINT tmpH; UINT tmpD; - /* TODO: It should only be possible to create textures for formats + /* TODO: It should only be possible to create textures for formats that are reported as supported */ if (WINED3DFMT_UNKNOWN >= Format) { WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This); @@ -1008,7 +1008,7 @@ HRESULT hr; unsigned int pow2EdgeLength = EdgeLength; - /* TODO: It should only be possible to create textures for formats + /* TODO: It should only be possible to create textures for formats that are reported as supported */ if (WINED3DFMT_UNKNOWN >= Format) { WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This); @@ -1776,7 +1776,7 @@ object->parent = Parent; object->wineD3DDevice = This; object->palNumEntries = IWineD3DPaletteImpl_Size(Flags); - + object->hpal = CreatePalette((const LOGPALETTE*)&(object->palVersion)); if(!object->hpal) { @@ -3792,7 +3792,7 @@ if( !doClip || ( (-rhw -eps < x) && (-rhw -eps < y) && ( -eps < z) && - (x <= rhw + eps) && (y <= rhw + eps ) && (z <= rhw + eps) && + (x <= rhw + eps) && (y <= rhw + eps ) && (z <= rhw + eps) && ( rhw > eps ) ) ) { /* "Normal" viewport transformation (not clipped) @@ -3887,7 +3887,7 @@ } if (DestFVF & WINED3DFVF_DIFFUSE) { - DWORD *color_d = + DWORD *color_d = (DWORD *) (((char *) lpStrideData->u.s.diffuse.lpData) + i * lpStrideData->u.s.diffuse.dwStride); if(!color_d) { static BOOL warned = FALSE; @@ -3916,9 +3916,9 @@ } } - if (DestFVF & WINED3DFVF_SPECULAR) { + if (DestFVF & WINED3DFVF_SPECULAR) { /* What's the color value in the feedback buffer? */ - DWORD *color_s = + DWORD *color_s = (DWORD *) (((char *) lpStrideData->u.s.specular.lpData) + i * lpStrideData->u.s.specular.dwStride); if(!color_s) { static BOOL warned = FALSE; @@ -3949,7 +3949,7 @@ for (tex_index = 0; tex_index < numTextures; tex_index++) { float *tex_coord = - (float *) (((char *) lpStrideData->u.s.texCoords[tex_index].lpData) + + (float *) (((char *) lpStrideData->u.s.texCoords[tex_index].lpData) + i * lpStrideData->u.s.texCoords[tex_index].dwStride); if(!tex_coord) { ERR("No source texture, but destination requests one\n"); @@ -4153,7 +4153,7 @@ oldTexture = This->updateStateBlock->textures[Stage]; if(pTexture != NULL) { - /* SetTexture isn't allowed on textures in WINED3DPOOL_SCRATCH; + /* SetTexture isn't allowed on textures in WINED3DPOOL_SCRATCH; */ if(((IWineD3DTextureImpl*)pTexture)->resource.pool == WINED3DPOOL_SCRATCH) { WARN("(%p) Attempt to set scratch texture rejected\n", pTexture); @@ -4345,11 +4345,11 @@ int i; ERR("(%p)\n", This); - + if (This->isRecordingState) { return WINED3DERR_INVALIDCALL; } - + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DStateBlockImpl)); if (NULL == object ) { FIXME("(%p)Error allocating memory for stateblock\n", This); @@ -6522,7 +6522,7 @@ IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; ResourceList* resourceList = NULL; ResourceList* previousResourceList = NULL; - + TRACE("(%p) : resource %p\n", This, resource); resourceList = This->resources; Modified: trunk/reactos/dll/directx/wine/wined3d/directx.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/d… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/directx.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/directx.c Mon Nov 12 17:14:14 2007 @@ -453,7 +453,7 @@ gl_info->gl_vendor = VENDOR_NVIDIA; } else if (strstr(gl_string, "ATI")) { gl_info->gl_vendor = VENDOR_ATI; - } else if (strstr(gl_string, "Intel(R)") || + } else if (strstr(gl_string, "Intel(R)") || strstr(gl_info->gl_renderer, "Intel(R)")) { gl_info->gl_vendor = VENDOR_INTEL; } else if (strstr(gl_string, "Mesa")) { @@ -842,7 +842,7 @@ * without a full database we can return a card with similar features. Second the size of the database * can be made quite small because when you know what type of 3d functionality a card has, you know to which * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string - * to distinguishes between different models from that family. + * to distinguishes between different models from that family. */ switch (gl_info->gl_vendor) { case VENDOR_NVIDIA: @@ -914,7 +914,7 @@ strstr(gl_info->gl_renderer, "X1300") || strstr(gl_info->gl_renderer, "X1400")) gl_info->gl_card = CARD_ATI_RADEON_X700; - /* Radeon R3xx */ + /* Radeon R3xx */ else gl_info->gl_card = CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */ } else if(WINE_D3D8_CAPABLE(gl_info)) { @@ -942,7 +942,7 @@ case VENDOR_MESA: case VENDOR_WINE: default: - /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice + /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice * for Nvidia was because the hardware and drivers they make are of good quality. This makes * them a good generic choice. */ @@ -950,7 +950,7 @@ if(WINE_D3D9_CAPABLE(gl_info)) gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600; else if(WINE_D3D8_CAPABLE(gl_info)) - gl_info->gl_card = CARD_NVIDIA_GEFORCE3; + gl_info->gl_card = CARD_NVIDIA_GEFORCE3; else if(WINE_D3D7_CAPABLE(gl_info)) gl_info->gl_card = CARD_NVIDIA_GEFORCE; else if(WINE_D3D6_CAPABLE(gl_info)) @@ -1403,7 +1403,7 @@ return WINED3DERR_NOTAVAILABLE; } -static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, +static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT SurfaceFormat, BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) { @@ -1477,7 +1477,7 @@ } #define GLINFO_LOCATION Adapters[Adapter].gl_info -static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, +static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat) { IWineD3DImpl *This = (IWineD3DImpl *)iface; TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n", @@ -2189,7 +2189,7 @@ WINED3DVTXPCAPS_LOCALVIEWER | WINED3DVTXPCAPS_VERTEXFOG | WINED3DVTXPCAPS_TEXGEN; - /* FIXME: Add + /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */ *pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */ @@ -2271,13 +2271,13 @@ *pCaps->NumSimultaneousRTs = GL_LIMITS(buffers); - + *pCaps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT | WINED3DPTFILTERCAPS_MAGFPOINT | WINED3DPTFILTERCAPS_MINFLINEAR | WINED3DPTFILTERCAPS_MAGFLINEAR; *pCaps->VertexTextureFilterCaps = 0; - + if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) { /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering) use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */ @@ -2292,7 +2292,7 @@ *pCaps->VS20Caps.Caps = 0; *pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH; *pCaps->VS20Caps.NumTemps = max(12, GLINFO_LOCATION.vs_arb_max_temps); - *pCaps->VS20Caps.StaticFlowControlDepth = 1; + *pCaps->VS20Caps.StaticFlowControlDepth = 1; *pCaps->MaxVShaderInstructionsExecuted = 65535; *pCaps->MaxVertexShader30InstructionSlots = 0; @@ -2300,16 +2300,16 @@ *pCaps->VS20Caps.Caps = 0; *pCaps->VS20Caps.DynamicFlowControlDepth = 0; *pCaps->VS20Caps.NumTemps = 0; - *pCaps->VS20Caps.StaticFlowControlDepth = 0; + *pCaps->VS20Caps.StaticFlowControlDepth = 0; *pCaps->MaxVShaderInstructionsExecuted = 0; - *pCaps->MaxVertexShader30InstructionSlots = 0; + *pCaps->MaxVertexShader30InstructionSlots = 0; } if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) { /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering) use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */ - + /* Caps is more or less undocumented on MSDN but it appears to be used for PS20Caps based on results from R9600/FX5900/Geforce6800 cards from Windows */ *pCaps->PS20Caps.Caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE | WINED3DPS20CAPS_GRADIENTINSTRUCTIONS | Modified: trunk/reactos/dll/directx/wine/wined3d/drawprim.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/d… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/drawprim.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/drawprim.c Mon Nov 12 17:14:14 2007 @@ -493,7 +493,7 @@ D3DCOLOR_B_G(diffuseColor), D3DCOLOR_B_B(diffuseColor), D3DCOLOR_B_A(diffuseColor)); - VTRACE(("glColor4ub: r,g,b,a=%lu,%lu,%lu,%lu\n", + VTRACE(("glColor4ub: r,g,b,a=%lu,%lu,%lu,%lu\n", D3DCOLOR_B_R(diffuseColor), D3DCOLOR_B_G(diffuseColor), D3DCOLOR_B_B(diffuseColor), @@ -535,9 +535,9 @@ } } - VTRACE(("glSecondaryColor4ub: r,g,b=%lu,%lu,%lu\n", - D3DCOLOR_B_R(specularColor), - D3DCOLOR_B_G(specularColor), + VTRACE(("glSecondaryColor4ub: r,g,b=%lu,%lu,%lu\n", + D3DCOLOR_B_R(specularColor), + D3DCOLOR_B_G(specularColor), D3DCOLOR_B_B(specularColor))); if (GL_SUPPORT(EXT_SECONDARY_COLOR)) { GL_EXTCALL(glSecondaryColor3ubEXT)( @@ -1110,7 +1110,7 @@ #ifdef SHOW_FRAME_MAKEUP { static long int primCounter = 0; - /* NOTE: set primCounter to the value reported by drawprim + /* NOTE: set primCounter to the value reported by drawprim before you want to to write frame makeup to /tmp */ if (primCounter >= 0) { WINED3DLOCKED_RECT r; Modified: trunk/reactos/dll/directx/wine/wined3d/glsl_shader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/g… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/glsl_shader.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/glsl_shader.c Mon Nov 12 17:14:14 2007 @@ -1,7 +1,7 @@ /* * GLSL pixel and vertex shader implementation * - * Copyright 2006 Jason Green + * Copyright 2006 Jason Green * Copyright 2006-2007 Henri Verbeet * * This library is free software; you can redistribute it and/or @@ -53,7 +53,7 @@ /** Prints the GLSL info log which will contain error messages if they exist */ void print_glsl_info_log(WineD3D_GL_Info *gl_info, GLhandleARB obj) { - + int infologLength = 0; char *infoLog; @@ -124,7 +124,7 @@ } } -/** +/** * Loads floating point constants (aka uniforms) into the currently set GLSL program. * When constant_list == NULL, it will load all the constants. */ @@ -187,7 +187,7 @@ checkGLcall("glUniform4fvARB()"); } -/** +/** * Loads integer constants (aka uniforms) into the currently set GLSL program. * When @constants_set == NULL, it will load all the constants. */ @@ -198,7 +198,7 @@ unsigned max_constants, int* constants, BOOL* constants_set) { - + GLhandleARB tmp_loc; int i; char tmp_name[8]; @@ -212,7 +212,7 @@ TRACE_(d3d_constants)("Loading constants %i: %i, %i, %i, %i\n", i, constants[i*4], constants[i*4+1], constants[i*4+2], constants[i*4+3]); - /* TODO: Benchmark and see if it would be beneficial to store the + /* TODO: Benchmark and see if it would be beneficial to store the * locations of the constants to avoid looking up each time */ _snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i); tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name)); @@ -245,7 +245,7 @@ } } -/** +/** * Loads boolean constants (aka uniforms) into the currently set GLSL program. * When @constants_set == NULL, it will load all the constants. */ @@ -256,7 +256,7 @@ unsigned max_constants, BOOL* constants, BOOL* constants_set) { - + GLhandleARB tmp_loc; int i; char tmp_name[8]; @@ -269,7 +269,7 @@ TRACE_(d3d_constants)("Loading constants %i: %i;\n", i, constants[i*4]); - /* TODO: Benchmark and see if it would be beneficial to store the + /* TODO: Benchmark and see if it would be beneficial to store the * locations of the constants to avoid looking up each time */ _snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i); tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name)); @@ -310,7 +310,7 @@ IWineD3DDevice* device, char usePixelShader, char useVertexShader) { - + IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device; IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock; WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info; @@ -373,12 +373,12 @@ /* Load DirectX 9 integer constants/uniforms for pixel shader */ shader_glsl_load_constantsI(pshader, gl_info, programId, MAX_CONST_I, - stateBlock->pixelShaderConstantI, + stateBlock->pixelShaderConstantI, stateBlock->changed.pixelShaderConstantsI); /* Load DirectX 9 boolean constants/uniforms for pixel shader */ shader_glsl_load_constantsB(pshader, gl_info, programId, MAX_CONST_B, - stateBlock->pixelShaderConstantB, + stateBlock->pixelShaderConstantB, stateBlock->changed.pixelShaderConstantsB); /* Upload the environment bump map matrix if needed. The needsbumpmat member specifies the texture stage to load the matrix from. @@ -416,7 +416,7 @@ /* Declare the constants (aka uniforms) */ if (This->baseShader.limits.constant_float > 0) { - unsigned max_constantsF = min(This->baseShader.limits.constant_float, + unsigned max_constantsF = min(This->baseShader.limits.constant_float, (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF))); shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF); } @@ -432,7 +432,7 @@ else if(reg_maps->bumpmat != -1) shader_addline(buffer, "uniform mat2 bumpenvmat;\n"); - /* Declare texture samplers */ + /* Declare texture samplers */ for (i = 0; i < This->baseShader.limits.sampler; i++) { if (reg_maps->samplers[i]) { @@ -458,7 +458,7 @@ } } } - + /* Declare address variables */ for (i = 0; i < This->baseShader.limits.address; i++) { if (reg_maps->address[i]) @@ -467,7 +467,7 @@ /* Declare texture coordinate temporaries and initialize them */ for (i = 0; i < This->baseShader.limits.texcoord; i++) { - if (reg_maps->texcoord[i]) + if (reg_maps->texcoord[i]) shader_addline(buffer, "vec4 T%lu = gl_TexCoord[%lu];\n", i, i); } @@ -500,7 +500,7 @@ shader_addline(buffer, "int aL;\n"); shader_addline(buffer, "int tmpInt;\n"); } - + /* Temporary variables for matrix operations */ shader_addline(buffer, "vec4 tmp0;\n"); shader_addline(buffer, "vec4 tmp1;\n"); @@ -521,22 +521,22 @@ /** Used for opcode modifiers - They multiply the result by the specified amount */ static const char * const shift_glsl_tab[] = { - "", /* 0 (none) */ - "2.0 * ", /* 1 (x2) */ - "4.0 * ", /* 2 (x4) */ - "8.0 * ", /* 3 (x8) */ - "16.0 * ", /* 4 (x16) */ - "32.0 * ", /* 5 (x32) */ - "", /* 6 (x64) */ - "", /* 7 (x128) */ - "", /* 8 (d256) */ - "", /* 9 (d128) */ - "", /* 10 (d64) */ - "", /* 11 (d32) */ - "0.0625 * ", /* 12 (d16) */ - "0.125 * ", /* 13 (d8) */ - "0.25 * ", /* 14 (d4) */ - "0.5 * " /* 15 (d2) */ + "", /* 0 (none) */ + "2.0 * ", /* 1 (x2) */ + "4.0 * ", /* 2 (x4) */ + "8.0 * ", /* 3 (x8) */ + "16.0 * ", /* 4 (x16) */ + "32.0 * ", /* 5 (x32) */ + "", /* 6 (x64) */ + "", /* 7 (x128) */ + "", /* 8 (d256) */ + "", /* 9 (d128) */ + "", /* 10 (d64) */ + "", /* 11 (d32) */ + "0.0625 * ", /* 12 (d16) */ + "0.125 * ", /* 13 (d8) */ + "0.25 * ", /* 14 (d4) */ + "0.5 * " /* 15 (d2) */ }; /* Generate a GLSL parameter that does the input modifier computation and return the input register/mask to use */ @@ -547,7 +547,7 @@ char *out_str) { out_str[0] = 0; - + if (instr == WINED3DSIO_TEXKILL) return; @@ -617,8 +617,8 @@ char pshader = shader_is_pshader_version(This->baseShader.hex_version); char tmpStr[50]; - *is_color = FALSE; - + *is_color = FALSE; + switch (regtype) { case WINED3DSPR_TEMP: sprintf(tmpStr, "R%u", reg); @@ -638,7 +638,7 @@ if (vshader_input_is_color((IWineD3DVertexShader*) This, reg)) *is_color = TRUE; sprintf(tmpStr, "attrib%u", reg); - } + } break; case WINED3DSPR_CONST: { @@ -647,7 +647,7 @@ /* Relative addressing */ if (param & WINED3DSHADER_ADDRMODE_RELATIVE) { - /* Relative addressing on shaders 2.0+ have a relative address token, + /* Relative addressing on shaders 2.0+ have a relative address token, * prior to that, it was hard-coded as "A0.x" because there's only 1 register */ if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2) { glsl_src_param_t rel_param; @@ -846,9 +846,9 @@ /** Process GLSL instruction modifiers */ void shader_glsl_add_instruction_modifiers(SHADER_OPCODE_ARG* arg) { - + DWORD mask = arg->dst & WINED3DSP_DSTMOD_MASK; - + if (arg->opcode->dst_token && mask != 0) { glsl_dst_param_t dst_param; @@ -913,9 +913,9 @@ /***************************************************************************** - * + * * Begin processing individual instruction opcodes - * + * ****************************************************************************/ /* Generate GLSL arithmetic functions (dst = src1 + src2) */ @@ -1286,13 +1286,13 @@ src0_param.param_str, src1_param.param_str, src2_param.param_str); } -/** Handles transforming all WINED3DSIO_M?x? opcodes for +/** Handles transforming all WINED3DSIO_M?x? opcodes for Vertex shaders to GLSL codes */ void shader_glsl_mnxn(SHADER_OPCODE_ARG* arg) { int i; int nComponents = 0; SHADER_OPCODE_ARG tmpArg; - + memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG)); /* Set constants for the temporary argument */ @@ -1301,8 +1301,8 @@ tmpArg.src[0] = arg->src[0]; tmpArg.src_addr[0] = arg->src_addr[0]; tmpArg.src_addr[1] = arg->src_addr[1]; - tmpArg.reg_maps = arg->reg_maps; - + tmpArg.reg_maps = arg->reg_maps; + switch(arg->opcode->opcode) { case WINED3DSIO_M4x4: nComponents = 4; @@ -1336,7 +1336,7 @@ } /** - The LRP instruction performs a component-wise linear interpolation + The LRP instruction performs a component-wise linear interpolation between the second and third operands using the first operand as the blend factor. Equation: (dst = src2 + src0 * (src1 - src2)) This is equivalent to mix(src2, src1, src0); @@ -1408,7 +1408,7 @@ /** Process the WINED3DSIO_SINCOS instruction in GLSL: * VS 2.0 requires that specific cosine and sine constants be passed to this instruction so the hardware * can handle it. But, these functions are built-in for GLSL, so we can just ignore the last 2 params. - * + * * dst.x = cos(src0.?) * dst.y = sin(src0.?) * dst.z = dst.z @@ -1450,7 +1450,7 @@ glsl_src_param_t src1_param; shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_ALL, &src1_param); - + shader_addline(arg->buffer, "for (tmpInt = 0, aL = %s.y; tmpInt < %s.x; tmpInt++, aL += %s.z) {\n", src1_param.reg_name, src1_param.reg_name, src1_param.reg_name); } @@ -1643,7 +1643,7 @@ void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg) { /* FIXME: Make this work for more than just 2D textures */ - + IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader; SHADER_BUFFER* buffer = arg->buffer; DWORD hex_version = This->baseShader.hex_version; @@ -1841,7 +1841,7 @@ current_state->current_row = 0; } -/** Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL +/** Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL * Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */ void pshader_glsl_texm3x3spec(SHADER_OPCODE_ARG* arg) { @@ -1876,7 +1876,7 @@ current_state->current_row = 0; } -/** Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL +/** Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL * Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */ void pshader_glsl_texm3x3vspec(SHADER_OPCODE_ARG* arg) { Modified: trunk/reactos/dll/directx/wine/wined3d/pixelshader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/p… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/pixelshader.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/pixelshader.c Mon Nov 12 17:14:14 2007 @@ -262,7 +262,7 @@ }; static void pshader_set_limits( - IWineD3DPixelShaderImpl *This) { + IWineD3DPixelShaderImpl *This) { This->baseShader.limits.attributes = 0; This->baseShader.limits.address = 0; @@ -272,7 +272,7 @@ case WINED3DPS_VERSION(1,0): case WINED3DPS_VERSION(1,1): case WINED3DPS_VERSION(1,2): - case WINED3DPS_VERSION(1,3): + case WINED3DPS_VERSION(1,3): This->baseShader.limits.temporary = 2; This->baseShader.limits.constant_float = 8; This->baseShader.limits.constant_int = 0; @@ -293,8 +293,8 @@ This->baseShader.limits.packed_input = 0; This->baseShader.limits.label = 0; break; - - /* FIXME: temporaries must match D3DPSHADERCAPS2_0.NumTemps */ + + /* FIXME: temporaries must match D3DPSHADERCAPS2_0.NumTemps */ case WINED3DPS_VERSION(2,0): This->baseShader.limits.temporary = 32; This->baseShader.limits.constant_float = 32; @@ -335,7 +335,7 @@ This->baseShader.limits.sampler = 16; This->baseShader.limits.packed_input = 0; This->baseShader.limits.label = 0; - FIXME("Unrecognized pixel shader version %#x\n", + FIXME("Unrecognized pixel shader version %#x\n", This->baseShader.hex_version); } } @@ -360,7 +360,7 @@ } buffer.buffer = This->device->fixupVertexBuffer; #else - buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE); + buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE); #endif buffer.bsize = 0; buffer.lineNo = 0; @@ -456,7 +456,7 @@ shader_addline(&buffer, "MOV result.color.a, TMP_COLOR.a;\n"); } - shader_addline(&buffer, "END\n"); + shader_addline(&buffer, "END\n"); /* TODO: change to resource.glObjectHandle or something like that */ GL_EXTCALL(glGenProgramsARB(1, &This->baseShader.prgId)); Modified: trunk/reactos/dll/directx/wine/wined3d/resource.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/r… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/resource.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/resource.c Mon Nov 12 17:14:14 2007 @@ -47,7 +47,7 @@ IWineD3DResourceImpl *This = (IWineD3DResourceImpl *)iface; ULONG ref = InterlockedIncrement(&This->resource.ref); TRACE("(%p) : AddRef increasing from %d\n", This, ref - 1); - return ref; + return ref; } ULONG WINAPI IWineD3DResourceImpl_Release(IWineD3DResource *iface) { Modified: trunk/reactos/dll/directx/wine/wined3d/state.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/state.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/state.c Mon Nov 12 17:14:14 2007 @@ -2216,7 +2216,7 @@ isStateDirty(context, STATE_PIXELSHADER)) { return; } - + device->shader_backend->shader_load_constants((IWineD3DDevice *) device, use_ps(device), use_vs(device)); } Modified: trunk/reactos/dll/directx/wine/wined3d/stateblock.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/stateblock.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/stateblock.c Mon Nov 12 17:14:14 2007 @@ -30,11 +30,11 @@ * Stateblock helper functions follow **************************************/ -/** Allocates the correct amount of space for pixel and vertex shader constants, +/** Allocates the correct amount of space for pixel and vertex shader constants, * along with their set/changed flags on the given stateblock object */ HRESULT allocate_shader_constants(IWineD3DStateBlockImpl* object) { - + IWineD3DStateBlockImpl *This = object; #define WINED3D_MEMCHECK(_object) if (NULL == _object) { FIXME("Out of memory!\n"); return E_OUTOFMEMORY; } @@ -66,7 +66,7 @@ IWineD3DStateBlock* iface, SAVEDSTATES* dest, SAVEDSTATES* source) { - + IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface; unsigned bsize = sizeof(BOOL); @@ -104,7 +104,7 @@ IWineD3DStateBlock* iface, SAVEDSTATES* states, BOOL value) { - + IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface; unsigned bsize = sizeof(BOOL); @@ -196,7 +196,7 @@ memcpy(Dest->vertexShaderConstantI, This->vertexShaderConstantI, sizeof(INT) * MAX_CONST_I * 4); memcpy(Dest->pixelShaderConstantB, This->pixelShaderConstantB, sizeof(BOOL) * MAX_CONST_B); memcpy(Dest->pixelShaderConstantI, This->pixelShaderConstantI, sizeof(INT) * MAX_CONST_I * 4); - + memcpy(Dest->streamStride, This->streamStride, sizeof(UINT) * MAX_STREAMS); memcpy(Dest->streamOffset, This->streamOffset, sizeof(UINT) * MAX_STREAMS); memcpy(Dest->streamSource, This->streamSource, sizeof(IWineD3DVertexBuffer*) * MAX_STREAMS); Modified: trunk/reactos/dll/directx/wine/wined3d/surface.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/surface.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/surface.c Mon Nov 12 17:14:14 2007 @@ -988,7 +988,7 @@ case WINED3DFMT_X8R8G8B8: { - /* make sure the X byte is set to alpha on, since it + /* make sure the X byte is set to alpha on, since it could be any random value. This fixes the intro movie in Pirates! */ int size; unsigned int *data; @@ -2444,7 +2444,7 @@ if( !(This->resource.usage & WINED3DUSAGE_RENDERTARGET) ) return WINEDDERR_NOTFLIPPABLE; if(override) { - /* DDraw sets this for the X11 surfaces, so don't confuse the user + /* DDraw sets this for the X11 surfaces, so don't confuse the user * FIXME("(%p) Target override is not supported by now\n", This); * Additionally, it isn't really possible to support triple-buffering * properly on opengl at all @@ -3428,7 +3428,7 @@ IWineD3DPaletteImpl *PalImpl = (IWineD3DPaletteImpl *) Pal; TRACE("(%p)->(%p)\n", This, Pal); - if(This->palette != NULL) + if(This->palette != NULL) if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) This->palette->Flags &= ~WINEDDPCAPS_PRIMARYSURFACE; Modified: trunk/reactos/dll/directx/wine/wined3d/surface_gdi.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/s… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/surface_gdi.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/surface_gdi.c Mon Nov 12 17:14:14 2007 @@ -1465,7 +1465,7 @@ for (y = 0; y < This->pow2Height; y++) { unsigned char *src = (unsigned char *) This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface)); - for (x = 0; x < This->pow2Width; x++) { + for (x = 0; x < This->pow2Width; x++) { unsigned int color; unsigned int comp; int i; Modified: trunk/reactos/dll/directx/wine/wined3d/vertexshader.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/v… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/vertexshader.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/vertexshader.c Mon Nov 12 17:14:14 2007 @@ -181,7 +181,7 @@ This->baseShader.limits.sampler = 0; This->baseShader.limits.label = 0; break; - + case WINED3DVS_VERSION(2,0): case WINED3DVS_VERSION(2,1): This->baseShader.limits.temporary = 12; @@ -315,7 +315,7 @@ } buffer.buffer = This->device->fixupVertexBuffer; #else - buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE); + buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE); #endif buffer.bsize = 0; buffer.lineNo = 0; @@ -339,7 +339,7 @@ /* If this shader doesn't use fog copy the z coord to the fog coord so that we can use table fog */ if (!reg_maps->fog) shader_addline(&buffer, "gl_FogFragCoord = gl_Position.z;\n"); - + /* Write the final position. * * OpenGL coordinates specify the center of the pixel while d3d coords specify @@ -371,7 +371,7 @@ /* Mesa supports only 95 constants */ if (GL_VEND(MESA) || GL_VEND(WINE)) - This->baseShader.limits.constant_float = + This->baseShader.limits.constant_float = min(95, This->baseShader.limits.constant_float); /* Base Declarations */ @@ -401,8 +401,8 @@ shader_addline(&buffer, "MUL TMP_OUT.y, TMP_OUT.y, posFixup.y;\n"); shader_addline(&buffer, "MOV result.position, TMP_OUT;\n"); - - shader_addline(&buffer, "END\n"); + + shader_addline(&buffer, "END\n"); /* TODO: change to resource.glObjectHandle or something like that */ GL_EXTCALL(glGenProgramsARB(1, &This->baseShader.prgId)); @@ -436,7 +436,7 @@ { IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface; TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj); - if (IsEqualGUID(riid, &IID_IUnknown) + if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IWineD3DBase) || IsEqualGUID(riid, &IID_IWineD3DBaseShader) || IsEqualGUID(riid, &IID_IWineD3DVertexShader)) { @@ -495,7 +495,7 @@ static HRESULT WINAPI IWineD3DVertexShaderImpl_GetParent(IWineD3DVertexShader *iface, IUnknown** parent){ IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface; - + *parent = This->parent; IUnknown_AddRef(*parent); TRACE("(%p) : returning %p\n", This, *parent); Modified: trunk/reactos/dll/directx/wine/wined3d/wined3d.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/w… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/wined3d.rbuild (original) +++ trunk/reactos/dll/directx/wine/wined3d/wined3d.rbuild Mon Nov 12 17:14:14 2007 @@ -1,6 +1,6 @@ <?xml version="1.0"?> <!DOCTYPE module SYSTEM "../../../../tools/rbuild/project.dtd"> -<module name="wined3d" type="win32dll" installbase="system32" installname="wined3d.dll" allowwarnings ="true"> +<module name="wined3d" type="win32dll" installbase="system32" installname="wined3d.dll" allowwarnings ="true"> <importlibrary definition="wined3d.def" /> <include base="wined3d">.</include> <include base="ReactOS">include/reactos/wine</include> Modified: trunk/reactos/dll/directx/wine/wined3d/wined3d_main.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/w… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/wined3d_main.c (original) +++ trunk/reactos/dll/directx/wine/wined3d/wined3d_main.c Mon Nov 12 17:14:14 2007 @@ -34,7 +34,7 @@ /* When updating default value here, make sure to update winecfg as well, * where appropriate. */ -wined3d_settings_t wined3d_settings = +wined3d_settings_t wined3d_settings = { VS_HW, /* Hardware by default */ PS_HW, /* Hardware by default */ Modified: trunk/reactos/dll/directx/wine/wined3d/wined3d_private.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/w… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/wined3d_private.h (original) +++ trunk/reactos/dll/directx/wine/wined3d/wined3d_private.h Mon Nov 12 17:14:14 2007 @@ -158,7 +158,7 @@ #define WINED3D_ATR_TYPESIZE(type) glTypeLookup[type].typesize /** - * Settings + * Settings */ #define VS_NONE 0 #define VS_HW 1 @@ -270,7 +270,7 @@ #define MAX_STREAMS 16 /* Maximum possible streams - used for fixed size arrays See MaxStreams in MSDN under GetDeviceCaps */ /* Maximum number of constants provided to the shaders */ -#define HIGHEST_TRANSFORMSTATE 512 +#define HIGHEST_TRANSFORMSTATE 512 /* Highest value in WINED3DTRANSFORMSTATETYPE */ #define MAX_PALETTES 256 @@ -287,7 +287,7 @@ debug_glerror(err), err, A, __FILE__, __LINE__); \ err = glGetError(); \ } while (err != GL_NO_ERROR); \ -} +} /* Trace routines / diagnostics */ /* ---------------------------- */ @@ -356,8 +356,8 @@ /* Trace information per-vertex: (extremely high amount of trace) */ #if 0 /* NOTE: Must be 0 in cvs */ # define VTRACE(A) TRACE A -#else -# define VTRACE(A) +#else +# define VTRACE(A) #endif /* Checking of per-vertex related GL calls */ @@ -385,21 +385,21 @@ the file is deleted */ # if 1 /* NOTE: Must be 1 in cvs, as this is mostly more useful than a trace from program start */ # define SINGLE_FRAME_DEBUGGING -# endif +# endif /* The following, when enabled, lets you see the makeup of the frame, by drawprimitive calls. - It can only be enabled when FRAME_DEBUGGING is also enabled - The contents of the back buffer are written into /tmp/backbuffer_* after each primitive + It can only be enabled when FRAME_DEBUGGING is also enabled + The contents of the back buffer are written into /tmp/backbuffer_* after each primitive array is drawn. */ -# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */ +# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */ # define SHOW_FRAME_MAKEUP 1 -# endif +# endif /* The following, when enabled, lets you see the makeup of the all the textures used during each of the drawprimitive calls. It can only be enabled when SHOW_FRAME_MAKEUP is also enabled. - The contents of the textures assigned to each stage are written into + The contents of the textures assigned to each stage are written into /tmp/texture_*_<Stage>.ppm after each primitive array is drawn. */ # if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */ # define SHOW_TEXTURE_MAKEUP 0 -# endif +# endif extern BOOL isOn; extern BOOL isDumpingFrames; extern LONG primCounter; @@ -954,7 +954,7 @@ /* IWineD3DTexture */ IWineD3DSurface *surfaces[MAX_LEVELS]; - + UINT width; UINT height; float pow2scalingFactorX; @@ -1443,7 +1443,7 @@ { const IWineD3DQueryVtbl *lpVtbl; LONG ref; /* Note: Ref counting not required */ - + IUnknown *parent; /*TODO: replace with iface usage */ #if 0 @@ -1456,8 +1456,8 @@ WINED3DQUERYTYPE type; /* TODO: Think about using a IUnknown instead of a void* */ void *extendedData; - - + + } IWineD3DQueryImpl; extern const IWineD3DQueryVtbl IWineD3DQuery_Vtbl; @@ -1506,7 +1506,7 @@ WineD3DContext *IWineD3DSwapChainImpl_CreateContextForThread(IWineD3DSwapChain *iface); /***************************************************************************** - * Utility function prototypes + * Utility function prototypes */ /* Trace routines */ @@ -1547,9 +1547,9 @@ void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2); /***************************************************************************** - * To enable calling of inherited functions, requires prototypes + * To enable calling of inherited functions, requires prototypes * - * Note: Only require classes which are subclassed, ie resource, basetexture, + * Note: Only require classes which are subclassed, ie resource, basetexture, */ /*** IUnknown methods ***/ extern HRESULT WINAPI IWineD3DResourceImpl_QueryInterface(IWineD3DResource *iface, REFIID riid, void** ppvObject); @@ -1656,7 +1656,7 @@ char attributes[MAX_ATTRIBS]; /* vertex */ char labels[MAX_LABELS]; /* pixel, vertex */ - /* Sampler usage tokens + /* Sampler usage tokens * Use 0 as default (bit 31 is always 1 on a valid token) */ DWORD samplers[max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS)]; char bumpmat; @@ -1729,21 +1729,21 @@ unsigned int label; } SHADER_LIMITS; -/** Keeps track of details for TEX_M#x# shader opcodes which need to +/** Keeps track of details for TEX_M#x# shader opcodes which need to maintain state information between multiple codes */ typedef struct SHADER_PARSE_STATE { unsigned int current_row; DWORD texcoord_w[2]; } SHADER_PARSE_STATE; -/* Base Shader utility functions. +/* Base Shader utility functions. * (may move callers into the same file in the future) */ extern int shader_addline( SHADER_BUFFER* buffer, const char* fmt, ...); extern const SHADER_OPCODE* shader_get_opcode( - IWineD3DBaseShader *iface, + IWineD3DBaseShader *iface, const DWORD code); extern void shader_delete_constant_list( @@ -2012,7 +2012,7 @@ * IDirect3DVertexShader implementation structure */ typedef struct IWineD3DVertexShaderImpl { - /* IUnknown parts*/ + /* IUnknown parts*/ const IWineD3DVertexShaderVtbl *lpVtbl; LONG ref; /* Note: Ref counting not required */ Modified: trunk/reactos/dll/directx/wine/wined3d/wined3d_private_types.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/wined3d/w… ============================================================================== --- trunk/reactos/dll/directx/wine/wined3d/wined3d_private_types.h (original) +++ trunk/reactos/dll/directx/wine/wined3d/wined3d_private_types.h Mon Nov 12 17:14:14 2007 @@ -61,7 +61,7 @@ /** Register types **/ typedef enum _WINED3DSHADER_PARAM_REGISTER_TYPE { - WINED3DSPR_TEMP = 0, + WINED3DSPR_TEMP = 0, WINED3DSPR_INPUT = 1, WINED3DSPR_CONST = 2, WINED3DSPR_ADDR = 3,

1 0

[greatlrd] 30389: remove the entrypoint="0" in d3d8 wine revert white space change, all file in directx/wine are from wine, and no change should be made
by greatlrd＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: greatlrd Date: Mon Nov 12 17:08:56 2007 New Revision: 30389 URL: http://svn.reactos.org/svn/reactos?rev=30389&view=rev Log: remove the entrypoint="0" in d3d8 wine revert white space change, all file in directx/wine are from wine, and no change should be made Modified: trunk/reactos/dll/directx/wine/d3d8/d3d8.rbuild trunk/reactos/dll/directx/wine/d3d8/d3d8_private.h Modified: trunk/reactos/dll/directx/wine/d3d8/d3d8.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/d3d8/d3d8… ============================================================================== --- trunk/reactos/dll/directx/wine/d3d8/d3d8.rbuild (original) +++ trunk/reactos/dll/directx/wine/d3d8/d3d8.rbuild Mon Nov 12 17:08:56 2007 @@ -1,6 +1,6 @@ <?xml version="1.0"?> <!DOCTYPE module SYSTEM "../../../../tools/rbuild/project.dtd"> -<module name="d3d8" type="win32dll" entrypoint="0" installbase="system32" installname="d3d8.dll" allowwarnings ="true"> +<module name="d3d8" type="win32dll" installbase="system32" installname="d3d8.dll" allowwarnings ="true"> <importlibrary definition="d3d8.spec.def" /> <include base="d3d8">.</include> <include base="ReactOS">include/reactos/wine</include> Modified: trunk/reactos/dll/directx/wine/d3d8/d3d8_private.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/directx/wine/d3d8/d3d8… ============================================================================== --- trunk/reactos/dll/directx/wine/d3d8/d3d8_private.h (original) +++ trunk/reactos/dll/directx/wine/d3d8/d3d8_private.h Mon Nov 12 17:08:56 2007 @@ -446,7 +446,7 @@ /* TODO: Generate a valid GUIDs */ /* {83B073CE-6F30-11d9-C687-00046142C14F} */ -DEFINE_GUID(IID_IDirect3DStateBlock8, +DEFINE_GUID(IID_IDirect3DStateBlock8, 0x83b073ce, 0x6f30, 0x11d9, 0xc6, 0x87, 0x0, 0x4, 0x61, 0x42, 0xc1, 0x4f); DEFINE_GUID(IID_IDirect3DVertexDeclaration8,

1 0

[hpoussin] 30388: Do not check for a system menu on the NULL window
by hpoussin＠svn.reactos.org 12 Nov '07

12 Nov '07

Author: hpoussin Date: Mon Nov 12 16:36:34 2007 New Revision: 30388 URL: http://svn.reactos.org/svn/reactos?rev=30388&view=rev Log: Do not check for a system menu on the NULL window Modified: trunk/reactos/subsystems/win32/win32k/ntuser/painting.c Modified: trunk/reactos/subsystems/win32/win32k/ntuser/painting.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/win32k/nt… ============================================================================== --- trunk/reactos/subsystems/win32/win32k/ntuser/painting.c (original) +++ trunk/reactos/subsystems/win32/win32k/ntuser/painting.c Mon Nov 12 16:36:34 2007 @@ -1821,7 +1821,7 @@ ButtonWidth = UserGetSystemMetrics(SM_CXSMSIZE) - 2; else ButtonWidth = UserGetSystemMetrics(SM_CXSIZE) - 2; - if(pWnd->Style & WS_SYSMENU) + if ((pWnd != NULL) && (pWnd->Style & WS_SYSMENU)) { r.right -= 3 + ButtonWidth; if(! (uFlags & DC_SMALLCAP))

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs