static HRESULT WINAPI IWineD3DTextureImpl_UnlockRect(IWineD3DTexture *iface, UINT Level) {
IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
HRESULT hr = WINED3DERR_INVALIDCALL;
if (Level < This->baseTexture.levels) {
hr = IWineD3DSurface_UnlockRect(This->surfaces[Level]);
}
if ( WINED3D_OK == hr) {
TRACE("(%p) Level (%d) success\n", This, Level);
} else {
WARN("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->baseTexture.levels);
}
return hr;
}
static HRESULT WINAPI IWineD3DTextureImpl_UnlockRect(IWineD3DTexture *iface, UINT level)
{
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
IWineD3DSurface *surface;
TRACE("iface %p, level %u.\n", iface, level);
if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, 0, level)))
{
WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL;
}
return IWineD3DSurface_UnlockRect(surface);
}
static HRESULT WINAPI IDirect3DSurface8Impl_UnlockRect(LPDIRECT3DSURFACE8 iface) {
IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
HRESULT hr;
TRACE("iface %p.\n", iface);
wined3d_mutex_lock();
hr = IWineD3DSurface_UnlockRect(This->wineD3DSurface);
wined3d_mutex_unlock();
switch(hr)
{
case WINEDDERR_NOTLOCKED: return D3DERR_INVALIDCALL;
default: return hr;
}
}
/*****************************************************************************
* IDirect3DTexture2::Load
*
* Loads a texture created with the DDSCAPS_ALLOCONLOAD
*
* This function isn't relayed to WineD3D because the whole interface is
* implemented in DDraw only. For speed improvements a implementation which
* takes OpenGL more into account could be placed into WineD3D.
*
* Params:
* D3DTexture2: Address of the texture to load
*
* Returns:
* D3D_OK on success
* D3DERR_TEXTURE_LOAD_FAILED.
*
*****************************************************************************/
static HRESULT WINAPI
IDirect3DTextureImpl_Load(IDirect3DTexture2 *iface,
IDirect3DTexture2 *D3DTexture2)
{
ICOM_THIS_FROM(IDirectDrawSurfaceImpl, IDirect3DTexture2, iface);
IDirectDrawSurfaceImpl *src_ptr = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirect3DTexture2, D3DTexture2);
IWineD3DPalette *wine_pal, *wine_pal_src;
IDirectDrawPalette *pal = NULL, *pal_src = NULL;
IDirectDrawPaletteImpl *pal_impl, *pal_impl_src;
HRESULT ret_value = D3D_OK;
TRACE("(%p)->(%p)\n", This, src_ptr);
if (((src_ptr->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP) != (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)) ||
(src_ptr->surface_desc.u2.dwMipMapCount != This->surface_desc.u2.dwMipMapCount))
{
ERR("Trying to load surfaces with different mip-map counts !\n");
}
while(1)
{
DDSURFACEDESC *src_d, *dst_d;
TRACE(" copying surface %p to surface %p (mipmap level %d)\n", src_ptr, This, src_ptr->mipmap_level);
if ( This->surface_desc.ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD )
/* If the surface is not allocated and its location is not yet specified,
force it to video memory */
if ( !(This->surface_desc.ddsCaps.dwCaps & (DDSCAPS_SYSTEMMEMORY|DDSCAPS_VIDEOMEMORY)) )
This->surface_desc.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
/* Suppress the ALLOCONLOAD flag */
This->surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
/* Get the palettes */
ret_value = IWineD3DSurface_GetPalette(This->WineD3DSurface, &wine_pal);
if( ret_value != D3D_OK)
{
ERR("IWineD3DSurface::GetPalette failed! This is unexpected\n");
return D3DERR_TEXTURE_LOAD_FAILED;
}
if(wine_pal)
{
ret_value = IWineD3DPalette_GetParent(wine_pal, (IUnknown **) &pal);
if(ret_value != D3D_OK)
{
ERR("IWineD3DPalette::GetParent failed! This is unexpected\n");
return D3DERR_TEXTURE_LOAD_FAILED;
}
pal_impl = ICOM_OBJECT(IDirectDrawPaletteImpl, IDirectDrawPalette, pal);
}
else
{
pal_impl = NULL;
}
ret_value = IWineD3DSurface_GetPalette(src_ptr->WineD3DSurface, &wine_pal_src);
if( ret_value != D3D_OK)
{
ERR("IWineD3DSurface::GetPalette failed! This is unexpected\n");
return D3DERR_TEXTURE_LOAD_FAILED;
}
if(wine_pal_src)
{
ret_value = IWineD3DPalette_GetParent(wine_pal_src, (IUnknown **) &pal_src);
if(ret_value != D3D_OK)
{
ERR("IWineD3DPalette::GetParent failed! This is unexpected\n");
return D3DERR_TEXTURE_LOAD_FAILED;
}
pal_impl_src = ICOM_OBJECT(IDirectDrawPaletteImpl, IDirectDrawPalette, pal_src);
}
else
{
pal_impl_src = NULL;
}
/* After seeing some logs, not sure at all about this... */
if (pal_impl == NULL)
{
IWineD3DSurface_SetPalette(This->WineD3DSurface, wine_pal);
if (pal_impl_src != NULL) IDirectDrawPalette_AddRef(ICOM_INTERFACE(pal_impl_src, IDirectDrawPalette));
}
else
{
if (pal_impl_src != NULL)
{
PALETTEENTRY palent[256];
IDirectDrawPalette_GetEntries(ICOM_INTERFACE(pal_impl_src, IDirectDrawPalette),
0, 0, 256, palent);
IDirectDrawPalette_SetEntries(ICOM_INTERFACE(pal_impl, IDirectDrawPalette),
0, 0, 256, palent);
}
}
/* Copy one surface on the other */
dst_d = (DDSURFACEDESC *)&(This->surface_desc);
src_d = (DDSURFACEDESC *)&(src_ptr->surface_desc);
if ((src_d->dwWidth != dst_d->dwWidth) || (src_d->dwHeight != dst_d->dwHeight))
{
/* Should also check for same pixel format, u1.lPitch, ... */
ERR("Error in surface sizes\n");
return D3DERR_TEXTURE_LOAD_FAILED;
}
else
{
WINED3DLOCKED_RECT pSrcRect, pDstRect;
/* LPDIRECT3DDEVICE2 d3dd = (LPDIRECT3DDEVICE2) This->D3Ddevice; */
/* I should put a macro for the calculus of bpp */
/* Copy also the ColorKeying stuff */
if (src_d->dwFlags & DDSD_CKSRCBLT)
{
dst_d->dwFlags |= DDSD_CKSRCBLT;
dst_d->ddckCKSrcBlt.dwColorSpaceLowValue = src_d->ddckCKSrcBlt.dwColorSpaceLowValue;
dst_d->ddckCKSrcBlt.dwColorSpaceHighValue = src_d->ddckCKSrcBlt.dwColorSpaceHighValue;
}
/* Copy the main memory texture into the surface that corresponds to the OpenGL
texture object. */
ret_value = IWineD3DSurface_LockRect(src_ptr->WineD3DSurface, &pSrcRect, NULL, 0);
if(ret_value != D3D_OK)
{
ERR(" (%p) Locking the source surface failed\n", This);
return D3DERR_TEXTURE_LOAD_FAILED;
}
ret_value = IWineD3DSurface_LockRect(This->WineD3DSurface, &pDstRect, NULL, 0);
if(ret_value != D3D_OK)
{
ERR(" (%p) Locking the destination surface failed\n", This);
IWineD3DSurface_UnlockRect(src_ptr->WineD3DSurface);
return D3DERR_TEXTURE_LOAD_FAILED;
}
if (This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
memcpy(pDstRect.pBits, pSrcRect.pBits, src_ptr->surface_desc.u1.dwLinearSize);
else
memcpy(pDstRect.pBits, pSrcRect.pBits, pSrcRect.Pitch * src_d->dwHeight);
IWineD3DSurface_UnlockRect(src_ptr->WineD3DSurface);
IWineD3DSurface_UnlockRect(This->WineD3DSurface);
}
if (src_ptr->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
{
src_ptr = get_sub_mimaplevel(src_ptr);
}
else
{
src_ptr = NULL;
}
if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
{
This = get_sub_mimaplevel(This);
}
else
{
This = NULL;
}
if ((src_ptr == NULL) || (This == NULL))
{
if (src_ptr != This)
{
ERR(" Loading surface with different mipmap structure !!!\n");
}
break;
}
}
return ret_value;
}
/* Routine common to the draw primitive and draw indexed primitive routines */
void drawPrimitive(IWineD3DDevice *iface, UINT index_count, UINT StartIdx, UINT idxSize, const void *idxData)
{
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
IWineD3DSurfaceImpl *target;
struct wined3d_context *context;
unsigned int i;
if (!index_count) return;
if (This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE])
{
/* Invalidate the back buffer memory so LockRect will read it the next time */
for (i = 0; i < This->adapter->gl_info.limits.buffers; ++i)
{
target = (IWineD3DSurfaceImpl *)This->render_targets[i];
if (target)
{
IWineD3DSurface_LoadLocation((IWineD3DSurface *)target, SFLAG_INDRAWABLE, NULL);
IWineD3DSurface_ModifyLocation((IWineD3DSurface *)target, SFLAG_INDRAWABLE, TRUE);
}
}
}
/* Signals other modules that a drawing is in progress and the stateblock finalized */
This->isInDraw = TRUE;
context = context_acquire(This, This->render_targets[0], CTXUSAGE_DRAWPRIM);
if (!context->valid)
{
context_release(context);
WARN("Invalid context, skipping draw.\n");
return;
}
#if defined(VBOX_WITH_WDDM)
DBGL_CHECK_DRAWPRIM(context->gl_info, This);
#endif
if (This->stencilBufferTarget) {
/* Note that this depends on the context_acquire() call above to set
* This->render_offscreen properly. We don't currently take the
* Z-compare function into account, but we could skip loading the
* depthstencil for D3DCMP_NEVER and D3DCMP_ALWAYS as well. Also note
* that we never copy the stencil data.*/
DWORD location = context->render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
if (This->stateBlock->renderState[WINED3DRS_ZWRITEENABLE]
|| This->stateBlock->renderState[WINED3DRS_ZENABLE])
surface_load_ds_location(This->stencilBufferTarget, context, location);
if (This->stateBlock->renderState[WINED3DRS_ZWRITEENABLE])
surface_modify_ds_location(This->stencilBufferTarget, location);
}
/* Ok, we will be updating the screen from here onwards so grab the lock */
ENTER_GL();
{
GLenum glPrimType = This->stateBlock->gl_primitive_type;
BOOL emulation = FALSE;
const struct wined3d_stream_info *stream_info = &This->strided_streams;
struct wined3d_stream_info stridedlcl;
if (!use_vs(This->stateBlock))
{
if (!This->strided_streams.position_transformed && context->num_untracked_materials
&& This->stateBlock->renderState[WINED3DRS_LIGHTING])
{
static BOOL warned;
if (!warned) {
FIXME("Using software emulation because not all material properties could be tracked\n");
warned = TRUE;
} else {
TRACE("Using software emulation because not all material properties could be tracked\n");
}
emulation = TRUE;
}
else if (context->fog_coord && This->stateBlock->renderState[WINED3DRS_FOGENABLE])
{
/* Either write a pipeline replacement shader or convert the specular alpha from unsigned byte
* to a float in the vertex buffer
*/
static BOOL warned;
if (!warned) {
FIXME("Using software emulation because manual fog coordinates are provided\n");
warned = TRUE;
} else {
TRACE("Using software emulation because manual fog coordinates are provided\n");
}
emulation = TRUE;
}
if(emulation) {
stream_info = &stridedlcl;
memcpy(&stridedlcl, &This->strided_streams, sizeof(stridedlcl));
remove_vbos(This, &stridedlcl);
}
}
if (This->useDrawStridedSlow || emulation) {
/* Immediate mode drawing */
if (use_vs(This->stateBlock))
{
static BOOL warned;
if (!warned) {
FIXME("Using immediate mode with vertex shaders for half float emulation\n");
warned = TRUE;
} else {
TRACE("Using immediate mode with vertex shaders for half float emulation\n");
}
drawStridedSlowVs(iface, stream_info, index_count, glPrimType, idxData, idxSize, StartIdx);
} else {
drawStridedSlow(iface, context, stream_info, index_count,
glPrimType, idxData, idxSize, StartIdx);
}
} else if(This->instancedDraw) {
/* Instancing emulation with mixing immediate mode and arrays */
drawStridedInstanced(iface, &This->strided_streams, index_count,
glPrimType, idxData, idxSize, StartIdx);
} else {
drawStridedFast(iface, glPrimType, index_count, idxSize, idxData, StartIdx);
}
}
/* Finished updating the screen, restore lock */
LEAVE_GL();
for(i = 0; i < This->num_buffer_queries; i++)
{
wined3d_event_query_issue(This->buffer_queries[i], This);
}
if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
context_release(context);
TRACE("Done all gl drawing\n");
/* Diagnostics */
#ifdef SHOW_FRAME_MAKEUP
{
static long int primCounter = 0;
/* NOTE: set primCounter to the value reported by drawprim
before you want to to write frame makeup to /tmp */
if (primCounter >= 0) {
WINED3DLOCKED_RECT r;
char buffer[80];
IWineD3DSurface_LockRect(This->render_targets[0], &r, NULL, WINED3DLOCK_READONLY);
sprintf(buffer, "/tmp/backbuffer_%ld.tga", primCounter);
TRACE("Saving screenshot %s\n", buffer);
IWineD3DSurface_SaveSnapshot(This->render_targets[0], buffer);
IWineD3DSurface_UnlockRect(This->render_targets[0]);
#ifdef SHOW_TEXTURE_MAKEUP
{
IWineD3DSurface *pSur;
int textureNo;
for (textureNo = 0; textureNo < MAX_COMBINED_SAMPLERS; ++textureNo) {
if (This->stateBlock->textures[textureNo] != NULL) {
sprintf(buffer, "/tmp/texture_%p_%ld_%d.tga", This->stateBlock->textures[textureNo], primCounter, textureNo);
TRACE("Saving texture %s\n", buffer);
if (IWineD3DBaseTexture_GetType(This->stateBlock->textures[textureNo]) == WINED3DRTYPE_TEXTURE) {
IWineD3DTexture_GetSurfaceLevel(This->stateBlock->textures[textureNo], 0, &pSur);
IWineD3DSurface_SaveSnapshot(pSur, buffer);
IWineD3DSurface_Release(pSur);
} else {
FIXME("base Texture isn't of type texture %d\n", IWineD3DBaseTexture_GetType(This->stateBlock->textures[textureNo]));
}
}
}
}
#endif
}
TRACE("drawprim #%ld\n", primCounter);
++primCounter;
}
#endif
/* Control goes back to the device, stateblock values may change again */
This->isInDraw = FALSE;
}