WineD3D patch submission - wine-devel

22 Sep 2007


      Hi all,
A week or so ago I tried to get a game working in WINE (Titan Quest), 
however it seems it really needs a proper DIB engine before it'll be 
playable.
Anyways, in my attempt to get it working I fixed up some issues w/ 
"IWineD3DDeviceImpl_UpdateSurface.c" in dlls/wined3d, not entirely sure 
how you guys do things around here so I thought i'd just post my changes 
to the function in this mailing list and you can do with it what you 
want.  (Note: it actually has a few different methods of doing one 
thing, enclosed in macro blocks to toggle between them.  Technically the 
first one should work (i think :) once you guys properly implement 
surface locking/unlocking, and it's 'simplest', but the last one is the 
only one that actually works properly (using standard OpenGL calls).
You'll probably have to clean up the code to meet your coding standards 
/ etc, maybe remove the custom byte size calculation of compressed 
images, and some other things - but the functionality is there...  i 
also fixed the existing code that didn't actually do what it was 
supposed to, heh.
Regards,
Mitchell Wheeler
static HRESULT  WINAPI  IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice 
*iface, IWineD3DSurface *pSourceSurface, CONST RECT* pSourceRect, 
IWineD3DSurface *pDestinationSurface, CONST POINT* pDestPoint) {
    IWineD3DDeviceImpl  *This         = (IWineD3DDeviceImpl *) iface;
    /** TODO: remove casts to IWineD3DSurfaceImpl
     *       NOTE: move code to surface to accomplish this
      ****************************************/
    IWineD3DSurfaceImpl *pSrcSurface  = (IWineD3DSurfaceImpl 
*)pSourceSurface;
    IWineD3DSurfaceImpl *pDestSurface  = 
(IWineD3DSurfaceImpl*)pDestinationSurface;
    int srcWidth, srcHeight;
    unsigned int  srcSurfaceWidth, srcSurfaceHeight, destSurfaceWidth, 
destSurfaceHeight;
    WINED3DFORMAT destFormat, srcFormat;
    int srcLeft, srcTop, destLeft, destTop;
    WINED3DPOOL       srcPool, destPool;
    int offset    = 0;
    int rowoffset = 0; /* how many bytes to add onto the end of a row to 
wraparound to the beginning of the next */
    glDescriptor *glDescription = NULL, *glSrcDescription = NULL;
    GLenum dummy;
    int bpp;
    UINT destByteSize = 0, srcByteSize = 0;
    int destPixelByteSize = 0, srcPixelByteSize = 0;
    CONVERT_TYPES convert = NO_CONVERSION;
WINED3DSURFACE_DESC  winedesc;
TRACE("(%p) : Source (%p)  Rect (%p) Destination (%p) Point(%p)\n", 
This, pSourceSurface, pSourceRect, pDestinationSurface, pDestPoint);
    memset(&winedesc, 0, sizeof(winedesc));
    winedesc.Width  = &srcSurfaceWidth;
    winedesc.Height = &srcSurfaceHeight;
    winedesc.Pool   = &srcPool;
    winedesc.Format = &srcFormat;
    winedesc.Size   = &srcByteSize;
IWineD3DSurface_GetDesc(pSourceSurface, &winedesc);
winedesc.Width  = &destSurfaceWidth;
    winedesc.Height = &destSurfaceHeight;
    winedesc.Pool   = &destPool;
    winedesc.Format = &destFormat;
    winedesc.Size   = &destByteSize;
IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
if(srcPool != WINED3DPOOL_SYSTEMMEM  || destPool != 
WINED3DPOOL_DEFAULT){
        WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, 
returning WINED3DERR_INVALIDCALL\n", pSourceSurface, pDestinationSurface);
        return WINED3DERR_INVALIDCALL;
    }
/* This call loads the opengl surface directly, instead of copying 
the surface to the
     * destination's sysmem copy. If surface conversion is needed, use 
BltFast instead to
     * copy in sysmem and use regular surface loading.
     */
    d3dfmt_get_conv((IWineD3DSurfaceImpl *) pDestinationSurface, FALSE, 
TRUE,
                    &dummy, &dummy, &dummy, &convert, &bpp, FALSE);
    if(convert != NO_CONVERSION) {
        return IWineD3DSurface_BltFast(pDestinationSurface,
                                        pDestPoint  ? pDestPoint->x : 0,
                                        pDestPoint  ? pDestPoint->y : 0,
                                        pSourceSurface, (RECT *) 
pSourceRect, 0);
    }
if (destFormat == WINED3DFMT_UNKNOWN) {
        TRACE("(%p) : Converting destination surface from 
WINED3DFMT_UNKNOWN to the source format\n", This);
        IWineD3DSurface_SetFormat(pDestinationSurface, srcFormat);
/* Get the update surface description */
        IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
    }
ActivateContext(This, This->lastActiveRenderTarget, 
CTXUSAGE_RESOURCELOAD);
ENTER_GL();
if (GL_SUPPORT(ARB_MULTITEXTURE)) {
        GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
        checkGLcall("glActiveTextureARB");
    }
/* Make sure the surface is loaded and up to date */
    IWineD3DSurface_PreLoad(pDestinationSurface);
    IWineD3DSurface_GetGlDesc(pDestinationSurface, &glDescription);
    IWineD3DSurface_GetGlDesc(pDestinationSurface, &glSrcDescription);
/* this needs to be done in lines if the sourceRect != the 
sourceWidth */
    srcWidth    = pSourceRect    ? pSourceRect->right - 
pSourceRect->left    : srcSurfaceWidth;
    srcHeight    = pSourceRect    ? pSourceRect->bottom - 
pSourceRect->top    : srcSurfaceHeight;
    srcLeft        = pSourceRect    ? pSourceRect->left                
            : 0;
    srcTop        = pSourceRect    ? pSourceRect->top                    
        : 0;
    destLeft    = pDestPoint    ? pDestPoint->x                        
        : 0;
    destTop        = pDestPoint    ? pDestPoint->y                    
            : 0;
// Calculate the rowOffset / offset values, for copying
    #define ISDXTFORMAT(format) \
        (format == WINED3DFMT_DXT1 || format == WINED3DFMT_DXT2 || 
format == WINED3DFMT_DXT3 || format == WINED3DFMT_DXT4 || format == 
WINED3DFMT_DXT5)
// Calculating this for our selves because I don't have faith in how 
surface->bytesPerPixel is calculated...
    destPixelByteSize = destByteSize / (int)(destSurfaceWidth * 
destSurfaceHeight);
    srcPixelByteSize = srcByteSize / (int)(srcSurfaceWidth * 
srcSurfaceHeight);
if(pSourceRect != NULL)
    {
        // Irregular surface formats
        if (destFormat != srcFormat) {
            FIXME("Can not convert between surface pixel formats...");
// Would require some relatively big code restructuring for 
rare occurances (that shouldn't even be supported?)
return WINED3DERR_INVALIDCALL;
        }
        // Uniform surface formats
        else
        {
            if(srcWidth != srcSurfaceWidth || srcLeft > 0)
            {
                rowoffset = srcSurfaceWidth * srcPixelByteSize;
                offset += (srcLeft * srcPixelByteSize);
            }
if(srcTop > 0)
               offset += srcTop * srcSurfaceWidth * srcPixelByteSize;
        }
}
/* Sanity check */
    if (IWineD3DSurface_GetData(pSourceSurface) == NULL) {
/* need to lock the surface to get the data */
        FIXME("Surfaces has no allocated memory, but should be an in 
memory only surface\n");
    }
/* TODO: Cube and volume support */
    if(rowoffset != 0) {
        // Compressed texture
        if (ISDXTFORMAT(destFormat))
        {
            if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC))
            {
#if 0
                RECT rect;
                rect.left = destLeft;
                rect.top = destTop;
                rect.right = destLeft + srcWidth;
                rect.bottom = destTop + srcHeight;
// Lock source/destination regions
                WINED3DLOCKED_RECT destRect, srcRect;
printf("Locking surfaces...\n");
                if(    
FAILED(IWineD3DSurface_LockRect(pDestinationSurface, &destRect, &rect, 
0)) ||
                    FAILED(IWineD3DSurface_LockRect(pSourceSurface, 
&srcRect, pSourceRect, WINED3DLOCK_READONLY)))
                {
                    // How should we handle this case?  Just returning 
an invalid call for now...
                    return WINED3DERR_INVALIDCALL;
                }
printf("Surfaces locked, copying contents now... ");
                if(destFormat == WINED3DFMT_DXT1) {
                    printf("DXT1\n");
                    //memcpy(destRect.pBits, srcRect.pBits, 
srcRect.Pitch * (srcHeight / 2));
                    //memcpy(destRect.pBits, srcRect.pBits, 
srcRect.Pitch * (srcHeight / 2));
                    memcpy(destRect.pBits, srcRect.pBits, 
ceil(srcWidth/4) * ceil(srcHeight/4) * 8);
                } else {
                    printf("DXT2-5\n");
                    //memcpy(destRect.pBits, srcRect.pBits, 
srcRect.Pitch * (srcHeight / 4));
                    memcpy(destRect.pBits, srcRect.pBits, 
ceil(srcWidth/4) * ceil(srcHeight/4) * 16);
                }
// Unlock source/destination regions
                IWineD3DSurface_UnlockRect(pSourceSurface);
                IWineD3DSurface_UnlockRect(pDestinationSurface);
                printf("Unlocking surfaces...\n");
#elif 0
                // Get pointers to the source/destination buffers
                unsigned char *dest_data = (unsigned 
char*)IWineD3DSurface_GetData(pDestinationSurface);
                const unsigned char *src_data = (unsigned 
char*)IWineD3DSurface_GetData(pSourceSurface);
// Copy subsection of source buffer, in to destination 
buffer.
                unsigned char *dest_ptr = dest_data + offset;
                const unsigned char *src_ptr = src_data + offset;
size_t i;
                for(i = 0; i < srcHeight; ++i) {
                    memcpy(dest_ptr, src_ptr, srcWidth * srcPixelByteSize);
dest_ptr += rowoffset;
                    src_ptr += rowoffset;
                }
// Upload destination buffer to server
                GL_EXTCALL(glCompressedTexImage2DARB(glDescription->target,
                                                    glDescription->level,
glDescription->glFormatInternal,
                                                    srcWidth,
                                                    srcHeight,
                                                    0,
                                                    destByteSize,
                                                    dest_data));
checkGLcall("glCompressedTexImage2DARB");
#elif 1
                int blocksize = 16;
                if(destFormat == WINED3DFMT_DXT1)
                    blocksize = 8;
#define max(a, b) (a > b? a : b)
                srcHeight = max(srcHeight, 4);
                srcWidth = max(srcWidth, 4);
                #undef max
int data_size = (srcWidth / 4) * (srcHeight / 4) * 
blocksize;
                int row_size = data_size / srcHeight;
                int pixel_size = row_size / srcWidth;
                int stride = srcSurfaceWidth * pixel_size;
unsigned char *temp_buffer = HeapAlloc(GetProcessHeap(), 
0, data_size);
                unsigned char *temp_ptr = temp_buffer;
// Debug info
                //printf(" > BytesTotal: %i | BytesPerPixel: %i | 
RowSize: %i\n", data_size, pixel_size, row_size);
                //printf(" > Source: %i -> %i, %i -> %i | Dest: %i, 
%i\n", srcLeft, srcWidth, srcTop, srcHeight, destLeft, destTop);
                //printf(" > Offset: %i\n", (int)((row_size * srcTop) + 
srcLeft * pixel_size));
// Get pointers to the source buffer
                const unsigned char *src_data = (unsigned 
char*)IWineD3DSurface_GetData(pSourceSurface);
                src_data += (stride * srcTop) + srcLeft * pixel_size;
