Changeset 2638 for trunk/src


Ignore:
Timestamp:
Feb 4, 2000, 8:31:26 PM (26 years ago)
Author:
hugh
Message:

Bugfixes at many places

Location:
trunk/src/ddraw
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ddraw/OS2DDRAW.CPP

    r2174 r2638  
    1 /* $Id: OS2DDRAW.CPP,v 1.18 1999-12-21 01:28:15 hugh Exp $ */
     1/* $Id: OS2DDRAW.CPP,v 1.19 2000-02-04 19:31:23 hugh Exp $ */
    22
    33/*
    … …  
    9999  Vtbl4.Compact                = DrawCompact;
    100100  Vtbl4.CreateClipper          = DrawCreateClipper;
     101  Vtbl4.CreatePalette          = DrawCreatePalette;
    101102  Vtbl4.CreateSurface          = DrawCreateSurface4;//
    102103  Vtbl4.DuplicateSurface       = DrawDuplicateSurface4;//
    … …  
    231232     !IsEqualGUID(riid, IID_IDirectDraw) &&
    232233     !IsEqualGUID(riid, IID_IDirectDraw2) &&
    233      !IsEqualGUID(riid, IID_IDirectDraw4))
     234     !IsEqualGUID(riid, IID_IDirectDraw4) &&
     235     !IsEqualGUID(riid, IID_IDirect3D))
    234236//&& !IsEqualGUID(riid, IID_IUnknown))
    235237  return E_NOINTERFACE;
    236238
    237239  // ToDo Better way of returning differnent intterfaces for same class
    238 
    239   if(IsEqualGUID(riid, IID_IDirectDraw4))
    240   {
    241     dprintf(("DDRAW: IID_IDirectDraw4 Interface\n"));
    242     me->lpVtbl = &me->Vtbl4;
     240  if(IsEqualGUID(riid, IID_IDirect3D))
     241  {
     242    me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl3D;
    243243  }
    244244  else
    245245  {
    246     dprintf(("DDRAW: No IID_IDirectDraw4 Interface\n"));
    247     me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl;
    248   }
     246    if(IsEqualGUID(riid, IID_IDirectDraw4))
     247    {
     248      dprintf(("DDRAW: IID_IDirectDraw4 Interface\n"));
     249      me->lpVtbl = &me->Vtbl4;
     250    }
     251    else
     252    {
     253      dprintf(("DDRAW: No IID_IDirectDraw4 Interface\n"));
     254      me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl;
     255    }
     256  }
     257  me->lpVtbl2 = me->lpVtbl;
    249258  *ppvObj = This;
    250259  DrawAddRef(This);
    … …  
    14461455    return(DDERR_INVALIDPARAMS);
    14471456
    1448 
     1457  #if 0
    14491458    rc = io_init1();
    14501459
    … …  
    14581467    return(DD_OK);
    14591468  }
    1460 
     1469  #else
     1470    *lpbIsInVB = ! (*lpbIsInVB);
     1471  #endif
    14611472  return(DDERR_UNSUPPORTED);
    14621473}
    … …  
    15451556  rc = DiveSetupBlitter( me->hDive,
    15461557                         &sBlt);
     1558  dprintf(("       DiveSetupBlitter rc=%d",rc));
    15471559
    15481560  return(DD_OK);
    … …  
    15571569 SETUP_BLITTER sBlt;
    15581570
    1559 #ifdef DEBUG
    15601571  dprintf(("DDRAW: SetDisplayMode to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
    1561 #endif
     1572
    15621573  me->screenwidth  = dwWidth;
    15631574  me->screenheight = dwHeight;
    … …  
    15871598  rc = DiveSetupBlitter( me->hDive,
    15881599                         &sBlt);
     1600  dprintf(("       DiveSetupBlitter rc=%d",rc));
    15891601
    15901602  return(DD_OK);

  • trunk/src/ddraw/OS2SURFACE.CPP

    r2192 r2638  
    1 /* $Id: OS2SURFACE.CPP,v 1.22 1999-12-23 00:50:11 hugh Exp $ */
     1/* $Id: OS2SURFACE.CPP,v 1.23 2000-02-04 19:31:24 hugh Exp $ */
    22
    33/*
    … …  
    2222#include "os2palette.h"
    2323#include "os2surface.h"
     24#include "os2util.h"
    2425#include "rectangle.h"
    2526#define _OS2WIN_H
    … …  
    492493  } flags[] = {
    493494#define FE(x) { x, #x},
     495          FE(DDCKEY_COLORSPACE)
     496    FE(DDCKEY_DESTBLT)
     497    FE(DDCKEY_DESTOVERLAY)
     498    FE(DDCKEY_SRCBLT)
     499    FE(DDCKEY_SRCOVERLAY)
     500  };
     501  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
     502    if (flags[i].mask & flagmask)
     503      dprintf(("DDRAW: %s ",flags[i].name));
     504  dprintf(("DDRAW: \n"));
     505}
     506
     507static void _dump_DDPIXELFORMAT(DWORD flagmask) {
     508  int  i;
     509  const struct {
     510    DWORD  mask;
     511    char  *name;
     512  } flags[] = {
     513#define FE(x) { x, #x},
    494514          FE(DDPF_ALPHAPIXELS)
    495515    FE(DDPF_ALPHA)
    … …  
    514534
    515535static void _dump_pixelformat(LPDDPIXELFORMAT pf) {
    516   _dump_DDCOLORKEY(pf->dwFlags);
     536  _dump_DDPIXELFORMAT(pf->dwFlags);
    517537  dprintf(("DDRAW: dwFourCC : %ld\n", pf->dwFourCC));
    518538  dprintf(("DDRAW: RBG bit cbout : %ld\n", pf->dwRGBBitCount));
    … …  
    871891      break;
    872892  }
    873   if( lpDDSurfaceDesc->dwFlags & DDSD_CAPS )
     893  // hack set DDSD_CAPS if the value is other than 0
     894  if( DDSurfaceDesc.ddsCaps.dwCaps)
     895    DDSurfaceDesc.dwFlags |= DDSD_CAPS;
     896
     897  if( DDSurfaceDesc.dwFlags & DDSD_CAPS )
    874898  {
    875899    // First check if we want to create a primary surface while the ddraw object already has one
    876     surfaceType = lpDDSurfaceDesc->ddsCaps.dwCaps;
     900    surfaceType = DDSurfaceDesc.ddsCaps.dwCaps;
    877901
    878902    if( surfaceType & DDSCAPS_PRIMARYSURFACE)
    … …  
    891915      }
    892916
    893       if( (lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT) ||
    894           (lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)  ||
    895           (lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)
     917      if( (DDSurfaceDesc.dwFlags & DDSD_HEIGHT) ||
     918          (DDSurfaceDesc.dwFlags & DDSD_WIDTH)  ||
     919          (DDSurfaceDesc.dwFlags & DDSD_PIXELFORMAT)
    896920        )
    897921      {
    … …  
    952976      DDSurfaceDesc.dwWidth      = lpDraw->GetScreenWidth();
    953977      DDSurfaceDesc.lpSurface    = pFrameBuffer;
    954       lpDDSurfaceDesc->dwFlags   = DDSurfaceDesc.dwFlags;
    955       lpDDSurfaceDesc->dwHeight  = DDSurfaceDesc.dwHeight;
    956       lpDDSurfaceDesc->dwWidth   = DDSurfaceDesc.dwWidth;
    957       lpDDSurfaceDesc->lpSurface = pFrameBuffer;
    958       lpDDSurfaceDesc->lPitch    = DDSurfaceDesc.lPitch;
    959 
    960       lpDDSurfaceDesc->ddsCaps.dwCaps |= DDSCAPS_VISIBLE;
    961978      DDSurfaceDesc.ddsCaps.dwCaps    |= DDSCAPS_VISIBLE;
    962979      lpDraw->SetPrimarySurface(TRUE);
    963       lpDDSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
    964       lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC = (DWORD) lpDraw->GetScreenFourCC();
    965       lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = lpDraw->GetScreenBpp();
    966980      DDSurfaceDesc.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
    967981      DDSurfaceDesc.ddpfPixelFormat.dwFourCC = (DWORD) lpDraw->GetScreenFourCC();
    … …  
    971985      {
    972986        case 4:
    973           lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED4 | DDPF_RGB;
    974987          DDSurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED4 | DDPF_RGB;
    975988          break;
    976989        case 8:
    977           lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8 | DDPF_FOURCC | DDPF_RGB;
    978990          DDSurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8 | DDPF_FOURCC | DDPF_RGB;
    979991          break;
    980992        case 16:
    981           lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_RGB;
    982           lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x0000F800;
    983           lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000007E0;
    984           lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000001F;
    985993          DDSurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_RGB;
    986994          DDSurfaceDesc.ddpfPixelFormat.dwRBitMask = 0x0000F800;
    … …  
    990998        case 24:
    991999        case 32:
    992           lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_RGB;
    993           lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
    994           lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
    995           lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x000000FF;
    9961000          DDSurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_RGB;
    9971001          DDSurfaceDesc.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
    … …  
    10011005        default:
    10021006          // Remove the Pixelformat flag
    1003           lpDDSurfaceDesc->dwFlags &= ~DDSD_PIXELFORMAT;
    10041007          DDSurfaceDesc.dwFlags    &= ~DDSD_PIXELFORMAT;
    1005           #ifdef DEBUG
    1006             dprintf(("DDRAW: Unexpected BitDepth : %d\n",lpDraw->GetScreenBpp()));
    1007           #endif
     1008          dprintf(("DDRAW: Unexpected BitDepth : %d\n",lpDraw->GetScreenBpp()));
    10081009          break;
    10091010      } // end switch
    10101011
    1011       #ifdef DEBUG
    1012         dprintf(("DDRAW: Surface set up, checking other Caps\n"));
    1013       #endif
     1012      dprintf(("DDRAW: Surface set up, checking other Caps\n"));
    10141013
    10151014      if( DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_COMPLEX)
    10161015      {
    1017         #ifdef DEBUG
    1018           dprintf(("DDRAW: Complex Surface\n"));
    1019         #endif
    1020 
    1021         if(lpDDSurfaceDesc->dwFlags & DDSD_BACKBUFFERCOUNT)
     1016        dprintf(("DDRAW: Complex Surface\n"));
     1017
     1018        if(DDSurfaceDesc.dwFlags & DDSD_BACKBUFFERCOUNT)
    10221019        {
    1023           #ifdef DEBUG
    1024             dprintf(("DDRAW: Backbuffer # = %d\n",lpDDSurfaceDesc->dwBackBufferCount));
    1025           #endif
     1020          dprintf(("DDRAW: Backbuffer # = %d\n",DDSurfaceDesc.dwBackBufferCount));
    10261021          memset( &ComplexSurfaceDesc,
    10271022                  0,
    … …  
    10421037          ComplexSurfaceDesc.ddpfPixelFormat.dwRGBBitCount = DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
    10431038
    1044           if(lpDDSurfaceDesc->dwBackBufferCount>1)
     1039          if(DDSurfaceDesc.dwBackBufferCount>1)
    10451040          {
    10461041            ComplexSurfaceDesc.dwFlags |=DDSD_BACKBUFFERCOUNT;
    1047             ComplexSurfaceDesc.dwBackBufferCount = lpDDSurfaceDesc->dwBackBufferCount -1;
     1042            ComplexSurfaceDesc.dwBackBufferCount = DDSurfaceDesc.dwBackBufferCount -1;
    10481043            ComplexSurfaceDesc.ddsCaps.dwCaps|= DDSCAPS_COMPLEX;
    10491044          }
    … …  
    10571052            // Our Primary Buffer is also the frontbuffer of a flipchain
    10581053            DDSurfaceDesc.ddsCaps.dwCaps    |= DDSCAPS_FRONTBUFFER | DDSCAPS_FLIP;
    1059             lpDDSurfaceDesc->ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER | DDSCAPS_FLIP;
    10601054            BackBuffer->SetFrontBuffer(this);
    10611055          }
    … …  
    10671061        else
    10681062        {
     1063          dprintf(("DDRAW: Unsupported Complex Surface\n"));
    10691064          #ifdef DEBUG
    1070             dprintf(("DDRAW: Unsupported Complex Surface\n"));
    1071             _dump_DDSCAPS(lpDDSurfaceDesc->dwFlags);
     1065            _dump_DDSCAPS(DDSurfaceDesc.dwFlags);
    10721066          #endif
    10731067          lastError = DDERR_OUTOFMEMORY;
    … …  
    11201114        dprintf(("DDRAW:  Use Screen Format :"));
    11211115        dwBpp = lpDraw->GetScreenBpp(); // No use Screenformat
    1122         lpDDSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
    1123         lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC = (DWORD) lpDraw->GetScreenFourCC();
    1124         lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = dwBpp;
    11251116        DDSurfaceDesc.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
    11261117        DDSurfaceDesc.ddpfPixelFormat.dwFourCC = (DWORD) lpDraw->GetScreenFourCC();
    … …  
    11291120        {
    11301121          case 4:
    1131             lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED4 | DDPF_RGB;
    11321122            DDSurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED4 | DDPF_RGB;
    11331123            break;
    11341124          case 8:
    1135             lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8 | DDPF_FOURCC | DDPF_RGB;
    11361125            DDSurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8 | DDPF_FOURCC | DDPF_RGB;
    11371126            break;
    11381127          case 16:
    1139             lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_RGB;
    1140             lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x0000F800;
    1141             lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000007E0;
    1142             lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000001F;
    11431128            DDSurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_RGB;
    11441129            DDSurfaceDesc.ddpfPixelFormat.dwRBitMask = 0x0000F800;
    … …  
    11481133          case 24:
    11491134          case 32:
    1150             lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_RGB;
    1151             lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
    1152             lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
    1153             lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x000000FF;
    11541135            DDSurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_RGB;
    11551136            DDSurfaceDesc.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
    … …  
    11591140          default:
    11601141            // Remove the Pixelformat flag
    1161             lpDDSurfaceDesc->dwFlags &= ~DDSD_PIXELFORMAT;
    11621142            DDSurfaceDesc.dwFlags    &= ~DDSD_PIXELFORMAT;
    1163             #ifdef DEBUG
    1164               dprintf(("DDRAW: Unexpected BitDepth : %d\n",lpDraw->GetScreenBpp()));
    1165             #endif
     1143            dprintf(("DDRAW: Unexpected BitDepth : %d\n",lpDraw->GetScreenBpp()));
    11661144            break;
    11671145        } // end switch
    … …  
    12141192          // and blit to the real framebuffer on Unlock to do color conversion
    12151193
    1216           dwPitchDB = (lpDDSurfaceDesc->dwWidth * dwBytesPPDive +7) & ~7;
     1194          dwPitchDB = (DDSurfaceDesc.dwWidth * dwBytesPPDive +7) & ~7;
    12171195
    12181196          // 24 byte more to enable alignment and speed up blitting
    12191197
    1220           pDBreal = (char*)malloc( lpDDSurfaceDesc->dwHeight * dwPitchDB + 24);
     1198          pDBreal = (char*)malloc( DDSurfaceDesc.dwHeight * dwPitchDB + 24);
    12211199          pDiveBuffer = (char*)(((int)pDBreal + 7) & ~7); // align to QWORD
    12221200
    … …  
    12511229
    12521230          // This surface isn't allocated yet, but when the texture is loaded
    1253           #ifdef DEBUG
    1254             dprintf(("DDRAW: Warning : Delayed memory allocation on request\n"));
    1255           #endif
     1231          dprintf(("DDRAW: Warning : Delayed memory allocation on request\n"));
    12561232          DDSurfaceDesc.lpSurface = NULL;
    1257           lpDDSurfaceDesc->lpSurface = NULL;
    12581233        }
    12591234        else
    … …  
    12631238          dprintf(("DDRAW:  Alloc now!\n"));
    12641239
    1265           lpDDSurfaceDesc->dwFlags  |= DDSD_PITCH|DDSD_LPSURFACE;
    1266           DDSurfaceDesc.dwFlags      = lpDDSurfaceDesc->dwFlags;
    1267 
    1268           dwPitchFB = lpDDSurfaceDesc->dwWidth * (dwBpp<8?1:dwBpp/8);
     1240          DDSurfaceDesc.dwFlags      = DDSurfaceDesc.dwFlags;
     1241
     1242          dwPitchFB = DDSurfaceDesc.dwWidth * (dwBpp<8?1:dwBpp/8);
    12691243          dwPitchFB = (dwPitchFB +7) & ~7;  // Align on QWords
    1270           DDSurfaceDesc.lPitch    = dwPitchFB;
    1271           lpDDSurfaceDesc->lPitch = dwPitchFB;
    1272 
    12731244          #ifdef DEBUG
    12741245            if(dwBpp<8)
    … …  
    12811252          // 24 byte more to enable alignment and speed up blitting
    12821253
    1283           pFBreal = (char*)malloc( lpDDSurfaceDesc->dwHeight * dwPitchFB + 24);
     1254          pFBreal = (char*)malloc( DDSurfaceDesc.dwHeight * dwPitchFB + 24);
    12841255
    12851256          if(NULL==pFBreal)
    … …  
    12941265                    pFBreal, pFrameBuffer, dwPitchFB));
    12951266
    1296           lpDDSurfaceDesc->lpSurface = pFrameBuffer;
    12971267          DDSurfaceDesc.lpSurface    = pFrameBuffer;
    1298 
    12991268
    13001269          if( (lpDraw->dCaps.ulDepth ) == dwBpp )
    … …  
    13071276          else
    13081277          {
    1309             dprintf(("DDRAW:  Alloc CCBuf "));
    1310             dwPitchDB = (lpDDSurfaceDesc->dwWidth * (lpDraw->dCaps.ulDepth/8) +7) & ~7;
    1311 
    1312             if(Mainchain)
    1313             {
    1314               dprintf(("DDRAW: with DIVE\n"));
    1315               // This surface is part of flipchain with the primary surface use dive to assoc memory
    1316               pDBreal = (char*)malloc( lpDDSurfaceDesc->dwHeight *
    1317                                            dwPitchDB+24);
    1318               pDiveBuffer = (char*)(((int)pDBreal + 7) & ~7); // align to QWORD
    1319               diveBufNr = 0;
    1320               rc = DiveAllocImageBuffer( hDive,
    1321                                          &diveBufNr,
    1322                                          lpDraw->dCaps.fccColorEncoding,
    1323                                          lpDDSurfaceDesc->dwWidth,
    1324                                          lpDDSurfaceDesc->dwHeight,
    1325                                          dwPitchDB,
    1326                                          (PBYTE)pDiveBuffer);
    1327                dprintf(("DDRAW: rc = 0x%08X\n",rc));
    1328             }
    1329             else
    1330             {
    1331               dprintf( ("with malloc (%dx%d) Pitch %d ",
    1332                         lpDDSurfaceDesc->dwHeight,
    1333                         lpDDSurfaceDesc->dwWidth,
    1334                         dwPitchDB));
    1335               // No so we must create the Divebuffer to do the colortranslation
    1336               // and blit to the real framebuffer on Unlock to do color conversion
    1337               pDBreal = (char*)malloc( lpDDSurfaceDesc->dwHeight *
    1338                                        dwPitchDB + 24);
    1339               pDiveBuffer = (char*)(((int)pDBreal + 7) & ~7); // align to QWORD
    1340             }
     1278            dwPitchDB = (DDSurfaceDesc.dwWidth * (lpDraw->dCaps.ulDepth/8) +7) & ~7;
     1279            dprintf( ("DDRAW:  Alloc CCBuf with malloc (%dx%d) Pitch %d ",
     1280                      DDSurfaceDesc.dwHeight,
     1281                      DDSurfaceDesc.dwWidth,
     1282                      dwPitchDB));
     1283            // No so we must create the Divebuffer to do the colortranslation
     1284            // and blit to the real framebuffer on Unlock to do color conversion
     1285            pDBreal = (char*)malloc( DDSurfaceDesc.dwHeight *
     1286                                     dwPitchDB + 24);
     1287            pDiveBuffer = (char*)(((int)pDBreal + 7) & ~7); // align to QWORD
    13411288            dprintf(( " @ %08X\n", pDiveBuffer));
     1289
     1290          }
     1291
     1292          if(Mainchain)
     1293          {
     1294            diveBufNr = 0;
     1295            rc = DiveAllocImageBuffer( hDive,
     1296                                       &diveBufNr,
     1297                                       lpDraw->dCaps.fccColorEncoding,
     1298                                       DDSurfaceDesc.dwWidth,
     1299                                       DDSurfaceDesc.dwHeight,
     1300                                       dwPitchDB,
     1301                                       (PBYTE)pDiveBuffer);
     1302             dprintf(("DDRAW: rc = 0x%08X\n",rc));
    13421303          }
    13431304
    … …  
    13521313        // remove the flag
    13531314        dwCaps &= ~DDSCAPS_COMPLEX;
    1354         #ifdef DEBUG
    1355           dprintf(("DDRAW: Complex Surface\n"));
    1356         #endif
    1357 
    1358         if(lpDDSurfaceDesc->dwFlags & DDSD_BACKBUFFERCOUNT)
     1315        dprintf(("DDRAW: Complex Surface\n"));
     1316
     1317        if(DDSurfaceDesc.dwFlags & DDSD_BACKBUFFERCOUNT)
    13591318        {
    1360           lpDDSurfaceDesc->dwFlags &= ~DDSD_BACKBUFFERCOUNT;
    1361           #ifdef DEBUG
    1362             dprintf(("DDRAW: Backbuffer # = %d\n",lpDDSurfaceDesc->dwBackBufferCount));
    1363           #endif
    1364           memcpy(&ComplexSurfaceDesc,lpDDSurfaceDesc,sizeof(DDSURFACEDESC2));
     1319          dprintf(("DDRAW: Backbuffer # = %d\n",DDSurfaceDesc.dwBackBufferCount));
     1320
     1321          memcpy( &ComplexSurfaceDesc,
     1322                  &DDSurfaceDesc,
     1323                  sizeof(DDSURFACEDESC2));
     1324          ComplexSurfaceDesc.dwFlags        &= ~DDSD_BACKBUFFERCOUNT;
    13651325          ComplexSurfaceDesc.ddsCaps.dwCaps |= DDSCAPS_FLIP;        // set flip
    13661326          ComplexSurfaceDesc.ddsCaps.dwCaps &= ~DDSCAPS_BACKBUFFER; // remove backbuffer
    … …  
    13881348
    13891349        // MipMap Surfaces are handled here
    1390         if( (lpDDSurfaceDesc->dwFlags & DDSD_MIPMAPCOUNT) &&
     1350        if( (DDSurfaceDesc.dwFlags & DDSD_MIPMAPCOUNT) &&
    13911351            (dwCaps & DDSCAPS_TEXTURE) &&
    13921352            (dwCaps & DDSCAPS_MIPMAP) )
    … …  
    13941354          dwCaps &= ~ (DDSCAPS_TEXTURE | DDSCAPS_MIPMAP);
    13951355
    1396           lpDDSurfaceDesc->dwFlags &= ~DDSD_MIPMAPCOUNT;
    1397           #ifdef DEBUG
    1398             dprintf(("DDRAW: Mipmpa # = %d\n",lpDDSurfaceDesc->dwMipMapCount));
    1399           #endif
     1356          dprintf(("DDRAW: Mipmpa # = %d\n",DDSurfaceDesc.dwMipMapCount));
    14001357          memcpy( &ComplexSurfaceDesc,
    1401                   lpDDSurfaceDesc,
     1358                  &DDSurfaceDesc,
    14021359                  sizeof(DDSURFACEDESC2));
    14031360          ComplexSurfaceDesc.dwMipMapCount = 0;
    1404 
    1405           for(int i =0; i < lpDDSurfaceDesc->dwMipMapCount; i++)
     1361          ComplexSurfaceDesc.dwFlags &= ~DDSD_MIPMAPCOUNT;
     1362
     1363          for(int i =0; i < DDSurfaceDesc.dwMipMapCount; i++)
    14061364          {
    1407             #ifdef DEBUG
    1408               dprintf(("DDRAW: Creating MipMap %d\n",i));
    1409             #endif
     1365            dprintf(("DDRAW: Creating MipMap %d\n",i));
    14101366            // Mpmaps shirnk by 2
    14111367            ComplexSurfaceDesc.dwWidth  /= 2;
    … …  
    14221378            {
    14231379              lastError = MipMapSurface->GetLastError();
    1424               #ifdef DEBUG
    1425                 dprintf(("DDRAW: Attached surface creation returned error %d\n",lastError));
    1426               #endif
     1380              dprintf(("DDRAW: Attached surface creation returned error %d\n",lastError));
    14271381              return;
    14281382            } // Endif Errorcheck
    1429           } //End for(i =0; i < lpDDSurfaceDesc->dwMipMapCount; i++)
     1383          } //End for(i =0; i < DDSurfaceDesc.dwMipMapCount; i++)
    14301384        } // End of MipMaps
    14311385
    1432         #ifdef DEBUG
    1433           if(lpDDSurfaceDesc->dwFlags)
     1386        #if 0
     1387          if(DDSurfaceDesc.dwFlags)
    14341388            dprintf(("DDRAW: Unsupported Complex Surface\n"));
    14351389        #endif
    … …  
    14521406    {
    14531407      dprintf(("DDRAW: Some Error Check Flags\n"));
    1454       _dump_DDSCAPS(lpDDSurfaceDesc->dwFlags);
     1408      _dump_DDSCAPS(DDSurfaceDesc.dwFlags);
    14551409    }
    14561410  #endif
    … …  
    14621416
    14631417  int i, FillWidth, FillHeight, Top, Left;
    1464   //char *pLine, *pFillPos;
    1465 
    1466   //DWORD *pColor, dwColor,y;
    14671418  DWORD *pPal24;
    14681419  WORD  *pPal16;
    … …  
    15401491    dprintf(("DDRAW: ColorFill function is NULL!!"));
    15411492  }
    1542 /*
    1543   switch(dwBytesPPDive)
    1544   {
    1545     case 1:
    1546       dprintf(("DDRAW: 8 Bit\n"));
    1547       dwColor = (dwFillColor<<24) + (dwFillColor<<16) +
    1548                 (dwFillColor<<8)  + (dwFillColor);
    1549       for(i=0,pColor = (DWORD*)pLine;i<(FillWidth/4);i++)
    1550         pColor[i] = dwColor;
    1551       if(FillWidth % 4)
    1552       {
    1553          pFillPos = (char*) (&pColor[i-1]);
    1554         for(i=0;i<FillWidth % 4;i++)
    1555            pFillPos[i] = (UCHAR) dwColor;
    1556       }
    1557       break;
    1558     case 2:
    1559       dprintf(("DDRAW: 16 Bit\n"));
    1560       if(pDiveBuffer!=pFrameBuffer)
    1561       {
    1562         if(8==lpDraw->GetScreenBpp())
    1563           dwColor = (pPal16[dwFillColor]<<16) + pPal16[dwFillColor];
    1564       }
    1565       else
    1566       {
    1567         dwColor = (dwFillColor<<16) + (dwFillColor);
    1568       }
    1569       dprintf(("DDRAW: Fill with 0x%08X\n",dwColor));
    1570       for(i=0,pColor = (DWORD*)pLine;i<(FillWidth/2);i++)
    1571         pColor[i] = dwColor;
    1572       if(FillWidth % 2)
    1573       {
    1574          pFillPos = (char*)(&pColor[i-1]);
    1575         *((USHORT*)pFillPos) = (USHORT)dwColor;
    1576       }
    1577       break;
    1578     case 3:
    1579       dprintf(("DDRAW: 24 Bit\n"));
    1580 
    1581       dwColor = (dwFillColor<<8);
    1582       for(i=0 ; i<FillWidth ; i++)
    1583       {
    1584          char* pColor = (char*)pLine+(i*3);
    1585         *pColor = dwColor;
    1586       }
    1587       break;
    1588     case 4:
    1589       dprintf(("DDRAW: 32 Bit\n"));
    1590       dwColor = dwFillColor;
    1591       for(i=0,pColor = (DWORD*)pLine;i<FillWidth;i++)
    1592         pColor[i] = dwColor;
    1593       break;
    1594     default:
    1595       #ifdef DEBUG
    1596         dprintf(("DDRAW: Unexpected Bitdepth\n"));
    1597       #endif
    1598       return DDERR_GENERIC;
    1599   } // end switch(dest->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
    1600 
    1601   // First Line has been Filled so FillHeight-1 are left by one
    1602   FillHeight--;
    1603   pFillPos = pLine + dwPitchDB;
    1604   FillWidth = FillWidth*dwBytesPPDive;
    1605 
    1606   for( y=0;y<FillHeight;y++,pFillPos+=dwPitchDB)
    1607   {
    1608     #ifdef USE_ASM
    1609       // ToDo get the loop into an asm function as well to speed up filling
    1610       // maybe remove the creation of the first fill line in an all asm
    1611       // function and use MMX regs to set 8 bytes
    1612       MemFlip(pFillPos,pLine,FillWidth);
    1613     #else
    1614       memcpy(pFillPos,pLine,FillWidth);
    1615     #endif
    1616   }
    1617 
    1618   if(pDiveBuffer!=pFrameBuffer)
    1619   {
    1620     dprintf(("DDRAW: CC-Mode Fill FrameBuffer %08X\n",pFrameBuffer));
    1621 
    1622     if(NULL!=lpDestRect)
    1623     {
    1624       dprintf(("DDRAW: Fill only Rect(%d,%d)(%d,%d)\n", lpDestRect->left, lpDestRect->top,
    1625                lpDestRect->right, lpDestRect->bottom));
    1626       FillWidth  = lpDestRect->right - lpDestRect->left;
    1627       FillHeight = lpDestRect->bottom - lpDestRect->top -1;
    1628       pLine = pFrameBuffer +
    1629               (lpDestRect->top*dwPitchFB) +
    1630               (lpDestRect->left*(lpDraw->GetScreenBpp()>>3));
    1631     }
    1632     else
    1633     {
    1634       dprintf(("DDRAW: Fill all at addr "));
    1635       FillWidth  = width;
    1636       FillHeight = height -1;
    1637       pLine = pFrameBuffer;
    1638     }
    1639     dprintf(("DDRAW: 0x%08X width,height(%d/%d) \n", pLine,FillWidth,FillHeight));
    1640 
    1641     // Colorconversion mode we must also fill the other buffer
    1642     switch(lpDraw->GetScreenBpp())
    1643     {
    1644       case 8:
    1645         dprintf(("DDRAW: 8 Bit\n"));
    1646         dwColor = (dwFillColor<<24) + (dwFillColor<<16) +
    1647                   (dwFillColor<<8)  + (dwFillColor);
    1648         dprintf(("DDRAW: Fill with %08X => 0x%08X\n",dwFillColor,dwColor));
    1649         for(i=0,pColor = (DWORD*)pLine;i<(FillWidth/4);i++)
    1650           pColor[i] = dwColor;
    1651         if(FillWidth % 4)
    1652         {
    1653           pFillPos = (char*) (&pColor[i-1]);
    1654           for(i=0;i<FillWidth % 4;i++)
    1655              pFillPos[i] = (UCHAR) dwColor;
    1656         }
    1657         break;
    1658       case 16:
    1659         dprintf(("DDRAW: 16 Bit\n"));
    1660         dwColor = (dwFillColor<<16) + (dwFillColor);
    1661         dprintf(("DDRAW: Fill with 0x%08X\n",dwColor));
    1662         for(i=0,pColor = (DWORD*)pLine;i<(FillWidth/2);i++)
    1663           pColor[i] = dwColor;
    1664         if(FillWidth % 2)
    1665         {
    1666            pFillPos = (char*)(&pColor[i-1]);
    1667           *((USHORT*)pFillPos) = (USHORT)dwColor;
    1668         }
    1669         break;
    1670       case 24:
    1671         dprintf(("DDRAW: 24 Bit\n"));
    1672         dwColor = (dwFillColor<<8);
    1673         for(i=0 ; i<FillWidth ; i++)
    1674         {
    1675            char* pColor = (char*)pLine+(i*3);
    1676           *pColor = dwColor;
    1677         }
    1678         break;
    1679       case 32:
    1680         dprintf(("DDRAW: 32 Bit\n"));
    1681         dwColor = dwFillColor;
    1682         for(i=0,pColor = (DWORD*)pLine;i<FillWidth;i++)
    1683           pColor[i] = dwColor;
    1684         break;
    1685       default:
    1686         dprintf(("DDRAW: Unsupported # of Bits %d",lpDraw->GetScreenBpp()));
    1687     }
    1688 
    1689     // First Line has been Filled so FillHeight-1 are left by one
    1690     FillHeight--;
    1691 
    1692     pFillPos = pLine + dwPitchFB;
    1693     FillWidth = FillWidth*(lpDraw->GetScreenBpp()>>3);
    1694     for( y=0;y<FillHeight;y++,pFillPos+=dwPitchFB)
    1695     {
    1696       #ifdef USE_ASM
    1697         // ToDo get the loop into an asm function as well to speed up filling
    1698         // maybe remove the creation of the first fill line in an all asm
    1699         // function and use MMX regs to set 8 bytes
    1700         MemFlip(pFillPos,pLine,FillWidth);
    1701       #else
    1702         memcpy(pFillPos,pLine,FillWidth);
    1703       #endif
    1704     }
    1705   }
    1706 */
     1493
    17071494  return(DD_OK);
    17081495}
    … …  
    40513838  if(-1 != me->diveBufNr)
    40523839  {
    4053     dprintf(("DDRAW: DIVE Flipchain"));
     3840    dprintf(("DDRAW: DIVE Flipchain DiveBuffer #%d",FlipSurface->diveBufNr));
    40543841
    40553842    // we got some DIVE surfaces
    … …  
    40673854    {
    40683855      // advance in the flipchain if no valid override surface was passed in
    4069       me->NextFlip = FlipSurface->BackBuffer!=NULL?FlipSurface->BackBuffer:me->BackBuffer;
     3856      // if we reached the end of the flipchain The Frontbuffer is the next to flip to
     3857      me->NextFlip = FlipSurface->BackBuffer!=NULL?FlipSurface->BackBuffer:me;//me->FrontBuffer;
    40703858    }
    40713859  }
    … …  
    43714159      rc = DDERR_GENERIC;
    43724160    }
     4161    InverseDC(me->hdcImage, LockedSurfaceDesc.dwHeight);
    43734162  }
    43744163
    … …  
    47474536      (NULL!=hEvent)
    47484537    )
     4538  {
     4539    dprintf(("DDERR_INVALIDPARAMS"));
    47494540    return DDERR_INVALIDPARAMS;
    4750 
     4541  }
    47514542
    47524543  if (NULL!=lpRect)
    … …  
    50004791  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    50014792  HRESULT rc;
    5002   #ifdef DEBUG
    5003     dprintf(("DDRAW: SurfSetColorKey\n"));
    5004   #endif
     4793
     4794  dprintf(("DDRAW: SurfSetColorKey %d %08X\n", dwFlags, lpDDColKey));
    50054795
    50064796  if (0==dwFlags)
     4797  {
    50074798    return (DDERR_INVALIDPARAMS);
     4799  }
    50084800
    50094801  // as we report only src colorkey in the caps return error on all others flags
    50104802  if( (DDCKEY_DESTBLT|DDCKEY_DESTOVERLAY|DDCKEY_SRCOVERLAY|DDCKEY_COLORSPACE) & dwFlags)
     4803  {
     4804    dprintf(("Unspported colorkey\n"));
    50114805    return(DDERR_UNSUPPORTED);
     4806  }
    50124807
    50134808  if(DDCKEY_SRCBLT & dwFlags)
    50144809  {
     4810
    50154811    //(me->lpVtbl == me->Vtbl4)
    50164812    //  me->Vtbl4->ChangeUniquenessValue(me); // we changed somethin so change this value
    50174813    if(NULL!=lpDDColKey)
    50184814    {
     4815      dprintf(("copy colorkey"));
    50194816      memcpy(&(me->DDSurfaceDesc.ddckCKSrcBlt), lpDDColKey, sizeof(DDCOLORKEY) );
    50204817      me->DDSurfaceDesc.dwFlags |= DDCKEY_SRCBLT;
    … …  
    50244821    else
    50254822    {
     4823      dprintf(("clear colorkey"));
    50264824      memset(&(me->DDSurfaceDesc.ddckCKSrcBlt), 0, sizeof(DDCOLORKEY) );
    50274825      me->DDSurfaceDesc.dwFlags &= ~DDCKEY_SRCBLT;
    … …  
    50304828  }
    50314829  else
     4830  {
     4831    dprintf(("Unsupported flags"));
     4832    #ifdef DEBUG
     4833      _dump_DDCOLORKEY(dwFlags);
     4834    #endif
    50324835    rc = DDERR_INVALIDPARAMS; // some other flags where set => error
    5033 
     4836  }
    50344837  return rc;
    50354838}
    … …  
    50994902  {
    51004903    me->lpPalette->Vtbl.Release((IDirectDrawPalette*)me->lpPalette);  //attach other palette
    5101     return(DD_OK);
     4904    //return(DD_OK);
    51024905  }
    51034906  me->lpPalette = (OS2IDirectDrawPalette *)lpPalette;

  • trunk/src/ddraw/OS2UTIL.CPP

    r1746 r2638  
    1 /* $Id: OS2UTIL.CPP,v 1.8 1999-11-14 22:16:32 hugh Exp $ */
     1/* $Id: OS2UTIL.CPP,v 1.9 2000-02-04 19:31:25 hugh Exp $ */
    22
    33/*
    … …  
    4949//******************************************************************************
    5050
     51HWND WIN32API WindowFromDC(HDC hdc);
     52HWND Win32ToOS2Handle(HWND hwnd);
     53BOOL    APIENTRY _GpiEnableYInversion (HPS hps, LONG lHeight);
     54
     55void InverseDC(HDC hdc, LONG lHeight)
     56{
     57 USHORT sel = RestoreOS2FS();
     58
     59 _GpiEnableYInversion( WinGetPS( Win32ToOS2Handle( WindowFromDC(hdc) ) ), lHeight);
     60 SetFS(sel);
     61
     62}
     63
    5164int InitIO()
    5265{

  • trunk/src/ddraw/OS2UTIL.H

    r1746 r2638  
    1 /* $Id: OS2UTIL.H,v 1.4 1999-11-14 22:16:32 hugh Exp $ */
     1/* $Id: OS2UTIL.H,v 1.5 2000-02-04 19:31:25 hugh Exp $ */
    22
    33/*
    … …  
    1515void  OS2FreeMem(char *lpMem);
    1616void  OS2MaximizeWindow(HWND hwndClient);
     17void InverseDC(HDC hdc, LONG lHeight);
    1718int InitIO();
    1819#endif

  • trunk/src/ddraw/asmutil.asm

    r2174 r2638  
    1 ; $Id: asmutil.asm,v 1.5 1999-12-21 01:28:19 hugh Exp $
     1; $Id: asmutil.asm,v 1.6 2000-02-04 19:31:26 hugh Exp $
    22
    33;
    … …  
    1414.MMX
    1515
    16 CODE32          SEGMENT DWORD PUBLIC USE32 'CODE'
    17                 ASSUME  CS:FLAT ,DS:FLAT,SS:FLAT
     16CODE32  SEGMENT DWORD USE32 PUBLIC 'CODE'
     17CODE32  ENDS
     18DATA32  SEGMENT DWORD USE32 PUBLIC 'DATA'
     19DATA32  ENDS
     20CONST32  SEGMENT DWORD USE32 PUBLIC 'CONST'
     21CONST32  ENDS
     22BSS32  SEGMENT DWORD USE32 PUBLIC 'BSS'
     23BSS32  ENDS
     24DGROUP  GROUP CONST32, BSS32, DATA32
     25  ASSUME  CS:FLAT, DS:FLAT, SS:FLAT, ES:FLAT
     26  DATA32  SEGMENT
     27  DATA32  ENDS
     28  BSS32  SEGMENT
     29  BSS32  ENDS
     30  CONST32  SEGMENT
     31  CONST32  ENDS
     32
     33
     34CODE32  SEGMENT
    1835
    1936    PUBLIC  _BlitColorKey8
    … …  
    295312
    296313JmpTable:
    297   dd offset bltEndMMX8
    298   dd offset blt1MMX8
    299   dd offset blt2MMX8
    300   dd offset blt3MMX8
    301   dd offset blt4MMX8
    302   dd offset blt5MMX8
    303   dd offset blt6MMX8
    304   dd offset blt7MMX8
     314  dd offset cs:bltEndMMX8
     315  dd offset cs:blt1MMX8
     316  dd offset cs:blt2MMX8
     317  dd offset cs:blt3MMX8
     318  dd offset cs:blt4MMX8
     319  dd offset cs:blt5MMX8
     320  dd offset cs:blt6MMX8
     321  dd offset cs:blt7MMX8
    305322align 2
    306323;
    … …  
    479496
    480497JumpTable:
    481   dd offset bltEndMMX16
    482   dd offset blt1MMX16
    483   dd offset blt2MMX16
    484   dd offset blt3MMX16
     498  dd offset cs:bltEndMMX16
     499  dd offset cs:blt1MMX16
     500  dd offset cs:blt2MMX16
     501  dd offset cs:blt3MMX16
    485502align 2
    486503
    … …  
    611628  jmp  ds:SmallJmpTable[ebx*4]
    612629SmallJmpTable:
    613  dd offset BltRecEnd ; BlitWidth is 0 done
    614  dd offset Rec1
    615  dd offset Rec2
    616  dd offset Rec3
    617  dd offset Rec4
    618  dd offset Rec5
    619  dd offset Rec6
    620  dd offset Rec7
    621  dd offset Rec8
    622  dd offset Rec9
    623  dd offset Rec10
    624  dd offset Rec11
    625  dd offset Rec12
    626  dd offset Rec13
    627  dd offset Rec14
    628  dd offset Rec15
     630 dd cs:offset BltRecEnd ; BlitWidth is 0 done
     631 dd cs:offset Rec1
     632 dd cs:offset Rec2
     633 dd cs:offset Rec3
     634 dd cs:offset Rec4
     635 dd cs:offset Rec5
     636 dd cs:offset Rec6
     637 dd cs:offset Rec7
     638 dd cs:offset Rec8
     639 dd cs:offset Rec9
     640 dd cs:offset Rec10
     641 dd cs:offset Rec11
     642 dd cs:offset Rec12
     643 dd cs:offset Rec13
     644 dd cs:offset Rec14
     645 dd cs:offset Rec15
    629646
    630647;One Pixel wide

  • trunk/src/ddraw/ddraw.CPP

    r2174 r2638  
    1 /* $Id: ddraw.CPP,v 1.10 1999-12-21 01:28:15 hugh Exp $ */
     1/* $Id: ddraw.CPP,v 1.11 2000-02-04 19:31:23 hugh Exp $ */
    22
    33/*
    … …  
    1212
    1313#include <memory.h>
    14 
     14#include <stdio.h>
    1515#include <builtin.h>
    1616#define INITGUID
     17#define ICOM_CINTERFACE 1
     18#define CINTERFACE
     19
    1720#include "os2ddraw.h"
     21#include "winerror.h"
    1822// define the following as we include winnt.h
    1923#define _OS2WIN_H
    … …  
    4145  else
    4246  {
    43     //  newdraw->Vtbl.AddRef((IDirectDraw *)newdraw);
     47    newdraw->Vtbl.AddRef((IDirectDraw *)newdraw);
    4448    rc = newdraw->GetLastError();
    4549    if(rc != DD_OK)
    … …  
    142146}
    143147//******************************************************************************
    144 //******************************************************************************
     148
     149/*******************************************************************************
     150 * DirectDraw ClassFactory
     151 *
     152 */
     153
     154typedef struct
     155{
     156    /* IUnknown fields */
     157    ICOM_VTABLE(IClassFactory) *lpvtbl;
     158    DWORD                       ref;
     159} IClassFactoryImpl;
     160
     161static HRESULT WINAPI
     162DDCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
     163{
     164  ICOM_THIS(IClassFactoryImpl,iface);
     165  char buf[80];
     166
     167  if (HIWORD(riid))
     168    WINE_StringFromCLSID(riid,buf);
     169  else
     170    sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
     171  dprintf(("DDRAW:(%p)->(%s,%p),stub!\n",This,buf,ppobj));
     172  return E_NOINTERFACE;
     173}
     174
     175static ULONG WINAPI
     176DDCF_AddRef(LPCLASSFACTORY iface)
     177{
     178  ICOM_THIS(IClassFactoryImpl,iface);
     179  return ++(This->ref);
     180}
     181
     182static ULONG WINAPI DDCF_Release(LPCLASSFACTORY iface)
     183{
     184  ICOM_THIS(IClassFactoryImpl,iface);
     185  /* static class, won't be  freed */
     186  return --(This->ref);
     187}
     188
     189static HRESULT WINAPI DDCF_CreateInstance( LPCLASSFACTORY iface,
     190                                           LPUNKNOWN pOuter,
     191                                           REFIID riid,
     192                                           LPVOID *ppobj)
     193{
     194  ICOM_THIS(IClassFactoryImpl,iface);
     195  LPGUID lpGUID;
     196  lpGUID = (LPGUID) riid;
     197
     198  dprintf(("DDRAW:DDCF_CreateInstance\n"));
     199  if( lpGUID &&
     200      ( (*lpGUID == IID_IDirectDraw ) ||
     201        (*lpGUID == IID_IDirectDraw2) ||
     202        (*lpGUID == IID_IDirectDraw4))
     203    )
     204  {
     205    /* FIXME: reuse already created DirectDraw if present? */
     206    return OS2DirectDrawCreate(lpGUID,(LPDIRECTDRAW*)ppobj,pOuter);
     207  }
     208  return E_NOINTERFACE;
     209}
     210
     211static HRESULT WINAPI DDCF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
     212{
     213  ICOM_THIS(IClassFactoryImpl,iface);
     214  dprintf(("DDRAW:(%p)->(%d),stub!\n",This,dolock));
     215  return S_OK;
     216}
     217
     218static ICOM_VTABLE(IClassFactory) DDCF_Vtbl =
     219{
     220  DDCF_QueryInterface,
     221  DDCF_AddRef,
     222  DDCF_Release,
     223  DDCF_CreateInstance,
     224  DDCF_LockServer
     225};
     226
     227static IClassFactoryImpl DDRAW_CF = {&DDCF_Vtbl, 1 };
     228
     229
     230HRESULT WINAPI DllGetClassObject( REFCLSID rclsid,
     231                                  REFIID riid,
     232                                  LPVOID *ppv)
     233{
     234  char buf[80],xbuf[80];
     235
     236  if (HIWORD(rclsid))
     237    WINE_StringFromCLSID(rclsid,xbuf);
     238  else
     239    sprintf(xbuf,"<guid-0x%04x>",LOWORD(rclsid));
     240  if (HIWORD(riid))
     241    WINE_StringFromCLSID(riid,buf);
     242  else
     243    sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
     244  WINE_StringFromCLSID(riid,xbuf);
     245
     246  dprintf(("DDRAW:(%p,%p,%p)\n", xbuf, buf, ppv));
     247  if (!memcmp(riid,&IID_IClassFactory,sizeof(IID_IClassFactory)))
     248  {
     249    *ppv = (LPVOID)&DDRAW_CF;
     250    DDRAW_CF.lpvtbl->AddRef((IClassFactory*)&DDRAW_CF);
     251    return S_OK;
     252  }
     253  dprintf(("DDRAW: (%p,%p,%p): no interface found.\n", xbuf, buf, ppv));
     254  return E_NOINTERFACE;
     255}
     256
     257
     258/*******************************************************************************
     259 * DllCanUnloadNow [DDRAW.12]  Determines whether the DLL is in use.
     260 *
     261 * RETURNS
     262 *    Success: S_OK
     263 *    Failure: S_FALSE
     264 */
     265HRESULT WINAPI DllCanUnloadNow(void)
     266{
     267  dprintf(("DllCanUnloadNow(void) stub\n"));
     268  return S_FALSE;
     269}//******************************************************************************
     270

  • trunk/src/ddraw/fillfunc.cpp

    r2174 r2638  
    1 /* $Id: fillfunc.cpp,v 1.1 1999-12-21 01:28:15 hugh Exp $ */
     1/* $Id: fillfunc.cpp,v 1.2 2000-02-04 19:31:23 hugh Exp $ */
    22
    33/*
    … …  
    287287  dwCol += (dwCol<<16);
    288288
    289   Fill8( pFB+(dwTop*dwPitchDB)+dwLeft,
     289  Fill8( pFB+(dwTop*dwPitchFB)+dwLeft,
    290290         dwWidth,
    291291         dwHeight,
    292          dwPitchDB,
     292         dwPitchFB,
    293293         dwCol);
    294294
    … …  
    319319  dwCol += (dwCol<<16);
    320320
    321   Fill8( pFB+(dwTop*dwPitchDB)+dwLeft,
     321  Fill8( pFB+(dwTop*dwPitchFB)+dwLeft,
    322322         dwWidth,
    323323         dwHeight,
    324          dwPitchDB,
     324         dwPitchFB,
    325325         dwCol);
    326326
    … …  
    350350  dwCol += (dwCol<<16);
    351351
    352   Fill8( pFB+(dwTop*dwPitchDB)+dwLeft,
     352  Fill8( pFB+(dwTop*dwPitchFB)+dwLeft,
    353353         dwWidth,
    354354         dwHeight,
    355          dwPitchDB,
     355         dwPitchFB,
    356356         dwCol);
    357357
    … …  
    393393  dwCol = dwColor + (dwColor<<16);
    394394
    395   Fill16( pFB+(dwTop*dwPitchDB)+(dwLeft*2),
    396           dwWidth,
    397           dwHeight,
    398           dwPitchDB,
     395  Fill16( pFB+(dwTop*dwPitchFB)+(dwLeft*2),
     396          dwWidth,
     397          dwHeight,
     398          dwPitchFB,
    399399          dwCol);
    400400
    … …  
    424424  dwCol = dwColor + (dwColor<<16);
    425425
    426   Fill16( pFB+(dwTop*dwPitchDB)+(dwLeft*2),
    427           dwWidth,
    428           dwHeight,
    429           dwPitchDB,
     426  Fill16( pFB+(dwTop*dwPitchFB)+(dwLeft*2),
     427          dwWidth,
     428          dwHeight,
     429          dwPitchFB,
    430430          dwCol);
    431431
    … …  
    470470  //dwColor <<=8;
    471471
    472   Fill24( pFB+(dwTop*dwPitchDB)+(dwLeft*3),
    473           dwWidth,
    474           dwHeight,
    475           dwPitchDB,
     472  Fill24( pFB+(dwTop*dwPitchFB)+(dwLeft*3),
     473          dwWidth,
     474          dwHeight,
     475          dwPitchFB,
    476476          dwColor);
    477477
    … …  
    502502  //dwColor <<=8;
    503503
    504   Fill24( pFB+(dwTop*dwPitchDB)+(dwLeft*3),
    505           dwWidth,
    506           dwHeight,
    507           dwPitchDB,
     504  Fill24( pFB+(dwTop*dwPitchFB)+(dwLeft*3),
     505          dwWidth,
     506          dwHeight,
     507          dwPitchFB,
    508508          dwColor);
    509509  Fill32( pDB+(dwTop*dwPitchDB)+(dwLeft*4),
    … …  
    542542  dprintf(("Fill32on16\n"));
    543543
    544   Fill32( pFB+(dwTop*dwPitchDB)+(dwLeft*4),
    545           dwWidth,
    546           dwHeight,
    547           dwPitchDB,
     544  Fill32( pFB+(dwTop*dwPitchFB)+(dwLeft*4),
     545          dwWidth,
     546          dwHeight,
     547          dwPitchFB,
    548548          dwColor);
    549549
    … …  
    572572{
    573573  dprintf(("Fill32on24\n"));
    574   Fill32( pFB+(dwTop*dwPitchDB)+(dwLeft*4),
    575           dwWidth,
    576           dwHeight,
    577           dwPitchDB,
     574  Fill32( pFB+(dwTop*dwPitchFB)+(dwLeft*4),
     575          dwWidth,
     576          dwHeight,
     577          dwPitchFB,
    578578          dwColor);
    579579

  • trunk/src/ddraw/makefile

    r2174 r2638  
    1 # $Id: makefile,v 1.16 1999-12-21 01:28:20 hugh Exp $
     1# $Id: makefile,v 1.17 2000-02-04 19:31:26 hugh Exp $
    22#
    33# ddraw.dll makefile
    … …  
    3030LIBS =  $(PDWIN32_LIB)\pmwinx.lib $(PDWIN32_LIB)\advapi32.lib $(PDWIN32_LIB)\gdi32.lib \
    3131        $(PDWIN32_LIB)\comctl32.lib $(PDWIN32_LIB)\kernel32.lib $(PDWIN32_LIB)\odincrt.lib \
    32         $(PDWIN32_LIB)\user32.lib mmpm2.lib OS2386.LIB $(RTLLIB_O)
     32        $(PDWIN32_LIB)\user32.lib $(PDWIN32_LIB)\ole32.lib mmpm2.lib OS2386.LIB $(RTLLIB_O)
    3333
    3434all: $(TARGET).dll $(TARGET).lib

  • trunk/src/ddraw/os2ddrawmodes.h

    r2174 r2638  
    1 /* $Id: os2ddrawmodes.h,v 1.2 1999-12-21 01:28:19 hugh Exp $ */
     1/* $Id: os2ddrawmodes.h,v 1.3 2000-02-04 19:31:25 hugh Exp $ */
    22
    33/*
    … …  
    2222} OS2_DXMODES, *POS2_DXMODES;
    2323
    24 #define NUM_MODES_DIVE 22
     24#define NUM_MODES_DIVE 30
    2525OS2_DXMODES ModesDive[NUM_MODES_DIVE] =
    2626{
    … …  
    3232  {800,600,8,0},
    3333  {1024,768,8,0},
     34  {1280,1024,8,1},
     35  {1600,1200,8,0},
    3436  {512,384,16,0},
    3537  {640,400,16,1},
    … …  
    3739  {800,600,16,0},
    3840  {1024,768,16,0},
     41  {1280,1024,16,1},
     42  {1600,1200,16,0},
    3943  {512,384,24,0},
    4044  {640,400,24,1},
    … …  
    4246  {800,600,24,0},
    4347  {1024,768,24,0},
     48  {1280,1024,24,1},
     49  {1600,1200,24,0},
    4450  {512,384,32,0},
    4551  {640,400,32,1},
    4652  {640,480,32,0},
    4753  {800,600,32,0},
    48   {1024,768,32,0}
     54  {1024,768,32,0},
     55  {1280,1024,32,1},
     56  {1600,1200,32,0}
    4957};
    5058
Note: See TracChangeset for help on using the changeset viewer.