* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
+#include "config.h"
+#include "wine/port.h"
+
#include "ddraw_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
+
static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface2(IDirectDrawSurface2 *iface);
static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface3(IDirectDrawSurface3 *iface);
* to support windowless rendering first. */
HRESULT ddraw_surface_update_frontbuffer(struct ddraw_surface *surface, const RECT *rect, BOOL read)
{
+ struct ddraw *ddraw = surface->ddraw;
HDC surface_dc, screen_dc;
int x, y, w, h;
HRESULT hr;
if (w <= 0 || h <= 0)
return DD_OK;
- if (surface->ddraw->swapchain_window)
+ if (ddraw->swapchain_window && !(ddraw->flags & DDRAW_GDI_FLIP))
{
/* Nothing to do, we control the frontbuffer, or at least the parts we
* care about. */
if (read)
return DD_OK;
- return wined3d_texture_blt(surface->ddraw->wined3d_frontbuffer, 0, rect,
+ return wined3d_texture_blt(ddraw->wined3d_frontbuffer, 0, rect,
surface->wined3d_texture, surface->sub_resource_idx, rect, 0, NULL, WINED3D_TEXF_POINT);
}
{
HRESULT hr;
- if (FAILED(hr = d3d_device_create(This->ddraw, This, (IUnknown *)&This->IDirectDrawSurface_iface,
+ if (FAILED(hr = d3d_device_create(This->ddraw, riid, This, (IUnknown *)&This->IDirectDrawSurface_iface,
1, &This->device1, (IUnknown *)&This->IDirectDrawSurface_iface)))
{
This->device1 = NULL;
hr = ddraw_surface_update_frontbuffer(surface, rect, TRUE);
if (SUCCEEDED(hr))
hr = wined3d_resource_map(wined3d_texture_get_resource(surface->wined3d_texture),
- surface->sub_resource_idx, &map_desc, rect ? &box : NULL, flags);
+ surface->sub_resource_idx, &map_desc, rect ? &box : NULL,
+ wined3dmapflags_from_ddrawmapflags(flags));
if (FAILED(hr))
{
wined3d_mutex_unlock();
return hr;
}
- if (!(clip_list = HeapAlloc(GetProcessHeap(), 0, clip_list_size)))
+ if (!(clip_list = heap_alloc(clip_list_size)))
{
WARN("Failed to allocate clip list.\n");
return E_OUTOFMEMORY;
&dst_rect, clip_list, &clip_list_size)))
{
WARN("Failed to get clip list, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, clip_list);
+ heap_free(clip_list);
return hr;
}
}
}
- HeapFree(GetProcessHeap(), 0, clip_list);
+ heap_free(clip_list);
return hr;
}
* particular, modify the QueryInterface() pointer in the surface vtbl
* but don't cleanup properly after the relevant dll is unloaded. */
if (attachment->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER
- && wined3d_device_get_depth_stencil_view(surface->ddraw->wined3d_device) == surface->wined3d_rtv)
+ && wined3d_device_get_depth_stencil_view(surface->ddraw->wined3d_device) == attachment->wined3d_rtv)
wined3d_device_set_depth_stencil_view(surface->ddraw->wined3d_device, NULL);
wined3d_mutex_unlock();
return impl_from_IDirectDrawSurface7(next_level);
}
+static BOOL compare_format(DDPIXELFORMAT *format1, DDPIXELFORMAT *format2)
+{
+ if ((format1->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_FOURCC)) !=
+ (format2->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_FOURCC)))
+ return FALSE;
+
+ if (format1->dwFlags & (DDPF_RGB|DDPF_YUV))
+ {
+ if (!(format1->dwFlags & DDPF_ALPHA))
+ {
+ /* The RGB and YUV bits are stored in the same fields */
+ if (format1->u1.dwRGBBitCount != format2->u1.dwRGBBitCount)
+ return FALSE;
+
+ if (format1->u2.dwRBitMask != format2->u2.dwRBitMask)
+ return FALSE;
+
+ if (format1->u3.dwGBitMask != format2->u3.dwGBitMask)
+ return FALSE;
+
+ if (format1->u4.dwBBitMask != format2->u4.dwBBitMask)
+ return FALSE;
+ }
+
+ if (format1->dwFlags & (DDPF_ALPHAPIXELS | DDPF_ALPHA))
+ {
+ if (format1->u5.dwRGBAlphaBitMask != format2->u5.dwRGBAlphaBitMask)
+ return FALSE;
+ }
+ }
+
+ if (format1->dwFlags & DDPF_FOURCC)
+ {
+ if (format1->dwFourCC != format2->dwFourCC)
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
/*****************************************************************************
* IDirect3DTexture2::Load
*
{
struct ddraw_surface *dst_surface = impl_from_IDirect3DTexture2(iface);
struct ddraw_surface *src_surface = unsafe_impl_from_IDirect3DTexture2(src_texture);
- struct wined3d_resource *dst_resource, *src_resource;
+ RECT src_rect, dst_rect;
HRESULT hr;
TRACE("iface %p, src_texture %p.\n", iface, src_texture);
wined3d_mutex_lock();
- dst_resource = wined3d_texture_get_resource(dst_surface->wined3d_texture);
- src_resource = wined3d_texture_get_resource(src_surface->wined3d_texture);
-
- if (((src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
- != (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP))
- || (src_surface->surface_desc.u2.dwMipMapCount != dst_surface->surface_desc.u2.dwMipMapCount))
- {
- ERR("Trying to load surfaces with different mip-map counts.\n");
- }
-
for (;;)
{
- struct ddraw_palette *dst_pal, *src_pal;
- DDSURFACEDESC *src_desc, *dst_desc;
+ DDSURFACEDESC *src_desc = (DDSURFACEDESC *)&src_surface->surface_desc;
TRACE("Copying surface %p to surface %p.\n", src_surface, dst_surface);
- /* Suppress the ALLOCONLOAD flag */
- dst_surface->surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
-
- /* Get the palettes */
- dst_pal = dst_surface->palette;
- src_pal = src_surface->palette;
-
- if (src_pal)
+ if (compare_format(&src_surface->surface_desc.u4.ddpfPixelFormat,
+ &dst_surface->surface_desc.u4.ddpfPixelFormat))
{
- PALETTEENTRY palent[256];
+ struct ddraw_palette *dst_pal, *src_pal;
- if (!dst_pal)
- {
- wined3d_mutex_unlock();
- return DDERR_NOPALETTEATTACHED;
- }
- IDirectDrawPalette_GetEntries(&src_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
- IDirectDrawPalette_SetEntries(&dst_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
- }
+ /* Get the palettes */
+ dst_pal = dst_surface->palette;
+ src_pal = src_surface->palette;
- /* Copy one surface on the other */
- dst_desc = (DDSURFACEDESC *)&(dst_surface->surface_desc);
- src_desc = (DDSURFACEDESC *)&(src_surface->surface_desc);
+ if (src_pal)
+ {
+ PALETTEENTRY palent[256];
- if ((src_desc->dwWidth != dst_desc->dwWidth) || (src_desc->dwHeight != dst_desc->dwHeight))
- {
- /* Should also check for same pixel format, u1.lPitch, ... */
- ERR("Error in surface sizes.\n");
- wined3d_mutex_unlock();
- return D3DERR_TEXTURE_LOAD_FAILED;
- }
- else
- {
- struct wined3d_map_desc src_map_desc, dst_map_desc;
+ if (!dst_pal)
+ {
+ wined3d_mutex_unlock();
+ return DDERR_NOPALETTEATTACHED;
+ }
+ IDirectDrawPalette_GetEntries(&src_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
+ IDirectDrawPalette_SetEntries(&dst_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
+ }
- /* Copy the src blit color key if the source has one, don't erase
- * the destination's ckey if the source has none */
if (src_desc->dwFlags & DDSD_CKSRCBLT)
{
IDirectDrawSurface7_SetColorKey(&dst_surface->IDirectDrawSurface7_iface,
DDCKEY_SRCBLT, &src_desc->ddckCKSrcBlt);
}
+ }
+ else
+ {
+ if (src_desc->dwFlags & DDSD_CKSRCBLT)
+ return E_FAIL;
+ }
- if (FAILED(hr = wined3d_resource_map(src_resource,
- src_surface->sub_resource_idx, &src_map_desc, NULL, 0)))
- {
- ERR("Failed to lock source surface, hr %#x.\n", hr);
- wined3d_mutex_unlock();
- return D3DERR_TEXTURE_LOAD_FAILED;
- }
-
- if (FAILED(hr = wined3d_resource_map(dst_resource,
- dst_surface->sub_resource_idx, &dst_map_desc, NULL, 0)))
- {
- ERR("Failed to lock destination surface, hr %#x.\n", hr);
- wined3d_resource_unmap(src_resource, src_surface->sub_resource_idx);
- wined3d_mutex_unlock();
- return D3DERR_TEXTURE_LOAD_FAILED;
- }
+ /* Suppress the ALLOCONLOAD flag */
+ dst_surface->surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
- if (dst_surface->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
- memcpy(dst_map_desc.data, src_map_desc.data, src_surface->surface_desc.u1.dwLinearSize);
- else
- memcpy(dst_map_desc.data, src_map_desc.data, src_map_desc.row_pitch * src_desc->dwHeight);
+ SetRect(&src_rect, 0, 0, src_surface->surface_desc.dwWidth, src_surface->surface_desc.dwHeight);
+ SetRect(&dst_rect, 0, 0, dst_surface->surface_desc.dwWidth, dst_surface->surface_desc.dwHeight);
- wined3d_resource_unmap(dst_resource, dst_surface->sub_resource_idx);
- wined3d_resource_unmap(src_resource, src_surface->sub_resource_idx);
+ hr = wined3d_texture_blt(dst_surface->wined3d_texture, dst_surface->sub_resource_idx, &dst_rect,
+ src_surface->wined3d_texture, src_surface->sub_resource_idx, &src_rect,
+ 0, NULL, WINED3D_TEXF_LINEAR);
+ if (FAILED(hr))
+ {
+ ERR("Failed to blit surface, hr %#x.\n", hr);
+ wined3d_mutex_unlock();
+ return hr;
}
if (src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
else
dst_surface = NULL;
+ if (src_surface && !dst_surface)
+ return DDERR_NOTFOUND;
+
if (!src_surface || !dst_surface)
- {
- if (src_surface != dst_surface)
- ERR("Loading surface with different mipmap structure.\n");
break;
- }
}
wined3d_mutex_unlock();
ddraw_surface2_PageUnlock,
};
-static const struct IDirectDrawSurfaceVtbl ddraw_surface1_vtbl =
+static struct IDirectDrawSurfaceVtbl ddraw_surface1_vtbl =
{
/* IUnknown */
ddraw_surface1_QueryInterface,
wined3d_private_store_cleanup(&surface->private_store);
- HeapFree(GetProcessHeap(), 0, surface);
+ heap_free(surface);
}
static const struct wined3d_parent_ops ddraw_surface_wined3d_parent_ops =
{
TRACE("parent %p.\n", parent);
- HeapFree(GetProcessHeap(), 0, parent);
+ heap_free(parent);
}
static const struct wined3d_parent_ops ddraw_texture_wined3d_parent_ops =
if (!surface)
return E_POINTER;
- if (!(texture = HeapAlloc(GetProcessHeap(), 0, sizeof(*texture))))
+ if (!(texture = heap_alloc(sizeof(*texture))))
return E_OUTOFMEMORY;
texture->version = version;
if (!(desc->dwFlags & DDSD_BACKBUFFERCOUNT) || !desc->u5.dwBackBufferCount)
{
WARN("Tried to create a flippable surface without any back buffers.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
if (!(desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX))
{
WARN("Tried to create a flippable surface without DDSCAPS_COMPLEX.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
{
WARN("Tried to create a flippable cubemap.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
{
FIXME("Flippable textures not implemented.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
}
{
WARN("Tried to specify a back buffer count for a non-flippable surface.\n");
hr = desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP ? DDERR_INVALIDPARAMS : DDERR_INVALIDCAPS;
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return hr;
}
}
if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
{
WARN("Tried to create a primary surface with DDSCAPS_TEXTURE.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
if ((desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX) && !(desc->ddsCaps.dwCaps & DDSCAPS_FLIP))
{
WARN("Tried to create a flippable primary surface without both DDSCAPS_FLIP and DDSCAPS_COMPLEX.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
if ((desc->ddsCaps.dwCaps & DDSCAPS_FLIP) && !(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
{
WARN("Tried to create a flippable primary surface without DDSCL_EXCLUSIVE.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_NOEXCLUSIVEMODE;
}
}
== (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
{
WARN("Tried to create a surface in both system and video memory.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
&& !(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
{
WARN("Caps %#x require DDSCAPS_TEXTURE.\n", desc->ddsCaps.dwCaps);
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
&& !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
{
WARN("Cube map faces requested without cube map flag.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
&& !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES))
{
WARN("Cube map without faces requested.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
if (!(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
{
WARN("DDSCAPS2_TEXTUREMANAGE used without DDSCAPS_TEXTURE, returning DDERR_INVALIDCAPS.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
if (desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
{
WARN("DDSCAPS2_TEXTUREMANAGE used width DDSCAPS_VIDEOMEMORY "
"or DDSCAPS_SYSTEMMEMORY, returning DDERR_INVALIDCAPS.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
}
if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
{
ERR("Failed to get display mode, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return hr_ddraw_from_wined3d(hr);
}
if (wined3d_desc.format == WINED3DFMT_UNKNOWN)
{
WARN("Unsupported / unknown pixelformat.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPIXELFORMAT;
}
if (!(desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
{
WARN("No width / height specified.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
if (!desc->dwWidth || !desc->dwHeight)
{
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
&swapchain_desc, NULL, ddraw_reset_enum_callback, TRUE)))
{
ERR("Failed to reset device.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return hr_ddraw_from_wined3d(hr);
}
wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
wined3d_desc.multisample_quality = 0;
wined3d_desc.usage = 0;
- wined3d_desc.pool = WINED3D_POOL_DEFAULT;
+ wined3d_desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
wined3d_desc.width = desc->dwWidth;
wined3d_desc.height = desc->dwHeight;
wined3d_desc.depth = 1;
/* Mipmap count is given, should not be 0. */
if (!desc->u2.dwMipMapCount)
{
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
}
== (DDSCAPS_OVERLAY | DDSCAPS_SYSTEMMEMORY))
{
WARN("System memory overlays are not allowed.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_NOOVERLAYHW;
}
if (desc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
{
- wined3d_desc.pool = WINED3D_POOL_SYSTEM_MEM;
+ /*
+ * The ddraw RGB device allows to use system memory surfaces as rendering target.
+ * This does not cause problems because the RGB device does software rasterization
+ * though it will fail with hardware accelerated ddraw. In order to be partially
+ * compatible with games requesting explicitly the RGB device, we ignore the
+ * specified location and try to create rendering targets in video memory if
+ * possible.
+ */
+ if ((desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) &&
+ SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
+ WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_RENDERTARGET,
+ WINED3D_RTYPE_TEXTURE_2D, wined3d_desc.format)))
+ {
+ FIXME("Application wants to create rendering target in system memory, using video memory instead\n");
+ wined3d_desc.usage |= WINED3DUSAGE_RENDERTARGET;
+ }
+ else
+ wined3d_desc.access = WINED3D_RESOURCE_ACCESS_CPU
+ | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
}
else
{
if (desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
{
- wined3d_desc.pool = WINED3D_POOL_MANAGED;
+ wined3d_desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU
+ | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
/* Managed textures have the system memory flag set. */
desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
}
if (desc->dwFlags & DDSD_LPSURFACE)
{
- if (wined3d_desc.pool != WINED3D_POOL_SYSTEM_MEM)
+ if (wined3d_desc.access & WINED3D_RESOURCE_ACCESS_GPU)
{
- WARN("User memory surfaces should be in the system memory pool.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ WARN("User memory surfaces should not be GPU accessible.\n");
+ heap_free(texture);
return DDERR_INVALIDCAPS;
}
if (version < 4)
{
WARN("User memory surfaces not supported before version 4.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
if (!desc->lpSurface)
{
WARN("NULL surface memory pointer specified.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
if (version != 4 && (desc->dwFlags & DDSD_PITCH))
{
WARN("Pitch specified on a compressed user memory surface.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
if (!(desc->dwFlags & (DDSD_LINEARSIZE | DDSD_PITCH)))
{
WARN("Compressed user memory surfaces should explicitly specify the linear size.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
wined3d_desc.format, wined3d_desc.width) * ((desc->dwHeight + 3) / 4))
{
WARN("Invalid linear size %u specified.\n", desc->u1.dwLinearSize);
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
}
if (!(desc->dwFlags & DDSD_PITCH))
{
WARN("User memory surfaces should explicitly specify the pitch.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
wined3d_desc.format, wined3d_desc.width) || desc->u1.lPitch & 3)
{
WARN("Invalid pitch %u specified.\n", desc->u1.lPitch);
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_INVALIDPARAMS;
}
&& desc->ddckCKSrcBlt.dwColorSpaceLowValue != desc->ddckCKSrcBlt.dwColorSpaceHighValue))
{
WARN("Range color keys not supported, returning DDERR_NOCOLORKEYHW.\n");
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return DDERR_NOCOLORKEYHW;
}
&ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
{
WARN("Failed to create wined3d texture, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
return hr_ddraw_from_wined3d(hr);
}
attach = &last->complex_array[0];
for (i = 0; i < count; ++i)
{
- if (!(texture = HeapAlloc(GetProcessHeap(), 0, sizeof(*texture))))
+ if (!(texture = heap_alloc(sizeof(*texture))))
{
hr = E_OUTOFMEMORY;
goto fail;
WINED3D_TEXTURE_CREATE_GET_DC_LENIENT, NULL, texture,
&ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
{
- HeapFree(GetProcessHeap(), 0, texture);
+ heap_free(texture);
hr = hr_ddraw_from_wined3d(hr);
goto fail;
}
projects / reactos.git / blobdiff