size_t i;
                for(i = 0; i < srcHeight; ++i) {
                    memcpy(temp_ptr, src_data, row_size);
                    temp_ptr += row_size;
                    src_data += stride;
                }
GL_EXTCALL(glCompressedTexSubImage2DARB(
                    glDescription->target,
                    glDescription->level,
                    destLeft,
                    destTop,
                    srcWidth,
                    srcHeight,
                    glDescription->glFormatInternal,
                    data_size,
                    temp_buffer
                ));
                //checkGLcall("glCompressedTexSubImage2DARB");
HeapFree(GetProcessHeap(), 0, temp_buffer);
#endif
            }
            else
            {
                FIXME("TODO: Need to update a DXT compressed texture 
without hardware support\n");
            }
        }
        // Uncompressed texture
        else
        {
            /* not a whole row so we have to do it a line at a time */
            int j;
/* hopefully using pointer addtion will be quicker than 
using a point + j * rowoffset */
            const unsigned char* data =((const unsigned char 
*)IWineD3DSurface_GetData(pSourceSurface)) + offset;
for(j = destTop; j < (srcHeight + destTop); ++j)
            {
                    glTexSubImage2D(glDescription->target
                        ,glDescription->level
                        ,destLeft
                        ,j
                        ,srcWidth
                        ,1
                        ,glDescription->glFormat
                        ,glDescription->glType
                        ,data /* could be quicker using */
                    );
                data += rowoffset;
            }
        }
    } else {
        // Compressed texture
        if (ISDXTFORMAT(destFormat))
        {
            if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC))
            {
                int blocksize = 16;
                if(destFormat == WINED3DFMT_DXT1)
                    blocksize = 8;
#define max(a, b) (a > b? a : b)
                int data_size = (max(srcWidth, 4) / 4) * (max(srcHeight, 
4) / 4) * blocksize;
                #undef max
//printf(" -> S = %i | CompressedTexImage2D(?, %i, %i, 
%i, %i, 0, %i, ?)\n", destByteSize, glDescription->level, 
glDescription->glFormatInternal, srcWidth, srcHeight, data_size);
GL_EXTCALL(glCompressedTexSubImage2DARB(glDescription->target,
                                                    glDescription->level,
                                                    destLeft,
                                                    destTop,
                                                    srcWidth,
                                                    srcHeight,
glDescription->glFormatInternal,
                                                    data_size,
IWineD3DSurface_GetData(pSourceSurface)));
checkGLcall("glCompressedTexImage2DARB");
            }
            else
            {
                FIXME("TODO: Need to update a DXT compressed texture 
without hardware support\n");
            }
        }
        // Uncompressed Texture
        else
        {
            glTexSubImage2D(
                glDescription->target,
                glDescription->level,
                destLeft,
                destTop,
                srcWidth,
                srcHeight,
                glDescription->glFormat,
                glDescription->glType,
                IWineD3DSurface_GetData(pSourceSurface)
            );
checkGLcall("glTexSubImage2D");
        }
     }
LEAVE_GL();
((IWineD3DSurfaceImpl *)pDestinationSurface)->Flags &= ~SFLAG_INSYSMEM;
    ((IWineD3DSurfaceImpl *)pDestinationSurface)->Flags |= SFLAG_INTEXTURE;
    IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(0));
return WINED3D_OK;
}