From 3dfdfbfa6fabd5b526d5f63c25bb5bcfc18471a4 Mon Sep 17 00:00:00 2001 From: Lionel Ulmer Date: Mon, 23 Jun 2003 03:34:34 +0000 Subject: [PATCH] - some TRACEing fixes - faster Blt to the framebuffer using texture engine --- dlls/ddraw/d3ddevice/mesa.c | 271 ++++++++++++++++++++++++++++++++++++++++---- dlls/ddraw/dsurface/dib.c | 8 +- dlls/ddraw/mesa.c | 43 +++++-- 3 files changed, 289 insertions(+), 33 deletions(-) diff --git a/dlls/ddraw/d3ddevice/mesa.c b/dlls/ddraw/d3ddevice/mesa.c index 42e887170c2..72781dcb16d 100644 --- a/dlls/ddraw/d3ddevice/mesa.c +++ b/dlls/ddraw/d3ddevice/mesa.c @@ -153,7 +153,6 @@ static DWORD d3ddevice_set_state_for_flush(IDirect3DDeviceImpl *d3d_dev, LPCRECT if (gl_d3d_dev->fogging != FALSE) glDisable(GL_FOG); if (gl_d3d_dev->current_tex_env != GL_REPLACE) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); - glColor3ub(0xFF, 0xFF, 0xFF); return opt_bitmap; } @@ -2686,14 +2685,12 @@ static HRESULT d3ddevice_clear_back(IDirect3DDeviceImpl *This, return d3ddevice_clear(This, WINE_GL_BUFFER_BACK, dwCount, lpRects, dwFlags, dwColor, dvZ, dwStencil); } -HRESULT -d3ddevice_blt(IDirectDrawSurfaceImpl *This, LPRECT rdst, - LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, - DWORD dwFlags, LPDDBLTFX lpbltfx) +static HRESULT +setup_rect_and_surface_for_blt(IDirectDrawSurfaceImpl *This, + WINE_GL_BUFFER_TYPE *buffer_type_p, D3DRECT *rect) { IDirect3DDeviceGLImpl *gl_d3d_dev = (IDirect3DDeviceGLImpl *) This->d3ddevice; WINE_GL_BUFFER_TYPE buffer_type; - D3DRECT rect; /* First check if we BLT to the backbuffer... */ if ((This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER)) != 0) { @@ -2704,7 +2701,30 @@ d3ddevice_blt(IDirectDrawSurfaceImpl *This, LPRECT rdst, ERR("Only BLT override to front or back-buffer is supported for now !\n"); return DDERR_INVALIDPARAMS; } + + if ((gl_d3d_dev->state[buffer_type] == SURFACE_MEMORY_DIRTY) && + (rect->u1.x1 >= gl_d3d_dev->lock_rect[buffer_type].left) && + (rect->u2.y1 >= gl_d3d_dev->lock_rect[buffer_type].top) && + (rect->u3.x2 <= gl_d3d_dev->lock_rect[buffer_type].right) && + (rect->u4.y2 <= gl_d3d_dev->lock_rect[buffer_type].bottom)) { + /* If the memory zone is already dirty, use the standard 'in memory' blit operations and not + * GL to do it. + */ + return DDERR_INVALIDPARAMS; + } + *buffer_type_p = buffer_type; + return DD_OK; +} + +HRESULT +d3ddevice_blt(IDirectDrawSurfaceImpl *This, LPRECT rdst, + LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, + DWORD dwFlags, LPDDBLTFX lpbltfx) +{ + WINE_GL_BUFFER_TYPE buffer_type; + D3DRECT rect; + if (rdst) { rect.u1.x1 = rdst->left; rect.u2.y1 = rdst->top; @@ -2716,17 +2736,8 @@ d3ddevice_blt(IDirectDrawSurfaceImpl *This, LPRECT rdst, rect.u3.x2 = This->surface_desc.dwWidth; rect.u4.y2 = This->surface_desc.dwHeight; } - - if ((gl_d3d_dev->state[buffer_type] == SURFACE_MEMORY_DIRTY) && - (rect.u1.x1 >= gl_d3d_dev->lock_rect[buffer_type].left) && - (rect.u2.y1 >= gl_d3d_dev->lock_rect[buffer_type].top) && - (rect.u3.x2 <= gl_d3d_dev->lock_rect[buffer_type].right) && - (rect.u4.y2 <= gl_d3d_dev->lock_rect[buffer_type].bottom)) { - /* If the memory zone is already dirty, use the standard 'in memory' blit operations and not - * GL to do it. - */ - return DDERR_INVALIDPARAMS; - } + + if (setup_rect_and_surface_for_blt(This, &buffer_type, &rect) != DD_OK) return DDERR_INVALIDPARAMS; if (dwFlags & DDBLT_COLORFILL) { /* This is easy to handle for the D3D Device... */ @@ -2794,14 +2805,16 @@ d3ddevice_blt(IDirectDrawSurfaceImpl *This, LPRECT rdst, LEAVE_GL(); return DD_OK; - } else if ((dwFlags & (~(DDBLT_WAIT|DDBLT_ASYNC))) == 0) { + } else if ((dwFlags & (~(DDBLT_KEYSRC|DDBLT_WAIT|DDBLT_ASYNC))) == 0) { /* Normal blit without any special case... */ if (src != NULL) { /* And which has a SRC surface */ IDirectDrawSurfaceImpl *src_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, src); + if ((src_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE) && - (src_impl->d3ddevice == This->d3ddevice)) { - /* Both are 3D devices and using the same GL device */ + (src_impl->d3ddevice == This->d3ddevice) && + ((dwFlags & DDBLT_KEYSRC) == 0)) { + /* Both are 3D devices and using the same GL device and the Blt is without color-keying */ D3DRECT src_rect; int width, height; GLenum prev_draw; @@ -2920,6 +2933,110 @@ d3ddevice_blt(IDirectDrawSurfaceImpl *This, LPRECT rdst, LEAVE_GL(); return DD_OK; + } else { + /* This is the normal 'with source' Blit. Use the texture engine to do the Blt for us + (this prevents calling glReadPixels) */ + D3DRECT src_rect; + int width, height; + GLenum prev_draw; + IDirect3DDeviceGLImpl *gl_d3d_dev = (IDirect3DDeviceGLImpl *) This->d3ddevice; + BOOLEAN initial = FALSE; + DWORD opt_bitmap; + int x, y; + double x_stretch, y_stretch; + + if (dwFlags & DDBLT_KEYSRC) { + /* As I have no game using this, did not bother to do it yet as I cannot test it anyway */ + FIXME(" Blt overide with color-keying not supported yet.\n"); + return DDERR_INVALIDPARAMS; + } + + if (rsrc) { + src_rect.u1.x1 = rsrc->left; + src_rect.u2.y1 = rsrc->top; + src_rect.u3.x2 = rsrc->right; + src_rect.u4.y2 = rsrc->bottom; + } else { + src_rect.u1.x1 = 0; + src_rect.u2.y1 = 0; + src_rect.u3.x2 = src_impl->surface_desc.dwWidth; + src_rect.u4.y2 = src_impl->surface_desc.dwHeight; + } + + width = src_rect.u3.x2 - src_rect.u1.x1; + height = src_rect.u4.y2 - src_rect.u2.y1; + + x_stretch = (double) (rect.u3.x2 - rect.u1.x1) / (double) width; + y_stretch = (double) (rect.u4.y2 - rect.u2.y1) / (double) height; + + TRACE(" using memory to buffer Blt overide.\n"); + + ENTER_GL(); + + opt_bitmap = d3ddevice_set_state_for_flush(This->d3ddevice, (LPCRECT) &rect, FALSE, &initial); + + if (upload_surface_to_tex_memory_init(src_impl, 0, &gl_d3d_dev->current_internal_format, + initial, FALSE, UNLOCK_TEX_SIZE, UNLOCK_TEX_SIZE) != DD_OK) { + ERR(" unsupported pixel format at memory to buffer Blt overide.\n"); + LEAVE_GL(); + return DDERR_INVALIDPARAMS; + } + + glGetIntegerv(GL_DRAW_BUFFER, &prev_draw); + if (buffer_type == WINE_GL_BUFFER_FRONT) + glDrawBuffer(GL_FRONT); + else + glDrawBuffer(GL_BACK); + + /* Now the serious stuff happens. This is basically the same code that for the memory + flush to frame buffer ... with stretching and different rectangles added :-) */ + for (y = 0; y < height; y += UNLOCK_TEX_SIZE) { + RECT flush_rect; + + flush_rect.top = src_rect.u2.y1 + y; + flush_rect.bottom = ((src_rect.u2.y1 + y + UNLOCK_TEX_SIZE > src_rect.u4.y2) ? + src_rect.u4.y2 : + (src_rect.u2.y1 + y + UNLOCK_TEX_SIZE)); + + for (x = 0; x < width; x += UNLOCK_TEX_SIZE) { + flush_rect.left = src_rect.u1.x1 + x; + flush_rect.right = ((src_rect.u1.x1 + x + UNLOCK_TEX_SIZE > src_rect.u3.x2) ? + src_rect.u3.x2 : + (src_rect.u1.x1 + x + UNLOCK_TEX_SIZE)); + + upload_surface_to_tex_memory(&flush_rect, 0, 0, &(gl_d3d_dev->surface_ptr)); + + glBegin(GL_QUADS); + glTexCoord2f(0.0, 0.0); + glVertex3d(rect.u1.x1 + (x * x_stretch), + rect.u2.y1 + (y * y_stretch), + 0.5); + glTexCoord2f(1.0, 0.0); + glVertex3d(rect.u1.x1 + ((x + UNLOCK_TEX_SIZE) * x_stretch), + rect.u2.y1 + (y * y_stretch), + 0.5); + glTexCoord2f(1.0, 1.0); + glVertex3d(rect.u1.x1 + ((x + UNLOCK_TEX_SIZE) * x_stretch), + rect.u2.y1 + ((y + UNLOCK_TEX_SIZE) * y_stretch), + 0.5); + glTexCoord2f(0.0, 1.0); + glVertex3d(rect.u1.x1 + (x * x_stretch), + rect.u2.y1 + ((y + UNLOCK_TEX_SIZE) * y_stretch), + 0.5); + glEnd(); + } + } + + upload_surface_to_tex_memory_release(); + d3ddevice_restore_state_after_flush(This->d3ddevice, opt_bitmap, FALSE); + + if (((buffer_type == WINE_GL_BUFFER_FRONT) && (prev_draw == GL_BACK)) || + ((buffer_type == WINE_GL_BUFFER_BACK) && (prev_draw == GL_FRONT))) + glDrawBuffer(prev_draw); + + LEAVE_GL(); + + return DD_OK; } } } @@ -2931,7 +3048,117 @@ d3ddevice_bltfast(IDirectDrawSurfaceImpl *This, DWORD dstx, DWORD dsty, LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, DWORD trans) { - return DDERR_INVALIDPARAMS; + RECT rsrc2; + RECT rdst; + IDirectDrawSurfaceImpl *src_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, src); + IDirect3DDeviceGLImpl *gl_d3d_dev = (IDirect3DDeviceGLImpl *) This->d3ddevice; + WINE_GL_BUFFER_TYPE buffer_type; + GLenum prev_draw; + DWORD opt_bitmap; + BOOLEAN initial; + int width, height, x, y; + + /* Cannot support DSTCOLORKEY blitting... */ + if ((trans & DDBLTFAST_DESTCOLORKEY) != 0) return DDERR_INVALIDPARAMS; + + if (rsrc == NULL) { + WARN("rsrc is NULL - getting the whole surface !!\n"); + rsrc = &rsrc2; + rsrc->left = rsrc->top = 0; + rsrc->right = src_impl->surface_desc.dwWidth; + rsrc->bottom = src_impl->surface_desc.dwHeight; + } else { + rsrc2 = *rsrc; + rsrc = &rsrc2; + } + + rdst.left = dstx; + rdst.top = dsty; + rdst.right = dstx + (rsrc->right - rsrc->left); + if (rdst.right > This->surface_desc.dwWidth) { + rsrc->right -= (This->surface_desc.dwWidth - rdst.right); + rdst.right = This->surface_desc.dwWidth; + } + rdst.bottom = dsty + (rsrc->bottom - rsrc->top); + if (rdst.bottom > This->surface_desc.dwHeight) { + rsrc->bottom -= (This->surface_desc.dwHeight - rdst.bottom); + rdst.bottom = This->surface_desc.dwHeight; + } + + width = rsrc->right - rsrc->left; + height = rsrc->bottom - rsrc->top; + + if (setup_rect_and_surface_for_blt(This, &buffer_type, (D3DRECT *) &rdst) != DD_OK) return DDERR_INVALIDPARAMS; + + TRACE(" using BltFast memory to frame buffer overide.\n"); + + ENTER_GL(); + + opt_bitmap = d3ddevice_set_state_for_flush(This->d3ddevice, &rdst, (trans & DDBLTFAST_SRCCOLORKEY) != 0, &initial); + + if (upload_surface_to_tex_memory_init(src_impl, 0, &gl_d3d_dev->current_internal_format, + initial, (trans & DDBLTFAST_SRCCOLORKEY) != 0, + UNLOCK_TEX_SIZE, UNLOCK_TEX_SIZE) != DD_OK) { + ERR(" unsupported pixel format at memory to buffer Blt overide.\n"); + LEAVE_GL(); + return DDERR_INVALIDPARAMS; + } + + glGetIntegerv(GL_DRAW_BUFFER, &prev_draw); + if (buffer_type == WINE_GL_BUFFER_FRONT) + glDrawBuffer(GL_FRONT); + else + glDrawBuffer(GL_BACK); + + /* Now the serious stuff happens. This is basically the same code that for the memory + flush to frame buffer but with different rectangles for source and destination :-) */ + for (y = 0; y < height; y += UNLOCK_TEX_SIZE) { + RECT flush_rect; + + flush_rect.top = rsrc->top + y; + flush_rect.bottom = ((rsrc->top + y + UNLOCK_TEX_SIZE > rsrc->bottom) ? + rsrc->bottom : + (rsrc->top + y + UNLOCK_TEX_SIZE)); + + for (x = 0; x < width; x += UNLOCK_TEX_SIZE) { + flush_rect.left = rsrc->left + x; + flush_rect.right = ((rsrc->left + x + UNLOCK_TEX_SIZE > rsrc->right) ? + rsrc->right : + (rsrc->left + x + UNLOCK_TEX_SIZE)); + + upload_surface_to_tex_memory(&flush_rect, 0, 0, &(gl_d3d_dev->surface_ptr)); + + glBegin(GL_QUADS); + glTexCoord2f(0.0, 0.0); + glVertex3d(rdst.left + x, + rdst.top + y, + 0.5); + glTexCoord2f(1.0, 0.0); + glVertex3d(rdst.left + (x + UNLOCK_TEX_SIZE), + rdst.top + y, + 0.5); + glTexCoord2f(1.0, 1.0); + glVertex3d(rdst.left + (x + UNLOCK_TEX_SIZE), + rdst.top + (y + UNLOCK_TEX_SIZE), + 0.5); + glTexCoord2f(0.0, 1.0); + glVertex3d(rdst.left + x, + rdst.top + (y + UNLOCK_TEX_SIZE), + 0.5); + glEnd(); + } + } + + upload_surface_to_tex_memory_release(); + d3ddevice_restore_state_after_flush(This->d3ddevice, opt_bitmap, (trans & DDBLTFAST_SRCCOLORKEY) != 0); + + if (((buffer_type == WINE_GL_BUFFER_FRONT) && (prev_draw == GL_BACK)) || + ((buffer_type == WINE_GL_BUFFER_BACK) && (prev_draw == GL_FRONT))) + glDrawBuffer(prev_draw); + + LEAVE_GL(); + + return DD_OK; } void @@ -3325,7 +3552,7 @@ static void d3ddevice_flush_to_frame_buffer(IDirect3DDeviceImpl *d3d_dev, LPCREC for (x = pRect->left; x < pRect->right; x += UNLOCK_TEX_SIZE) { /* First, upload the texture... */ flush_rect.left = x; - flush_rect.right = (x + UNLOCK_TEX_SIZE > pRect->right) ? pRect->right : (x + UNLOCK_TEX_SIZE); + flush_rect.right = (x + UNLOCK_TEX_SIZE > pRect->right) ? pRect->right : (x + UNLOCK_TEX_SIZE); upload_surface_to_tex_memory(&flush_rect, 0, 0, &(gl_d3d_dev->surface_ptr)); diff --git a/dlls/ddraw/dsurface/dib.c b/dlls/ddraw/dsurface/dib.c index ab2301030a7..5bd3358ea91 100644 --- a/dlls/ddraw/dsurface/dib.c +++ b/dlls/ddraw/dsurface/dib.c @@ -819,16 +819,16 @@ DIB_DirectDrawSurface_BltFast(LPDIRECTDRAWSURFACE7 iface, DWORD dstx, if (TRACE_ON(ddraw)) { - FIXME("(%p)->(%ld,%ld,%p,%p,%08lx)\n", + TRACE("(%p)->(%ld,%ld,%p,%p,%08lx)\n", This,dstx,dsty,src,rsrc,trans ); - FIXME("\ttrans:"); + TRACE("\ttrans:"); if (FIXME_ON(ddraw)) DDRAW_dump_DDBLTFAST(trans); if (rsrc) - FIXME("\tsrcrect: %ldx%ld-%ldx%ld\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom); + TRACE("\tsrcrect: %ldx%ld-%ldx%ld\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom); else - FIXME(" srcrect: NULL\n"); + TRACE(" srcrect: NULL\n"); } /* First, check if the possible override function handles this case */ diff --git a/dlls/ddraw/mesa.c b/dlls/ddraw/mesa.c index daf90953349..07b6334b1c3 100644 --- a/dlls/ddraw/mesa.c +++ b/dlls/ddraw/mesa.c @@ -617,6 +617,8 @@ static IDirectDrawSurfaceImpl *current_surface; static GLuint current_level; static DWORD current_tex_width; static DWORD current_tex_height; +static BOOLEAN need_alignement_restore; +static int current_storage_width; HRESULT upload_surface_to_tex_memory_init(IDirectDrawSurfaceImpl *surf_ptr, GLuint level, GLenum *current_internal_format, BOOLEAN need_to_alloc, BOOLEAN need_alpha_ck, DWORD tex_width, DWORD tex_height) @@ -627,6 +629,8 @@ HRESULT upload_surface_to_tex_memory_init(IDirectDrawSurfaceImpl *surf_ptr, GLui GLenum internal_format = GL_LUMINANCE; /* A bogus value to be sure to have a nice Mesa warning :-) */ BYTE bpp = GET_BPP(surf_ptr->surface_desc); BOOL sub_texture = TRUE; + + need_alignement_restore = FALSE; current_surface = surf_ptr; current_level = level; @@ -868,16 +872,16 @@ HRESULT upload_surface_to_tex_memory_init(IDirectDrawSurfaceImpl *surf_ptr, GLui } if ((sub_texture == TRUE) && (convert_type == NO_CONVERSION)) { - glPixelStorei(GL_UNPACK_ROW_LENGTH, surf_ptr->surface_desc.u1.lPitch / bpp); + current_storage_width = surf_ptr->surface_desc.u1.lPitch / bpp; } else { if (surf_ptr->surface_desc.u1.lPitch == (surf_ptr->surface_desc.dwWidth * bpp)) { - glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + current_storage_width = 0; } else { - glPixelStorei(GL_UNPACK_ROW_LENGTH, surf_ptr->surface_desc.u1.lPitch / bpp); - } - + current_storage_width = surf_ptr->surface_desc.u1.lPitch / bpp; + } } - + glPixelStorei(GL_UNPACK_ROW_LENGTH, current_storage_width); + return DD_OK; } @@ -1217,10 +1221,31 @@ HRESULT upload_surface_to_tex_memory(RECT *rect, DWORD xoffset, DWORD yoffset, v } if (convert_type != NO_CONVERSION) { + int storage_width; + surf_buffer = *temp_buffer; if (width != current_tex_width) { /* Overide the default PixelStore parameter if only using part of the actual texture */ - glPixelStorei(GL_UNPACK_ROW_LENGTH, width); + storage_width = width; + /* This is needed when locking with a rectangle with 'odd' width */ + if (need_alignement_restore == FALSE) { + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + need_alignement_restore = TRUE; + } + } else { + if (current_surface->surface_desc.u1.lPitch == (current_surface->surface_desc.dwWidth * bpp)) { + storage_width = 0; + } else { + storage_width = current_surface->surface_desc.u1.lPitch / bpp; + } + if (need_alignement_restore == TRUE) { + glPixelStorei(GL_UNPACK_ALIGNMENT, 0); + need_alignement_restore = FALSE; + } + } + if (storage_width != current_storage_width) { + glPixelStorei(GL_UNPACK_ROW_LENGTH, storage_width); + current_storage_width = storage_width; } } @@ -1239,5 +1264,9 @@ HRESULT upload_surface_to_tex_memory_release(void) { current_surface = NULL; + if (need_alignement_restore == TRUE) { + glPixelStorei(GL_UNPACK_ALIGNMENT, 4); + } + return DD_OK; } -- 2.11.4.GIT