Changeset 6935

Timestamp:

Oct 3, 2001, 3:49:41 PM (24 years ago)

Author:

sandervl

Message:

take clipping info into account when blitting

Location:

trunk/src/ddraw

Files:

• OS2CLIPPER.CPP (modified) (4 diffs)
• OS2CLIPPER.H (modified) (3 diffs)
• OS2PALETTE.CPP (modified) (1 diff)
• OS2SURFACE.CPP (modified) (23 diffs)
• OS2SURFACE.H (modified) (3 diffs)
• rectangle.cpp (modified) (2 diffs)

trunk/src/ddraw/OS2CLIPPER.CPP ¶

@@ -1 @@
-/* $Id: OS2CLIPPER.CPP,v 1.13 2001-09-30 22:23:44 sandervl Exp $ */
+/* $Id: OS2CLIPPER.CPP,v 1.14 2001-10-03 13:49:39 sandervl Exp $ */
 
 /*
  * DX clipper class routines
  *
- * Copyright 1998 Sander van Leeuwen
+ * Copyright 1998-2001 Sander van Leeuwen
  * Copyright 1999 Markus Montkowski
  *
  * Project Odin Software License can be found in LICENSE.TXT
+ *
+ * TODO: This is NOT THREAD SAFE!!!
  *
  */
@@ -48 +50 @@
   // lpDraw->Vtbl.AddRef(lpDraw);
   // hDive                   = lpDirectDraw->GetDiveInstance();
+
 }
 
@@ -142 +145 @@
 
   if(!lpdwSize) {
-        return DDERR_INVALIDPARAMS;
+      return DDERR_INVALIDPARAMS;
+  }
+  if(lpRect) {
+      dprintf(("WARNING: clipping the cliplist is not yet implemented"));
   }
   if(me->clipWindow) 
@@ -153 +159 @@
           return DDERR_NOCLIPLIST;
       }
+      //TODO: This is NOT THREAD SAFE!!!
       regiondatasize = me->lpRgnData->rdh.dwSize + me->lpRgnData->rdh.nCount*sizeof(RECT);
       if(lpClipList == NULL) {

trunk/src/ddraw/OS2CLIPPER.H ¶

@@ -1 @@
-/* $Id: OS2CLIPPER.H,v 1.9 2001-09-30 22:23:44 sandervl Exp $ */
+/* $Id: OS2CLIPPER.H,v 1.10 2001-10-03 13:49:39 sandervl Exp $ */
 
 /*
@@ -13 +13 @@
 
 #include "divewrap.h"
+
 #define FAR
 #undef THIS
@@ -29 +30 @@
         int             Referenced;
         inline  HRESULT       GetLastError() { return lastError; };
+
  private:
 

trunk/src/ddraw/OS2PALETTE.CPP ¶

@@ -1 @@
-/* $Id: OS2PALETTE.CPP,v 1.14 2001-03-18 21:44:42 mike Exp $ */
+/* $Id: OS2PALETTE.CPP,v 1.15 2001-10-03 13:49:40 sandervl Exp $ */
 
 /*
  * DX palette class implementation
  *
- * Copyright 1998 Sander va Leeuwen
+ * Copyright 1998 Sander van Leeuwen
  * Copyright 1999 Markus Montkowski
  *

trunk/src/ddraw/OS2SURFACE.CPP ¶

@@ -1 @@
-/* $Id: OS2SURFACE.CPP,v 1.33 2001-09-30 22:23:44 sandervl Exp $ */
+/* $Id: OS2SURFACE.CPP,v 1.34 2001-10-03 13:49:40 sandervl Exp $ */
 
 /*
@@ -6 +6 @@
  * Copyright 1999 Markus Montkowski
  * Copyright 2000 Michal Necasek
+ * Copyright 1998-2001 Sander van Leeuwen
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -2162 +2163 @@
         LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
 {
+ OS2IDirectDrawSurface *dest = (OS2IDirectDrawSurface *)This;
+ OS2IDirectDrawSurface *src  = (OS2IDirectDrawSurface *)lpDDSrcSurface;
+
+ DDSURFACEDESC2  DestSurfaceDesc, SrcSurfaceDesc;
+ DDRectangle    *pIRectDest,*pIRectSrc,*pIRectTest;
+ RECT            DestRect, SrcRect;
+ BOOL            Found;
+ int             i;
+ HRESULT         ret = DD_OK;
+
+  #ifdef DEBUG
+    dprintf(("DDRAW: SurfBlt4 To Surf %08X, from Surf %08X\n",dest,src));
+    if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
+      dprintf(("DDRAW: SurfBlt4 to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
+               lpDestRect->right, lpDestRect->bottom, dest, lpSrcRect->left, lpSrcRect->top,
+               lpSrcRect->right, lpSrcRect->bottom, src));
+
+    _dump_DDBLT(dwFlags);
+  #endif
+
+  if (NULL!=lpDestRect)
+  {
+    // HACK: RA does pass in negative values we might be better return an error,
+    //for now we clip
+#define RA_HACK 1
+
+#ifdef RA_HACK
+    int top,left,bottom,right;
+
+    top    = lpDestRect->top;
+    left   = lpDestRect->left;
+    bottom = lpDestRect->bottom;
+    right  = lpDestRect->right;
+
+    if(top<0)
+    {
+      bottom += top;
+      top = 0;
+    }
+
+    if(top > dest->height)
+      return DDERR_INVALIDPARAMS;
+
+    if(bottom<0)
+      return DDERR_INVALIDPARAMS;
+
+    if(bottom>dest->height)
+      bottom=dest->height;
+
+    if(left<0)
+    {
+      right += left;
+      left = 0;
+    }
+
+    if(left>dest->width)
+      return DDERR_INVALIDPARAMS;
+
+    if(right<0)
+      return DDERR_INVALIDPARAMS;
+
+    if(right>dest->width)
+       right = dest->width;
+#endif    // RA_HACK
+
+    pIRectDest = new DDRectangle( left, top, right, bottom);
+#ifdef RA_HACK
+    DestRect.top    = top;
+    DestRect.left   = left;
+    DestRect.bottom = bottom;
+    DestRect.right  = right;
+#else
+    memcpy(&DestRect,lpDestRect,sizeof(RECT) );
+#endif //RA_HACK
+  }
+  else
+  {
+    pIRectDest = new DDRectangle( 0, 0, dest->width, dest->height);
+    DestRect.top    = 0;
+    DestRect.left   = 0;
+    DestRect.bottom = dest->height;
+    DestRect.right  = dest->width;
+  }
+
+  if(dest->fLocked)
+  {
+    if (NULL==lpDestRect)
+    {
+      // If anything is locked we can't blit to the complete surface as
+      // a part is locked
+      Found = TRUE;
+    }
+    else
+    {
+      // If the dest Rectangle intersects with any of the locked rectangles
+      // we can't blit to it
+
+      Found = FALSE;
+      i=0;
+      while( (i<DPA_GetPtrCount(dest->DPA_LockedRects))  && !Found)
+      {
+        pIRectTest = (DDRectangle*) DPA_FastGetPtr(dest->DPA_LockedRects,i);
+        Found = pIRectDest->intersects(*pIRectTest);
+        i++;
+      }
+
+    }
+    if (Found)
+    {
+      delete pIRectDest;
+      dprintf(("DDRAW: Blt: Dest Surface partially locked\n"));
+      return(DDERR_SURFACEBUSY);
+    }
+  }
+  delete pIRectDest;
+
+  if (NULL!=lpSrcRect)
+  {
+#ifdef RA_HACK
+    // Same as for dest rectangle now for src
+
+    int top,left,bottom,right;
+
+    top    = lpSrcRect->top;
+    left   = lpSrcRect->left;
+    bottom = lpSrcRect->bottom;
+    right  = lpSrcRect->right;
+
+    if(top<0)
+    {
+      bottom += top;
+      top = 0;
+    }
+
+    if(top > src->height)
+      return DDERR_INVALIDPARAMS;
+
+    if(bottom<0)
+      return DDERR_INVALIDPARAMS;
+
+    if(bottom>src->height)
+      bottom=src->height;
+
+    if(left<0)
+    {
+      right += left;
+      left = 0;
+    }
+
+    if(left>src->width)
+      return DDERR_INVALIDPARAMS;
+
+    if(right<0)
+      return DDERR_INVALIDPARAMS;
+
+    if(right>src->width)
+       right = src->width;
+#endif    // RA_HACK
+
+    pIRectSrc = new DDRectangle( left, top, right, bottom );
+#ifdef RA_HACK
+    SrcRect.top    = top;
+    SrcRect.left   = left;
+    SrcRect.bottom = bottom;
+    SrcRect.right  = right;
+#else
+    memcpy(&SrcRect,lpSrcRect,sizeof(RECT) );
+#endif
+  }
+  else
+  {
+    pIRectSrc = new DDRectangle( 0, 0, src->width, src->height);
+    SrcRect.top    = 0;
+    SrcRect.left   = 0;
+    SrcRect.bottom = src->height;
+    SrcRect.right  = src->width;
+  }
+
+  if(src->fLocked)
+  {
+    if (NULL==lpSrcRect)
+    {
+      // If anything is locked we can't blit from the complete surface as
+      // a part is locked
+      Found = TRUE;
+    }
+    else
+    {
+      // If the src Rectangle intersects with any of the locked rectangles of the
+      // source surface we can't blit from it
+
+      Found = FALSE;
+      i=0;
+
+      while((i<DPA_GetPtrCount(src->DPA_LockedRects) ) && !Found)
+      {
+        pIRectTest = (DDRectangle*) DPA_FastGetPtr(src->DPA_LockedRects,i);
+        Found = pIRectDest->intersects(*pIRectTest);
+        i++;
+      }
+
+    }
+
+    if (Found)
+    {
+      delete pIRectSrc;
+      dprintf(("DDRAW: Blt: Src Surface partly locked\n"));
+
+      return(DDERR_SURFACEBUSY);
+    }
+  }
+  delete pIRectSrc;
+
+  //TODO: do we need to check the source for clipping information in case
+  //      the app wants to copy from the frame buffer?
+  if(dest->lpClipper) 
+  {
+      DWORD rgnsize;
+      if(ClipGetClipList((IDirectDrawClipper*)dest->lpClipper, NULL, NULL, &rgnsize) == DD_OK) 
+      {
+          LPRGNDATA lpRgnData = (LPRGNDATA)alloca(rgnsize);
+          if(lpRgnData == NULL) {
+              DebugInt3();
+              goto doblit;
+          }
+          if(ClipGetClipList((IDirectDrawClipper*)dest->lpClipper, NULL, lpRgnData, &rgnsize) == DD_OK) 
+          {
+              RECT newdest, newsrc;
+              LPRECT lpClipRect = (LPRECT)&lpRgnData->Buffer;
+
+              for(i=0;i<lpRgnData->rdh.nCount;i++) 
+              {
+                  if(IntersectRect(&newdest, &DestRect, &lpClipRect[i]) == TRUE) 
+                  {
+                      //TODO: This is not correct for stretching blits
+                      newsrc.left   = SrcRect.left + (newdest.left - DestRect.left);
+                      newsrc.top    = SrcRect.top + (newdest.top - DestRect.top);
+                      newsrc.right  = newsrc.left + RECT_WIDTH(&newdest);
+                      newsrc.bottom = newsrc.top + RECT_HEIGHT(&newdest);
+
+                      ret = SurfDoBlt(This, &newdest, lpDDSrcSurface, &newsrc, dwFlags, lpDDBltFx);
+                      if(ret != DD_OK) {
+                          break;
+                      }
+                  }
+              }
+              return ret;
+          }
+      }
+  }
+doblit:
+  return SurfDoBlt(This, &DestRect, lpDDSrcSurface, &SrcRect, dwFlags, lpDDBltFx);
+}
+//******************************************************************************
+//******************************************************************************
+HRESULT WIN32API SurfDoBlt(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE4 lpDDSrcSurface,
+                           LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
+{
    // We have determine between 3 different blit senarios.
    // 1. Blitting between Divebuffers (Front/Backbuffer and primary surface)
@@ -2178 +2437 @@
 
  int                    x, i, BlitWidth, BlitHeight;
- PALETTEENTRY           SysPal[257];
- PLOGPALETTE            pLogPal = (PLOGPALETTE) SysPal;
- char                   *pBltPos, *pSrcPos;
+ char                  *pBltPos, *pSrcPos;
  DDSURFACEDESC2         DestSurfaceDesc, SrcSurfaceDesc;
- DDRectangle             *pIRectDest,*pIRectSrc,*pIRectTest;
- RECTL                  DestRect, SrcRect;
  BOOL Found;
  DWORD dwSrcColor, dwDestColor;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfBlt4 To Surf %08X, from Surf %08X\n",dest,src));
-    if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
-      dprintf(("DDRAW: SurfBlt4 to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
+  dprintf(("DDRAW: SurfDoBlt To Surf %08X, from Surf %08X\n",dest,src));
+  if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
+      dprintf(("DDRAW: SurfDoBlt to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
                lpDestRect->right, lpDestRect->bottom, dest, lpSrcRect->left, lpSrcRect->top,
                lpSrcRect->right, lpSrcRect->bottom, src));
-
-    _dump_DDBLT(dwFlags);
-  #endif
-
-
-  if (NULL!=lpDestRect)
-  {
-    // HACK: RA does pss in negative values we might be better etrun an error,
-    //for now we clip
-#define RA_HACK 1
-
-#ifdef RA_HACK
-    int top,left,bottom,right;
-
-    top    = lpDestRect->top;
-    left   = lpDestRect->left;
-    bottom = lpDestRect->bottom;
-    right  = lpDestRect->right;
-
-    if(top<0)
-    {
-      bottom += top;
-      top = 0;
-    }
-
-    if(top > dest->height)
-      return DDERR_INVALIDPARAMS;
-
-    if(bottom<0)
-      return DDERR_INVALIDPARAMS;
-
-    if(bottom>dest->height)
-      bottom=dest->height;
-
-    if(left<0)
-    {
-      right += left;
-      left = 0;
-    }
-
-    if(left>dest->width)
-      return DDERR_INVALIDPARAMS;
-
-    if(right<0)
-      return DDERR_INVALIDPARAMS;
-
-    if(right>dest->width)
-       right = dest->width;
-#endif    // RA_HACK
-
-    pIRectDest = new DDRectangle( top,
-                                  left,
-                                  bottom,
-                                  right);
-#ifdef RA_HACK
-    DestRect.top    = top;
-    DestRect.left   = left;
-    DestRect.bottom = bottom;
-    DestRect.right  = right;
-#else
-    memcpy(&DestRect,lpDestRect,sizeof(RECTL) );
-#endif //RA_HACK
-  }
-  else
-  {
-    pIRectDest = new DDRectangle( 0, 0, dest->height, dest->width);
-    DestRect.top    = 0;
-    DestRect.left   = 0;
-    DestRect.bottom = dest->height;
-    DestRect.right  = dest->width;
-  }
-
-  if(dest->fLocked)
-  {
-    if (NULL==lpDestRect)
-    {
-      // If anything is locked we can't blit to the complete surface as
-      // a part is locked
-      Found = TRUE;
-    }
-    else
-    {
-      // If the dest Rectangle intersects with any of the locked rectangles
-      // we can't blit to it
-
-      Found = FALSE;
-      i=0;
-      while( (i<DPA_GetPtrCount(dest->DPA_LockedRects))  && !Found)
-      {
-        pIRectTest = (DDRectangle*) DPA_FastGetPtr(dest->DPA_LockedRects,i);
-        Found = pIRectDest->intersects(*pIRectTest);
-        i++;
-      }
-
-    }
-
-    if (Found)
-    {
-      delete pIRectDest;
-      dprintf(("DDRAW: Blt: Dest Surface partially locked\n"));
-      return(DDERR_SURFACEBUSY);
-    }
-  }
 
   DestSurfaceDesc.dwSize = sizeof(DDSURFACEDESC2);
@@ -2379 +2530 @@
   }
 
-  if (NULL!=lpSrcRect)
-  {
-#ifdef RA_HACK
-    // Same as for dest rectangle now for src
-
-    int top,left,bottom,right;
-
-    top    = lpSrcRect->top;
-    left   = lpSrcRect->left;
-    bottom = lpSrcRect->bottom;
-    right  = lpSrcRect->right;
-
-    if(top<0)
-    {
-      bottom += top;
-      top = 0;
-    }
-
-    if(top > src->height)
-      return DDERR_INVALIDPARAMS;
-
-    if(bottom<0)
-      return DDERR_INVALIDPARAMS;
-
-    if(bottom>src->height)
-      bottom=src->height;
-
-    if(left<0)
-    {
-      right += left;
-      left = 0;
-    }
-
-    if(left>src->width)
-      return DDERR_INVALIDPARAMS;
-
-    if(right<0)
-      return DDERR_INVALIDPARAMS;
-
-    if(right>src->width)
-       right = src->width;
-#endif    // RA_HACK
-
-    pIRectSrc = new DDRectangle( top,
-                                 left,
-                                 bottom,
-                                 right);
-#ifdef RA_HACK
-    SrcRect.top    = top;
-    SrcRect.left   = left;
-    SrcRect.bottom = bottom;
-    SrcRect.right  = right;
-#else
-    memcpy(&SrcRect,lpSrcRect,sizeof(RECTL) );
-#endif
-  }
-  else
-  {
-    pIRectSrc = new DDRectangle( 0, 0, src->height, src->width);
-    SrcRect.top    = 0;
-    SrcRect.left   = 0;
-    SrcRect.bottom = src->height;
-    SrcRect.right  = src->width;
-  }
-
-  if(src->fLocked)
-  {
-    if (NULL==lpSrcRect)
-    {
-      // If anything is locked we can't blit from the complete surface as
-      // a part is locked
-      Found = TRUE;
-    }
-    else
-    {
-      // If the src Rectangle intersects with any of the locked rectangles of the
-      // source surface we can't blit from it
-
-      Found = FALSE;
-      i=0;
-
-      while((i<DPA_GetPtrCount(src->DPA_LockedRects) ) && !Found)
-      {
-        pIRectTest = (DDRectangle*) DPA_FastGetPtr(src->DPA_LockedRects,i);
-        Found = pIRectDest->intersects(*pIRectTest);
-        i++;
-      }
-
-    }
-
-    if (Found)
-    {
-      delete pIRectSrc;
-      dprintf(("DDRAW: Blt: Src Surface partly locked\n"));
-
-      return(DDERR_SURFACEBUSY);
-    }
-  }
-
   if( ( (NULL==lpDestRect) && (NULL!=lpSrcRect) ) ||
       ( (NULL==lpSrcRect) && (NULL!=lpDestRect) ) )
@@ -2486 +2538 @@
   }
 
-  if( ( pIRectDest->width()  != pIRectSrc->width() ) ||
-      ( pIRectDest->height() != pIRectSrc->height() )
+  if( ( RECT_WIDTH(lpDestRect)  != RECT_WIDTH(lpSrcRect) ) ||
+      ( RECT_HEIGHT(lpDestRect) != RECT_HEIGHT(lpSrcRect) )
     )
   {
@@ -2505 +2557 @@
       dprintf(("DDRAW: Src is Primary Surface\n"));
 
-      if( *pIRectDest == *pIRectSrc)
+      if( RECT_EQUAL(lpDestRect, lpSrcRect))
         return DD_OK; // rects are the same => no blit needed
 
@@ -2511 +2563 @@
 
       MoveRects( dest->pDiveBuffer,
-                 (LPRECT)&DestRect,
-                 (LPRECT)&SrcRect,
+                 lpDestRect,
+                 lpSrcRect,
                  dest->dwBytesPPDive,
                  dest->dwPitchDB);
@@ -2519 +2571 @@
       {
         MoveRects( dest->pFrameBuffer,
-                   (LPRECT)&DestRect,
-                   (LPRECT)&SrcRect,
+                   lpDestRect,
+                   lpSrcRect,
                    dest->lpDraw->GetScreenBpp()>>3,
                    dest->dwPitchFB);
@@ -2554 +2606 @@
         dest->BltSolid( dest->pDiveBuffer,
                         dest->pFrameBuffer,
-                        DestRect.top,
-                        DestRect.left,
+                        lpDestRect->top,
+                        lpDestRect->left,
                         dest->dwPitchDB,
                         dest->dwPitchFB,
                         src->pDiveBuffer,
                         src->pFrameBuffer,
-                        SrcRect.top,
-                        SrcRect.left,
-                        pIRectDest->width(),
-                        pIRectDest->height(),
+                        lpSrcRect->top,
+                        lpSrcRect->left,
+                        RECT_WIDTH(lpDestRect),
+                        RECT_HEIGHT(lpDestRect),
                         src->dwPitchDB,
                         src->dwPitchFB
@@ -2571 +2623 @@
       else
       {
-        pBltPos = (char*) dest->pDiveBuffer + (DestRect.top * dest->dwPitchDB) +
-                  (DestRect.left * dest->dwBytesPPDive);
-
-        pSrcPos = (char*) src->pDiveBuffer + (SrcRect.top * src->dwPitchDB) +
-                  (SrcRect.left * src->dwBytesPPDive);
-
-        BlitHeight = pIRectDest->height();
-        BlitWidth = pIRectDest->width();
+        pBltPos = (char*) dest->pDiveBuffer + (lpDestRect->top * dest->dwPitchDB) +
+                  (lpDestRect->left * dest->dwBytesPPDive);
+
+        pSrcPos = (char*) src->pDiveBuffer + (lpSrcRect->top * src->dwPitchDB) +
+                  (lpSrcRect->left * src->dwBytesPPDive);
+
+        BlitHeight = RECT_HEIGHT(lpDestRect);
+        BlitWidth  = RECT_WIDTH(lpDestRect);
         // Transparent Blit
         if( (dwFlags &DDBLT_KEYSRC) || (dwFlags & DDBLT_KEYSRCOVERRIDE) )
@@ -2609 +2661 @@
         // DIVE => DIVE  or Mem => Dive
         // or a rectangle from streen to a buffer can be handelt in the same way
-        pBltPos = (char*) dest->pDiveBuffer + (DestRect.top * dest->dwPitchDB) +
-                  (DestRect.left * dest->dwBytesPPDive);
-
-        pSrcPos = (char*) src->pDiveBuffer + (SrcRect.top * src->dwPitchDB) +
-                  (SrcRect.left * src->dwBytesPPDive);
-
-        BlitHeight = pIRectDest->height();
-        BlitWidth = pIRectDest->width();
+        pBltPos = (char*) dest->pDiveBuffer + (lpDestRect->top * dest->dwPitchDB) +
+                  (lpDestRect->left * dest->dwBytesPPDive);
+
+        pSrcPos = (char*) src->pDiveBuffer + (lpSrcRect->top * src->dwPitchDB) +
+                  (lpSrcRect->left * src->dwBytesPPDive);
+
+        BlitHeight = RECT_HEIGHT(lpDestRect);
+        BlitWidth  = RECT_WIDTH(lpDestRect);
 
         // Check for transparent blit
@@ -2623 +2675 @@
           dest->BltSolid( dest->pDiveBuffer,
                           dest->pFrameBuffer,
-                          DestRect.top,
-                          DestRect.left,
+                          lpDestRect->top,
+                          lpDestRect->left,
                           dest->dwPitchDB,
                           dest->dwPitchFB,
                           src->pDiveBuffer,
                           src->pFrameBuffer,
-                          SrcRect.top,
-                          SrcRect.left,
-                          pIRectDest->width(),
-                          pIRectDest->height(),
+                          lpSrcRect->top,
+                          lpSrcRect->left,
+                          RECT_WIDTH(lpDestRect),
+                          RECT_HEIGHT(lpDestRect),
                           src->dwPitchDB,
                           src->dwPitchFB
@@ -2663 +2715 @@
 
       if( (src->pDiveBuffer == dest->pDiveBuffer) &&
-          (pIRectDest->intersects(*pIRectSrc) ) )
+          (intersects(lpDestRect, lpSrcRect) ) )
       {
         // Overlapping rects  on the same surface ?
@@ -2670 +2722 @@
 
         MoveRects( dest->pDiveBuffer,
-                   (LPRECT)&DestRect,
-                   (LPRECT)&SrcRect,
+                   lpDestRect,
+                   lpSrcRect,
                    dest->dwBytesPPDive,
                    dest->dwPitchDB);
@@ -2679 +2731 @@
         {
           MoveRects( dest->pFrameBuffer,
-                     (LPRECT)&DestRect,
-                     (LPRECT)&SrcRect,
+                     lpDestRect,
+                     lpSrcRect,
                      dest->lpDraw->GetScreenBpp()>>3,
                      dest->dwPitchFB);
@@ -2692 +2744 @@
         dest->BltSolid( dest->pDiveBuffer,
                         dest->pFrameBuffer,
-                        DestRect.top,
-                        DestRect.left,
+                        lpDestRect->top,
+                        lpDestRect->left,
                         dest->dwPitchDB,
                         dest->dwPitchFB,
                         src->pDiveBuffer,
                         src->pFrameBuffer,
-                        SrcRect.top,
-                        SrcRect.left,
-                        pIRectDest->width(),
-                        pIRectDest->height(),
+                        lpSrcRect->top,
+                        lpSrcRect->left,
+                        RECT_WIDTH(lpDestRect),
+                        RECT_HEIGHT(lpDestRect),
                         src->dwPitchDB,
                         src->dwPitchFB
@@ -2708 +2760 @@
       else
       {
-        pBltPos = (char*) dest->pDiveBuffer + (DestRect.top * dest->dwPitchDB) +
-                  (DestRect.left * dest->dwBytesPPDive);
-
-        pSrcPos = (char*) src->pDiveBuffer + (SrcRect.top * src->dwPitchDB) +
-                  (SrcRect.left * src->dwBytesPPDive);
-
-        BlitHeight = pIRectDest->height();
-        BlitWidth = pIRectDest->width();
+        pBltPos = (char*) dest->pDiveBuffer + (lpDestRect->top * dest->dwPitchDB) +
+                  (lpDestRect->left * dest->dwBytesPPDive);
+
+        pSrcPos = (char*) src->pDiveBuffer + (lpSrcRect->top * src->dwPitchDB) +
+                  (lpSrcRect->left * src->dwBytesPPDive);
+
+        BlitHeight = RECT_HEIGHT(lpDestRect);
+        BlitWidth  = RECT_WIDTH(lpDestRect);
         DWORD dwPitch = dest->dwPitchDB;
 
@@ -2751 +2803 @@
             dwPitch = -dwPitch;
             pBltPos = (char*) dest->pDiveBuffer +
-                      ((DestRect.top +BlitHeight)* dest->dwPitchDB) +
-                      (DestRect.left * dest->dwBytesPPDive);
+                      ((lpDestRect->top +BlitHeight)* dest->dwPitchDB) +
+                      (lpDestRect->left * dest->dwBytesPPDive);
 
             dwFx &= ~DDBLTFX_MIRRORUPDOWN;  // remove handled flag
@@ -4654 +4706 @@
   }
 
-
   return rc;
 }
@@ -5000 +5051 @@
     Found = (pIRectEnum != NULL);
 #else
-    pIRectUnlock = new DDRectangle( 0, 0, me->height, me->width);
+    pIRectUnlock = new DDRectangle( 0, 0, me->width, me->height);
 
     while(i<DPA_GetPtrCount(me->DPA_LockedRects) && !Found)
@@ -5115 +5166 @@
   {
     dprintf(("DDRAW: Unlock rectangle\n"));
-    pIRectUnlock = new DDRectangle( lpSurfaceRect->top,
-                                    lpSurfaceRect->left,
-                                    lpSurfaceRect->bottom,
-                                    lpSurfaceRect->right);
+    pIRectUnlock = new DDRectangle( lpSurfaceRect->left, lpSurfaceRect->top,
+                                    lpSurfaceRect->right, lpSurfaceRect->bottom);
   }
   else
   {
     dprintf(("DDRAW: Unlock complete surface\n"));
-    pIRectUnlock = new DDRectangle( 0, 0, me->height, me->width);
+    pIRectUnlock = new DDRectangle( 0, 0, me->width, me->height);
   }
 
@@ -5191 +5240 @@
     dprintf(("DDRAW: Unlock OK\n\n"));
     rc = DD_OK;
+
   }
 

trunk/src/ddraw/OS2SURFACE.H ¶

@@ -1 @@
-/* $Id: OS2SURFACE.H,v 1.13 1999-12-21 01:28:19 hugh Exp $ */
+/* $Id: OS2SURFACE.H,v 1.14 2001-10-03 13:49:41 sandervl Exp $ */
 
 /*
@@ -19 +19 @@
 #undef THIS
 #define THIS VOID*
+
+#define RECT_WIDTH(a)   ((a)->right - (a)->left)
+#define RECT_HEIGHT(a)  ((a)->bottom - (a)->top) 
+#define RECT_EQUAL(a,b) memcmp(a, b, sizeof(RECT))
+
+inline BOOL intersects(LPRECT lprcSrc1, LPRECT lprcSrc2) 
+{
+  if( (lprcSrc1->left >= lprcSrc2->right) || (lprcSrc2->left >= lprcSrc1->right) ||
+      (lprcSrc1->top >= lprcSrc2->bottom) || (lprcSrc2->top >= lprcSrc1->bottom) )
+  {
+      return FALSE;
+  }
+  return TRUE;
+}
 
 typedef struct _OS2RECTL {
@@ -148 +162 @@
         HDPA DPA_LockedRects;
 
-    friend    HRESULT __stdcall SurfQueryInterface(THIS, REFIID riid, LPVOID FAR * ppvObj);
-    friend    ULONG   __stdcall SurfAddRef(THIS);
-    friend    ULONG   __stdcall SurfRelease(THIS);
-    friend    HRESULT __stdcall SurfAddAttachedSurface(THIS, LPDIRECTDRAWSURFACE2);
-    friend    HRESULT __stdcall SurfAddAttachedSurface3(THIS, LPDIRECTDRAWSURFACE3);
-    friend    HRESULT __stdcall SurfAddAttachedSurface4(THIS, LPDIRECTDRAWSURFACE4);
-    friend    HRESULT __stdcall SurfAddOverlayDirtyRect(THIS, LPRECT);
-    friend    HRESULT __stdcall SurfBlt(THIS, LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX);
-    friend    HRESULT __stdcall SurfBlt3(THIS, LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX);
-    friend    HRESULT __stdcall SurfBlt4(THIS, LPRECT,LPDIRECTDRAWSURFACE4, LPRECT,DWORD, LPDDBLTFX);
-    friend    HRESULT __stdcall SurfBltBatch(THIS, LPDDBLTBATCH, DWORD, DWORD );
-    friend    HRESULT __stdcall SurfBltFast(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD);
-    friend    HRESULT __stdcall SurfBltFast3(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD);
-    friend    HRESULT __stdcall SurfBltFast4(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE4, LPRECT,DWORD);
-    friend    HRESULT __stdcall SurfDeleteAttachedSurface(THIS, DWORD,LPDIRECTDRAWSURFACE2);
-    friend    HRESULT __stdcall SurfDeleteAttachedSurface3(THIS, DWORD,LPDIRECTDRAWSURFACE3);
-    friend    HRESULT __stdcall SurfDeleteAttachedSurface4(THIS, DWORD,LPDIRECTDRAWSURFACE4);
-    friend    HRESULT __stdcall SurfEnumAttachedSurfaces(THIS, LPVOID,LPDDENUMSURFACESCALLBACK);
-    friend    HRESULT __stdcall SurfEnumAttachedSurfaces4(THIS, LPVOID,LPDDENUMSURFACESCALLBACK2);
-    friend    HRESULT __stdcall SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK);
-    friend    HRESULT __stdcall SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2);
-    friend    HRESULT __stdcall SurfFlip(THIS, LPDIRECTDRAWSURFACE2 , DWORD);
-    friend    HRESULT __stdcall SurfFlip3(THIS, LPDIRECTDRAWSURFACE3 , DWORD);
-    friend    HRESULT __stdcall SurfFlip4(THIS, LPDIRECTDRAWSURFACE4 , DWORD);
-    friend    HRESULT __stdcall SurfGetAttachedSurface(THIS, LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *);
-    friend    HRESULT __stdcall SurfGetAttachedSurface3(THIS, LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *);
-    friend    HRESULT __stdcall SurfGetAttachedSurface4(THIS, LPDDSCAPS2, LPDIRECTDRAWSURFACE4 FAR *);
-    friend    HRESULT __stdcall SurfGetBltStatus(THIS, DWORD);
-    friend    HRESULT __stdcall SurfGetCaps(THIS, LPDDSCAPS);
-    friend    HRESULT __stdcall SurfGetCaps4(THIS, LPDDSCAPS2);
-    friend    HRESULT __stdcall SurfGetClipper(THIS, LPDIRECTDRAWCLIPPER FAR*);
-    friend    HRESULT __stdcall SurfGetColorKey(THIS, DWORD, LPDDCOLORKEY);
-    friend    HRESULT __stdcall SurfGetDC(THIS, HDC FAR *);
-    friend    HRESULT __stdcall SurfGetFlipStatus(THIS, DWORD);
-    friend    HRESULT __stdcall SurfGetOverlayPosition(THIS, LPLONG, LPLONG );
-    friend    HRESULT __stdcall SurfGetPalette(THIS, LPDIRECTDRAWPALETTE FAR*);
-    friend    HRESULT __stdcall SurfGetPixelFormat(THIS, LPDDPIXELFORMAT);
-    friend    HRESULT __stdcall SurfGetSurfaceDesc(THIS, LPDDSURFACEDESC);
-    friend    HRESULT __stdcall SurfGetSurfaceDesc4(THIS, LPDDSURFACEDESC2);
-    friend    HRESULT __stdcall SurfInitialize(THIS, LPDIRECTDRAW, LPDDSURFACEDESC);
-    friend    HRESULT __stdcall SurfInitialize4(THIS, LPDIRECTDRAW, LPDDSURFACEDESC2);
-    friend    HRESULT __stdcall SurfIsLost(THIS);
-    friend    HRESULT __stdcall SurfLock(THIS, LPRECT,LPDDSURFACEDESC,DWORD,HANDLE);
-    friend    HRESULT __stdcall SurfLock4(THIS, LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE);
-    friend    HRESULT __stdcall SurfReleaseDC(THIS, HDC);
-    friend    HRESULT __stdcall SurfRestore(THIS);
-    friend    HRESULT __stdcall SurfSetClipper(THIS, LPDIRECTDRAWCLIPPER);
-    friend    HRESULT __stdcall SurfSetColorKey(THIS, DWORD, LPDDCOLORKEY);
-    friend    HRESULT __stdcall SurfSetOverlayPosition(THIS, LONG, LONG );
-    friend    HRESULT __stdcall SurfSetPalette(THIS, LPDIRECTDRAWPALETTE);
-    friend    HRESULT __stdcall SurfUnlock(THIS, LPVOID);
-    friend    HRESULT __stdcall SurfUnlock4(THIS, LPRECT);
-    friend    HRESULT __stdcall SurfUpdateOverlay(THIS, LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX);
-    friend    HRESULT __stdcall SurfUpdateOverlay3(THIS, LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX);
-    friend    HRESULT __stdcall SurfUpdateOverlay4(THIS, LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX);
-    friend    HRESULT __stdcall SurfUpdateOverlayDisplay(THIS, DWORD);
-    friend    HRESULT __stdcall SurfUpdateOverlayZOrder(THIS, DWORD, LPDIRECTDRAWSURFACE2);
-    friend    HRESULT __stdcall SurfUpdateOverlayZOrder3(THIS, DWORD, LPDIRECTDRAWSURFACE3);
-    friend    HRESULT __stdcall SurfUpdateOverlayZOrder4(THIS, DWORD, LPDIRECTDRAWSURFACE4);
+    friend    HRESULT  WIN32API SurfQueryInterface(THIS, REFIID riid, LPVOID FAR * ppvObj);
+    friend    ULONG    WIN32API SurfAddRef(THIS);
+    friend    ULONG    WIN32API SurfRelease(THIS);
+    friend    HRESULT  WIN32API SurfAddAttachedSurface(THIS, LPDIRECTDRAWSURFACE2);
+    friend    HRESULT  WIN32API SurfAddAttachedSurface3(THIS, LPDIRECTDRAWSURFACE3);
+    friend    HRESULT  WIN32API SurfAddAttachedSurface4(THIS, LPDIRECTDRAWSURFACE4);
+    friend    HRESULT  WIN32API SurfAddOverlayDirtyRect(THIS, LPRECT);
+    friend    HRESULT  WIN32API SurfBlt(THIS, LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX);
+    friend    HRESULT  WIN32API SurfBlt3(THIS, LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX);
+    friend    HRESULT  WIN32API SurfBlt4(THIS, LPRECT,LPDIRECTDRAWSURFACE4, LPRECT,DWORD, LPDDBLTFX);
+    friend    HRESULT  WIN32API SurfDoBlt(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE4 lpDDSrcSurface,
+                                          LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx);
+    friend    HRESULT  WIN32API SurfBltBatch(THIS, LPDDBLTBATCH, DWORD, DWORD );
+    friend    HRESULT  WIN32API SurfBltFast(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD);
+    friend    HRESULT  WIN32API SurfBltFast3(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD);
+    friend    HRESULT  WIN32API SurfBltFast4(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE4, LPRECT,DWORD);
+    friend    HRESULT  WIN32API SurfDeleteAttachedSurface(THIS, DWORD,LPDIRECTDRAWSURFACE2);
+    friend    HRESULT  WIN32API SurfDeleteAttachedSurface3(THIS, DWORD,LPDIRECTDRAWSURFACE3);
+    friend    HRESULT  WIN32API SurfDeleteAttachedSurface4(THIS, DWORD,LPDIRECTDRAWSURFACE4);
+    friend    HRESULT  WIN32API SurfEnumAttachedSurfaces(THIS, LPVOID,LPDDENUMSURFACESCALLBACK);
+    friend    HRESULT  WIN32API SurfEnumAttachedSurfaces4(THIS, LPVOID,LPDDENUMSURFACESCALLBACK2);
+    friend    HRESULT  WIN32API SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK);
+    friend    HRESULT  WIN32API SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2);
+    friend    HRESULT  WIN32API SurfFlip(THIS, LPDIRECTDRAWSURFACE2 , DWORD);
+    friend    HRESULT  WIN32API SurfFlip3(THIS, LPDIRECTDRAWSURFACE3 , DWORD);
+    friend    HRESULT  WIN32API SurfFlip4(THIS, LPDIRECTDRAWSURFACE4 , DWORD);
+    friend    HRESULT  WIN32API SurfGetAttachedSurface(THIS, LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *);
+    friend    HRESULT  WIN32API SurfGetAttachedSurface3(THIS, LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *);
+    friend    HRESULT  WIN32API SurfGetAttachedSurface4(THIS, LPDDSCAPS2, LPDIRECTDRAWSURFACE4 FAR *);
+    friend    HRESULT  WIN32API SurfGetBltStatus(THIS, DWORD);
+    friend    HRESULT  WIN32API SurfGetCaps(THIS, LPDDSCAPS);
+    friend    HRESULT  WIN32API SurfGetCaps4(THIS, LPDDSCAPS2);
+    friend    HRESULT  WIN32API SurfGetClipper(THIS, LPDIRECTDRAWCLIPPER FAR*);
+    friend    HRESULT  WIN32API SurfGetColorKey(THIS, DWORD, LPDDCOLORKEY);
+    friend    HRESULT  WIN32API SurfGetDC(THIS, HDC FAR *);
+    friend    HRESULT  WIN32API SurfGetFlipStatus(THIS, DWORD);
+    friend    HRESULT  WIN32API SurfGetOverlayPosition(THIS, LPLONG, LPLONG );
+    friend    HRESULT  WIN32API SurfGetPalette(THIS, LPDIRECTDRAWPALETTE FAR*);
+    friend    HRESULT  WIN32API SurfGetPixelFormat(THIS, LPDDPIXELFORMAT);
+    friend    HRESULT  WIN32API SurfGetSurfaceDesc(THIS, LPDDSURFACEDESC);
+    friend    HRESULT  WIN32API SurfGetSurfaceDesc4(THIS, LPDDSURFACEDESC2);
+    friend    HRESULT  WIN32API SurfInitialize(THIS, LPDIRECTDRAW, LPDDSURFACEDESC);
+    friend    HRESULT  WIN32API SurfInitialize4(THIS, LPDIRECTDRAW, LPDDSURFACEDESC2);
+    friend    HRESULT  WIN32API SurfIsLost(THIS);
+    friend    HRESULT  WIN32API SurfLock(THIS, LPRECT,LPDDSURFACEDESC,DWORD,HANDLE);
+    friend    HRESULT  WIN32API SurfLock4(THIS, LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE);
+    friend    HRESULT  WIN32API SurfReleaseDC(THIS, HDC);
+    friend    HRESULT  WIN32API SurfRestore(THIS);
+    friend    HRESULT  WIN32API SurfSetClipper(THIS, LPDIRECTDRAWCLIPPER);
+    friend    HRESULT  WIN32API SurfSetColorKey(THIS, DWORD, LPDDCOLORKEY);
+    friend    HRESULT  WIN32API SurfSetOverlayPosition(THIS, LONG, LONG );
+    friend    HRESULT  WIN32API SurfSetPalette(THIS, LPDIRECTDRAWPALETTE);
+    friend    HRESULT  WIN32API SurfUnlock(THIS, LPVOID);
+    friend    HRESULT  WIN32API SurfUnlock4(THIS, LPRECT);
+    friend    HRESULT  WIN32API SurfUpdateOverlay(THIS, LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX);
+    friend    HRESULT  WIN32API SurfUpdateOverlay3(THIS, LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX);
+    friend    HRESULT  WIN32API SurfUpdateOverlay4(THIS, LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX);
+    friend    HRESULT  WIN32API SurfUpdateOverlayDisplay(THIS, DWORD);
+    friend    HRESULT  WIN32API SurfUpdateOverlayZOrder(THIS, DWORD, LPDIRECTDRAWSURFACE2);
+    friend    HRESULT  WIN32API SurfUpdateOverlayZOrder3(THIS, DWORD, LPDIRECTDRAWSURFACE3);
+    friend    HRESULT  WIN32API SurfUpdateOverlayZOrder4(THIS, DWORD, LPDIRECTDRAWSURFACE4);
     // Added in V2 interface
-    friend    HRESULT __stdcall SurfGetDDInterface(THIS, LPVOID FAR *);
-    friend    HRESULT __stdcall SurfPageLock(THIS, DWORD);
-    friend    HRESULT __stdcall SurfPageUnlock(THIS, DWORD);
+    friend    HRESULT  WIN32API SurfGetDDInterface(THIS, LPVOID FAR *);
+    friend    HRESULT  WIN32API SurfPageLock(THIS, DWORD);
+    friend    HRESULT  WIN32API SurfPageUnlock(THIS, DWORD);
     // Added in V3 interface
-    friend    HRESULT __stdcall SurfSetSurfaceDesc(THIS, LPDDSURFACEDESC, DWORD);
-    friend    HRESULT __stdcall SurfSetSurfaceDesc4(THIS, LPDDSURFACEDESC2, DWORD);
+    friend    HRESULT  WIN32API SurfSetSurfaceDesc(THIS, LPDDSURFACEDESC, DWORD);
+    friend    HRESULT  WIN32API SurfSetSurfaceDesc4(THIS, LPDDSURFACEDESC2, DWORD);
     // Added in V4 interface
-    friend    HRESULT __stdcall SurfSetPrivateData(THIS, REFGUID, LPVOID, DWORD, DWORD);
-    friend    HRESULT __stdcall SurfGetPrivateData(THIS, REFGUID, LPVOID, LPDWORD);
-    friend    HRESULT __stdcall SurfFreePrivateData(THIS, REFGUID);
-    friend    HRESULT __stdcall SurfGetUniquenessValue(THIS, LPDWORD);
-    friend    HRESULT __stdcall SurfChangeUniquenessValue(THIS);
+    friend    HRESULT  WIN32API SurfSetPrivateData(THIS, REFGUID, LPVOID, DWORD, DWORD);
+    friend    HRESULT  WIN32API SurfGetPrivateData(THIS, REFGUID, LPVOID, LPDWORD);
+    friend    HRESULT  WIN32API SurfFreePrivateData(THIS, REFGUID);
+    friend    HRESULT  WIN32API SurfGetUniquenessValue(THIS, LPDWORD);
+    friend    HRESULT  WIN32API SurfChangeUniquenessValue(THIS);
 };
 
 
-HRESULT __stdcall SurfQueryInterface(THIS, REFIID riid, LPVOID FAR * ppvObj);
-ULONG   __stdcall SurfAddRef(THIS);
-ULONG   __stdcall SurfRelease(THIS);
-HRESULT __stdcall SurfAddAttachedSurface(THIS, LPDIRECTDRAWSURFACE2);
-HRESULT __stdcall SurfAddAttachedSurface3(THIS, LPDIRECTDRAWSURFACE3);
-HRESULT __stdcall SurfAddAttachedSurface4(THIS, LPDIRECTDRAWSURFACE4);
-HRESULT __stdcall SurfAddOverlayDirtyRect(THIS, LPRECT);
-HRESULT __stdcall SurfBlt(THIS, LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX);
-HRESULT __stdcall SurfBlt3(THIS, LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX);
-HRESULT __stdcall SurfBlt4(THIS, LPRECT,LPDIRECTDRAWSURFACE4, LPRECT,DWORD, LPDDBLTFX);
-HRESULT __stdcall SurfBltBatch(THIS, LPDDBLTBATCH, DWORD, DWORD );
-HRESULT __stdcall SurfBltFast(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD);
-HRESULT __stdcall SurfBltFast3(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD);
-HRESULT __stdcall SurfBltFast4(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE4, LPRECT,DWORD);
-HRESULT __stdcall SurfDeleteAttachedSurface(THIS, DWORD,LPDIRECTDRAWSURFACE2);
-HRESULT __stdcall SurfDeleteAttachedSurface3(THIS, DWORD,LPDIRECTDRAWSURFACE3);
-HRESULT __stdcall SurfDeleteAttachedSurface4(THIS, DWORD,LPDIRECTDRAWSURFACE4);
-HRESULT __stdcall SurfEnumAttachedSurfaces(THIS, LPVOID,LPDDENUMSURFACESCALLBACK);
-HRESULT __stdcall SurfEnumAttachedSurfaces4(THIS, LPVOID,LPDDENUMSURFACESCALLBACK2);
-HRESULT __stdcall SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK);
-HRESULT __stdcall SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2);
-HRESULT __stdcall SurfFlip(THIS, LPDIRECTDRAWSURFACE2 , DWORD);
-HRESULT __stdcall SurfFlip3(THIS, LPDIRECTDRAWSURFACE3 , DWORD);
-HRESULT __stdcall SurfFlip4(THIS, LPDIRECTDRAWSURFACE4 , DWORD);
-HRESULT __stdcall SurfGetAttachedSurface(THIS, LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *);
-HRESULT __stdcall SurfGetAttachedSurface3(THIS, LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *);
-HRESULT __stdcall SurfGetAttachedSurface4(THIS, LPDDSCAPS2, LPDIRECTDRAWSURFACE4 FAR *);
-HRESULT __stdcall SurfGetBltStatus(THIS, DWORD);
-HRESULT __stdcall SurfGetCaps4(THIS, LPDDSCAPS2);
-HRESULT __stdcall SurfGetCaps(THIS, LPDDSCAPS);
-HRESULT __stdcall SurfGetClipper(THIS, LPDIRECTDRAWCLIPPER FAR*);
-HRESULT __stdcall SurfGetColorKey(THIS, DWORD, LPDDCOLORKEY);
-HRESULT __stdcall SurfGetDC(THIS, HDC FAR *);
-HRESULT __stdcall SurfGetFlipStatus(THIS, DWORD);
-HRESULT __stdcall SurfGetOverlayPosition(THIS, LPLONG, LPLONG );
-HRESULT __stdcall SurfGetPalette(THIS, LPDIRECTDRAWPALETTE FAR*);
-HRESULT __stdcall SurfGetPixelFormat(THIS, LPDDPIXELFORMAT);
-HRESULT __stdcall SurfGetSurfaceDesc(THIS, LPDDSURFACEDESC);
-HRESULT __stdcall SurfGetSurfaceDesc4(THIS, LPDDSURFACEDESC2);
-HRESULT __stdcall SurfInitialize(THIS, LPDIRECTDRAW, LPDDSURFACEDESC);
-HRESULT __stdcall SurfInitialize4(THIS, LPDIRECTDRAW, LPDDSURFACEDESC2);
-HRESULT __stdcall SurfIsLost(THIS);
-HRESULT __stdcall SurfLock(THIS, LPRECT,LPDDSURFACEDESC,DWORD,HANDLE);
-HRESULT __stdcall SurfLock4(THIS, LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE);
-HRESULT __stdcall SurfReleaseDC(THIS, HDC);
-HRESULT __stdcall SurfRestore(THIS);
-HRESULT __stdcall SurfSetClipper(THIS, LPDIRECTDRAWCLIPPER);
-HRESULT __stdcall SurfSetColorKey(THIS, DWORD, LPDDCOLORKEY);
-HRESULT __stdcall SurfSetOverlayPosition(THIS, LONG, LONG );
-HRESULT __stdcall SurfSetPalette(THIS, LPDIRECTDRAWPALETTE);
-HRESULT __stdcall SurfUnlock(THIS, LPVOID);
-HRESULT __stdcall SurfUnlock4(THIS, LPRECT);
-HRESULT __stdcall SurfUpdateOverlay(THIS, LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX);
-HRESULT __stdcall SurfUpdateOverlay3(THIS, LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX);
-HRESULT __stdcall SurfUpdateOverlay4(THIS, LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX);
-HRESULT __stdcall SurfUpdateOverlayDisplay(THIS, DWORD);
-HRESULT __stdcall SurfUpdateOverlayZOrder(THIS, DWORD, LPDIRECTDRAWSURFACE2);
-HRESULT __stdcall SurfUpdateOverlayZOrder3(THIS, DWORD, LPDIRECTDRAWSURFACE3);
-HRESULT __stdcall SurfUpdateOverlayZOrder4(THIS, DWORD, LPDIRECTDRAWSURFACE4);
-HRESULT __stdcall SurfGetDDInterface(THIS, LPVOID FAR *);
-HRESULT __stdcall SurfPageLock(THIS, DWORD);
-HRESULT __stdcall SurfPageUnlock(THIS, DWORD);
-HRESULT __stdcall SurfSetSurfaceDesc(THIS, LPDDSURFACEDESC, DWORD);
-HRESULT __stdcall SurfSetSurfaceDesc4(THIS, LPDDSURFACEDESC2, DWORD);
-HRESULT __stdcall SurfSetPrivateData(THIS, REFGUID, LPVOID, DWORD, DWORD);
-HRESULT __stdcall SurfGetPrivateData(THIS, REFGUID, LPVOID, LPDWORD);
-HRESULT __stdcall SurfFreePrivateData(THIS, REFGUID);
-HRESULT __stdcall SurfGetUniquenessValue(THIS, LPDWORD);
-HRESULT __stdcall SurfChangeUniquenessValue(THIS);
+HRESULT  WIN32API SurfQueryInterface(THIS, REFIID riid, LPVOID FAR * ppvObj);
+ULONG    WIN32API SurfAddRef(THIS);
+ULONG    WIN32API SurfRelease(THIS);
+HRESULT  WIN32API SurfAddAttachedSurface(THIS, LPDIRECTDRAWSURFACE2);
+HRESULT  WIN32API SurfAddAttachedSurface3(THIS, LPDIRECTDRAWSURFACE3);
+HRESULT  WIN32API SurfAddAttachedSurface4(THIS, LPDIRECTDRAWSURFACE4);
+HRESULT  WIN32API SurfAddOverlayDirtyRect(THIS, LPRECT);
+HRESULT  WIN32API SurfBlt(THIS, LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX);
+HRESULT  WIN32API SurfBlt3(THIS, LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX);
+HRESULT  WIN32API SurfBlt4(THIS, LPRECT,LPDIRECTDRAWSURFACE4, LPRECT,DWORD, LPDDBLTFX);
+HRESULT  WIN32API SurfDoBlt(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE4 lpDDSrcSurface,
+                            LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx);
+HRESULT  WIN32API SurfBltBatch(THIS, LPDDBLTBATCH, DWORD, DWORD );
+HRESULT  WIN32API SurfBltFast(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD);
+HRESULT  WIN32API SurfBltFast3(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD);
+HRESULT  WIN32API SurfBltFast4(THIS, DWORD,DWORD,LPDIRECTDRAWSURFACE4, LPRECT,DWORD);
+HRESULT  WIN32API SurfDeleteAttachedSurface(THIS, DWORD,LPDIRECTDRAWSURFACE2);
+HRESULT  WIN32API SurfDeleteAttachedSurface3(THIS, DWORD,LPDIRECTDRAWSURFACE3);
+HRESULT  WIN32API SurfDeleteAttachedSurface4(THIS, DWORD,LPDIRECTDRAWSURFACE4);
+HRESULT  WIN32API SurfEnumAttachedSurfaces(THIS, LPVOID,LPDDENUMSURFACESCALLBACK);
+HRESULT  WIN32API SurfEnumAttachedSurfaces4(THIS, LPVOID,LPDDENUMSURFACESCALLBACK2);
+HRESULT  WIN32API SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK);
+HRESULT  WIN32API SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2);
+HRESULT  WIN32API SurfFlip(THIS, LPDIRECTDRAWSURFACE2 , DWORD);
+HRESULT  WIN32API SurfFlip3(THIS, LPDIRECTDRAWSURFACE3 , DWORD);
+HRESULT  WIN32API SurfFlip4(THIS, LPDIRECTDRAWSURFACE4 , DWORD);
+HRESULT  WIN32API SurfGetAttachedSurface(THIS, LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *);
+HRESULT  WIN32API SurfGetAttachedSurface3(THIS, LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *);
+HRESULT  WIN32API SurfGetAttachedSurface4(THIS, LPDDSCAPS2, LPDIRECTDRAWSURFACE4 FAR *);
+HRESULT  WIN32API SurfGetBltStatus(THIS, DWORD);
+HRESULT  WIN32API SurfGetCaps4(THIS, LPDDSCAPS2);
+HRESULT  WIN32API SurfGetCaps(THIS, LPDDSCAPS);
+HRESULT  WIN32API SurfGetClipper(THIS, LPDIRECTDRAWCLIPPER FAR*);
+HRESULT  WIN32API SurfGetColorKey(THIS, DWORD, LPDDCOLORKEY);
+HRESULT  WIN32API SurfGetDC(THIS, HDC FAR *);
+HRESULT  WIN32API SurfGetFlipStatus(THIS, DWORD);
+HRESULT  WIN32API SurfGetOverlayPosition(THIS, LPLONG, LPLONG );
+HRESULT  WIN32API SurfGetPalette(THIS, LPDIRECTDRAWPALETTE FAR*);
+HRESULT  WIN32API SurfGetPixelFormat(THIS, LPDDPIXELFORMAT);
+HRESULT  WIN32API SurfGetSurfaceDesc(THIS, LPDDSURFACEDESC);
+HRESULT  WIN32API SurfGetSurfaceDesc4(THIS, LPDDSURFACEDESC2);
+HRESULT  WIN32API SurfInitialize(THIS, LPDIRECTDRAW, LPDDSURFACEDESC);
+HRESULT  WIN32API SurfInitialize4(THIS, LPDIRECTDRAW, LPDDSURFACEDESC2);
+HRESULT  WIN32API SurfIsLost(THIS);
+HRESULT  WIN32API SurfLock(THIS, LPRECT,LPDDSURFACEDESC,DWORD,HANDLE);
+HRESULT  WIN32API SurfLock4(THIS, LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE);
+HRESULT  WIN32API SurfReleaseDC(THIS, HDC);
+HRESULT  WIN32API SurfRestore(THIS);
+HRESULT  WIN32API SurfSetClipper(THIS, LPDIRECTDRAWCLIPPER);
+HRESULT  WIN32API SurfSetColorKey(THIS, DWORD, LPDDCOLORKEY);
+HRESULT  WIN32API SurfSetOverlayPosition(THIS, LONG, LONG );
+HRESULT  WIN32API SurfSetPalette(THIS, LPDIRECTDRAWPALETTE);
+HRESULT  WIN32API SurfUnlock(THIS, LPVOID);
+HRESULT  WIN32API SurfUnlock4(THIS, LPRECT);
+HRESULT  WIN32API SurfUpdateOverlay(THIS, LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX);
+HRESULT  WIN32API SurfUpdateOverlay3(THIS, LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX);
+HRESULT  WIN32API SurfUpdateOverlay4(THIS, LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX);
+HRESULT  WIN32API SurfUpdateOverlayDisplay(THIS, DWORD);
+HRESULT  WIN32API SurfUpdateOverlayZOrder(THIS, DWORD, LPDIRECTDRAWSURFACE2);
+HRESULT  WIN32API SurfUpdateOverlayZOrder3(THIS, DWORD, LPDIRECTDRAWSURFACE3);
+HRESULT  WIN32API SurfUpdateOverlayZOrder4(THIS, DWORD, LPDIRECTDRAWSURFACE4);
+HRESULT  WIN32API SurfGetDDInterface(THIS, LPVOID FAR *);
+HRESULT  WIN32API SurfPageLock(THIS, DWORD);
+HRESULT  WIN32API SurfPageUnlock(THIS, DWORD);
+HRESULT  WIN32API SurfSetSurfaceDesc(THIS, LPDDSURFACEDESC, DWORD);
+HRESULT  WIN32API SurfSetSurfaceDesc4(THIS, LPDDSURFACEDESC2, DWORD);
+HRESULT  WIN32API SurfSetPrivateData(THIS, REFGUID, LPVOID, DWORD, DWORD);
+HRESULT  WIN32API SurfGetPrivateData(THIS, REFGUID, LPVOID, LPDWORD);
+HRESULT  WIN32API SurfFreePrivateData(THIS, REFGUID);
+HRESULT  WIN32API SurfGetUniquenessValue(THIS, LPDWORD);
+HRESULT  WIN32API SurfChangeUniquenessValue(THIS);
 
 void __cdecl MoveRects(char* pBuffer, LPRECT lpDestRect, LPRECT lpSrcRect, int bbp, LONG lPitch);

trunk/src/ddraw/rectangle.cpp ¶

@@ -1 @@
-/* $Id: rectangle.cpp,v 1.5 2001-03-20 23:18:56 mike Exp $ */
+/* $Id: rectangle.cpp,v 1.6 2001-10-03 13:49:41 sandervl Exp $ */
 
 /*
@@ -14 +14 @@
 #include "rectangle.h"
 
-DDRectangle::DDRectangle ( Coord y1,
-                    Coord x1,
-                    Coord y2,
-                    Coord x2 )
+DDRectangle::DDRectangle ( Coord x1,
+                    Coord y1,
+                    Coord x2,
+                    Coord y2 )
 {
   lTop    = y1;