ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wined3d: Migrate surfaces to the new location flags.

This commit is contained in:
Stefan Dösinger 2014-01-17 13:27:16 +01:00 committed by Alexandre Julliard
parent beb64c9998
commit b81e560531
9 changed files with 224 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
dlls/wined3d/arb_program_shader.c
View File

@ -7454,7 +7454,8 @@ HRESULT arbfp_blit_surface(struct wined3d_device *device, DWORD filter,
/* Now load the surface */ /* Now load the surface */
if (wined3d_settings.offscreen_rendering_mode != ORM_FBO if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
&& (src_surface->locations & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE)) == SFLAG_INDRAWABLE && (src_surface->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_DRAWABLE))
== WINED3D_LOCATION_DRAWABLE
&& !surface_is_offscreen(src_surface)) && !surface_is_offscreen(src_surface))
{ {
/* Without FBO blits transferring from the drawable to the texture is /* Without FBO blits transferring from the drawable to the texture is

40
dlls/wined3d/context.c
View File

@ -139,8 +139,8 @@ static void context_attach_depth_stencil_fbo(struct wined3d_context *context,
{ {
switch (location) switch (location)
{ {
case SFLAG_INTEXTURE: case WINED3D_LOCATION_TEXTURE_RGB:
case SFLAG_INSRGBTEX: case WINED3D_LOCATION_TEXTURE_SRGB:
surface_prepare_texture(depth_stencil, context, FALSE); surface_prepare_texture(depth_stencil, context, FALSE);
if (format_flags & WINED3DFMT_FLAG_DEPTH) if (format_flags & WINED3DFMT_FLAG_DEPTH)
@ -160,20 +160,20 @@ static void context_attach_depth_stencil_fbo(struct wined3d_context *context,
} }
break; break;
case SFLAG_INRB_MULTISAMPLE: case WINED3D_LOCATION_RB_MULTISAMPLE:
surface_prepare_rb(depth_stencil, gl_info, TRUE); surface_prepare_rb(depth_stencil, gl_info, TRUE);
context_attach_depth_stencil_rb(gl_info, fbo_target, context_attach_depth_stencil_rb(gl_info, fbo_target,
format_flags, depth_stencil->rb_multisample); format_flags, depth_stencil->rb_multisample);
break; break;
case SFLAG_INRB_RESOLVED: case WINED3D_LOCATION_RB_RESOLVED:
surface_prepare_rb(depth_stencil, gl_info, FALSE); surface_prepare_rb(depth_stencil, gl_info, FALSE);
context_attach_depth_stencil_rb(gl_info, fbo_target, context_attach_depth_stencil_rb(gl_info, fbo_target,
format_flags, depth_stencil->rb_resolved); format_flags, depth_stencil->rb_resolved);
break; break;
default: default:
ERR("Unsupported location %s (%#x).\n", debug_surflocation(location), location); ERR("Unsupported location %s (%#x).\n", wined3d_debug_location(location), location);
break; break;
} }
} }
@ -214,9 +214,9 @@ static void context_attach_surface_fbo(struct wined3d_context *context,
switch (location) switch (location)
{ {
case SFLAG_INTEXTURE: case WINED3D_LOCATION_TEXTURE_RGB:
case SFLAG_INSRGBTEX: case WINED3D_LOCATION_TEXTURE_SRGB:
srgb = location == SFLAG_INSRGBTEX; srgb = location == WINED3D_LOCATION_TEXTURE_SRGB;
surface_prepare_texture(surface, context, srgb); surface_prepare_texture(surface, context, srgb);
gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_COLOR_ATTACHMENT0 + idx, gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_COLOR_ATTACHMENT0 + idx,
surface->texture_target, surface_get_texture_name(surface, gl_info, srgb), surface->texture_target, surface_get_texture_name(surface, gl_info, srgb),
@ -224,14 +224,14 @@ static void context_attach_surface_fbo(struct wined3d_context *context,
checkGLcall("glFramebufferTexture2D()"); checkGLcall("glFramebufferTexture2D()");
break; break;
case SFLAG_INRB_MULTISAMPLE: case WINED3D_LOCATION_RB_MULTISAMPLE:
surface_prepare_rb(surface, gl_info, TRUE); surface_prepare_rb(surface, gl_info, TRUE);
gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_COLOR_ATTACHMENT0 + idx, gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_COLOR_ATTACHMENT0 + idx,
GL_RENDERBUFFER, surface->rb_multisample); GL_RENDERBUFFER, surface->rb_multisample);
checkGLcall("glFramebufferRenderbuffer()"); checkGLcall("glFramebufferRenderbuffer()");
break; break;
case SFLAG_INRB_RESOLVED: case WINED3D_LOCATION_RB_RESOLVED:
surface_prepare_rb(surface, gl_info, FALSE); surface_prepare_rb(surface, gl_info, FALSE);
gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_COLOR_ATTACHMENT0 + idx, gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_COLOR_ATTACHMENT0 + idx,
GL_RENDERBUFFER, surface->rb_resolved); GL_RENDERBUFFER, surface->rb_resolved);
@ -239,7 +239,7 @@ static void context_attach_surface_fbo(struct wined3d_context *context,
break; break;
default: default:
ERR("Unsupported location %s (%#x).\n", debug_surflocation(location), location); ERR("Unsupported location %s (%#x).\n", wined3d_debug_location(location), location);
break; break;
} }
} }
@ -276,7 +276,7 @@ void context_check_fbo_status(const struct wined3d_context *context, GLenum targ
return; return;
} }
FIXME("\tLocation %s (%#x).\n", debug_surflocation(context->current_fbo->location), FIXME("\tLocation %s (%#x).\n", wined3d_debug_location(context->current_fbo->location),
context->current_fbo->location); context->current_fbo->location);
/* Dump the FBO attachments */ /* Dump the FBO attachments */
@ -467,7 +467,7 @@ static void context_apply_fbo_state(struct wined3d_context *context, GLenum targ
context->rebind_fbo = FALSE; context->rebind_fbo = FALSE;
} }
if (location == SFLAG_INDRAWABLE) if (location == WINED3D_LOCATION_DRAWABLE)
{ {
context->current_fbo = NULL; context->current_fbo = NULL;
context_bind_fbo(context, target, 0); context_bind_fbo(context, target, 0);
@ -2096,7 +2096,7 @@ static void context_validate_onscreen_formats(struct wined3d_context *context,
WARN("Depth stencil format is not supported by WGL, rendering the backbuffer in an FBO\n"); WARN("Depth stencil format is not supported by WGL, rendering the backbuffer in an FBO\n");
/* The currently active context is the necessary context to access the swapchain's onscreen buffers */ /* The currently active context is the necessary context to access the swapchain's onscreen buffers */
surface_load_location(context->current_rt, SFLAG_INTEXTURE); surface_load_location(context->current_rt, WINED3D_LOCATION_TEXTURE_RGB);
swapchain->render_to_fbo = TRUE; swapchain->render_to_fbo = TRUE;
swapchain_update_draw_bindings(swapchain); swapchain_update_draw_bindings(swapchain);
context_set_render_offscreen(context, TRUE); context_set_render_offscreen(context, TRUE);
@ -2211,11 +2211,11 @@ BOOL context_apply_clear_state(struct wined3d_context *context, const struct win
++i; ++i;
} }
context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets, fb->depth_stencil, context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets, fb->depth_stencil,
rt_count ? rts[0]->draw_binding : SFLAG_INTEXTURE); rt_count ? rts[0]->draw_binding : WINED3D_LOCATION_TEXTURE_RGB);
} }
else else
{ {
context_apply_fbo_state(context, GL_FRAMEBUFFER, NULL, NULL, SFLAG_INDRAWABLE); context_apply_fbo_state(context, GL_FRAMEBUFFER, NULL, NULL, WINED3D_LOCATION_DRAWABLE);
rt_mask = context_generate_rt_mask_from_surface(rts[0]); rt_mask = context_generate_rt_mask_from_surface(rts[0]);
} }
@ -2312,7 +2312,7 @@ void context_state_fb(struct wined3d_context *context, const struct wined3d_stat
{ {
if (!context->render_offscreen) if (!context->render_offscreen)
{ {
context_apply_fbo_state(context, GL_FRAMEBUFFER, NULL, NULL, SFLAG_INDRAWABLE); context_apply_fbo_state(context, GL_FRAMEBUFFER, NULL, NULL, WINED3D_LOCATION_DRAWABLE);
} }
else else
{ {
@ -2928,8 +2928,8 @@ static void context_setup_target(struct wined3d_context *context, struct wined3d
/* When switching away from an offscreen render target, and we're not /* When switching away from an offscreen render target, and we're not
* using FBOs, we have to read the drawable into the texture. This is * using FBOs, we have to read the drawable into the texture. This is
* done via PreLoad (and SFLAG_INDRAWABLE set on the surface). There * done via PreLoad (and WINED3D_LOCATION_DRAWABLE set on the surface).
* are some things that need care though. PreLoad needs a GL context, * There are some things that need care though. PreLoad needs a GL context,
* and FindContext is called before the context is activated. It also * and FindContext is called before the context is activated. It also
* has to be called with the old rendertarget active, otherwise a * has to be called with the old rendertarget active, otherwise a
* wrong drawable is read. */ * wrong drawable is read. */
@ -2942,7 +2942,7 @@ static void context_setup_target(struct wined3d_context *context, struct wined3d
if (texture->texture_srgb.name) if (texture->texture_srgb.name)
wined3d_texture_load(texture, context, TRUE); wined3d_texture_load(texture, context, TRUE);
wined3d_texture_load(texture, context, FALSE); wined3d_texture_load(texture, context, FALSE);
surface_invalidate_location(context->current_rt, SFLAG_INDRAWABLE); surface_invalidate_location(context->current_rt, WINED3D_LOCATION_DRAWABLE);
} }
} }

2
dlls/wined3d/cs.c
View File

@ -378,7 +378,7 @@ static void wined3d_cs_exec_set_depth_stencil(struct wined3d_cs *cs, const void
if (device->swapchains[0]->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL if (device->swapchains[0]->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
|| prev->flags & SFLAG_DISCARD) || prev->flags & SFLAG_DISCARD)
{ {
surface_modify_ds_location(prev, SFLAG_DISCARDED, surface_modify_ds_location(prev, WINED3D_LOCATION_DISCARDED,
prev->resource.width, prev->resource.height); prev->resource.width, prev->resource.height);
if (prev == device->onscreen_depth_stencil) if (prev == device->onscreen_depth_stencil)
{ {

10
dlls/wined3d/device.c
View File

@ -201,9 +201,9 @@ void device_switch_onscreen_ds(struct wined3d_device *device,
{ {
if (device->onscreen_depth_stencil) if (device->onscreen_depth_stencil)
{ {
surface_load_ds_location(device->onscreen_depth_stencil, context, SFLAG_INTEXTURE); surface_load_ds_location(device->onscreen_depth_stencil, context, WINED3D_LOCATION_TEXTURE_RGB);
surface_modify_ds_location(device->onscreen_depth_stencil, SFLAG_INTEXTURE, surface_modify_ds_location(device->onscreen_depth_stencil, WINED3D_LOCATION_TEXTURE_RGB,
device->onscreen_depth_stencil->ds_current_size.cx, device->onscreen_depth_stencil->ds_current_size.cx,
device->onscreen_depth_stencil->ds_current_size.cy); device->onscreen_depth_stencil->ds_current_size.cy);
wined3d_surface_decref(device->onscreen_depth_stencil); wined3d_surface_decref(device->onscreen_depth_stencil);
@ -234,7 +234,7 @@ static void prepare_ds_clear(struct wined3d_surface *ds, struct wined3d_context
{ {
RECT current_rect, r; RECT current_rect, r;
if (ds->locations & SFLAG_DISCARDED) if (ds->locations & WINED3D_LOCATION_DISCARDED)
{ {
/* Depth buffer was discarded, make it entirely current in its new location since /* Depth buffer was discarded, make it entirely current in its new location since
* there is no other place where we would get data anyway. */ * there is no other place where we would get data anyway. */
@ -337,7 +337,7 @@ void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, c
if (flags & WINED3DCLEAR_ZBUFFER) if (flags & WINED3DCLEAR_ZBUFFER)
{ {
DWORD location = render_offscreen ? fb->depth_stencil->draw_binding : SFLAG_INDRAWABLE; DWORD location = render_offscreen ? fb->depth_stencil->draw_binding : WINED3D_LOCATION_DRAWABLE;
if (!render_offscreen && fb->depth_stencil != device->onscreen_depth_stencil) if (!render_offscreen && fb->depth_stencil != device->onscreen_depth_stencil)
device_switch_onscreen_ds(device, context, fb->depth_stencil); device_switch_onscreen_ds(device, context, fb->depth_stencil);
@ -369,7 +369,7 @@ void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, c
if (flags & WINED3DCLEAR_ZBUFFER) if (flags & WINED3DCLEAR_ZBUFFER)
{ {
DWORD location = render_offscreen ? fb->depth_stencil->draw_binding : SFLAG_INDRAWABLE; DWORD location = render_offscreen ? fb->depth_stencil->draw_binding : WINED3D_LOCATION_DRAWABLE;
surface_modify_ds_location(fb->depth_stencil, location, ds_rect.right, ds_rect.bottom); surface_modify_ds_location(fb->depth_stencil, location, ds_rect.right, ds_rect.bottom);

4
dlls/wined3d/drawprim.c
View File

@ -639,7 +639,7 @@ void draw_primitive(struct wined3d_device *device, UINT start_idx, UINT index_co
* depthstencil for D3DCMP_NEVER and D3DCMP_ALWAYS as well. Also note * depthstencil for D3DCMP_NEVER and D3DCMP_ALWAYS as well. Also note
* that we never copy the stencil data.*/ * that we never copy the stencil data.*/
DWORD location = context->render_offscreen ? DWORD location = context->render_offscreen ?
device->fb.depth_stencil->draw_binding : SFLAG_INDRAWABLE; device->fb.depth_stencil->draw_binding : WINED3D_LOCATION_DRAWABLE;
if (state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE]) if (state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE])
{ {
struct wined3d_surface *ds = device->fb.depth_stencil; struct wined3d_surface *ds = device->fb.depth_stencil;
@ -671,7 +671,7 @@ void draw_primitive(struct wined3d_device *device, UINT start_idx, UINT index_co
if (device->fb.depth_stencil && state->render_states[WINED3D_RS_ZWRITEENABLE]) if (device->fb.depth_stencil && state->render_states[WINED3D_RS_ZWRITEENABLE])
{ {
struct wined3d_surface *ds = device->fb.depth_stencil; struct wined3d_surface *ds = device->fb.depth_stencil;
DWORD location = context->render_offscreen ? ds->draw_binding : SFLAG_INDRAWABLE; DWORD location = context->render_offscreen ? ds->draw_binding : WINED3D_LOCATION_DRAWABLE;
surface_modify_ds_location(ds, location, ds->ds_current_size.cx, ds->ds_current_size.cy); surface_modify_ds_location(ds, location, ds->ds_current_size.cx, ds->ds_current_size.cy);
} }

313
dlls/wined3d/surface.c
View File

@ -37,7 +37,8 @@ WINE_DECLARE_DEBUG_CHANNEL(d3d);
#define MAXLOCKCOUNT 50 /* After this amount of locks do not free the sysmem copy. */ #define MAXLOCKCOUNT 50 /* After this amount of locks do not free the sysmem copy. */
static const DWORD surface_simple_locations = static const DWORD surface_simple_locations =
SFLAG_INDIB | SFLAG_INUSERMEM | SFLAG_INSYSMEM | SFLAG_INBUFFER; WINED3D_LOCATION_SYSMEM | WINED3D_LOCATION_USER_MEMORY
| WINED3D_LOCATION_DIB | WINED3D_LOCATION_BUFFER;
static void surface_cleanup(struct wined3d_surface *surface) static void surface_cleanup(struct wined3d_surface *surface)
{ {
@ -105,11 +106,11 @@ static void surface_cleanup(struct wined3d_surface *surface)
void surface_update_draw_binding(struct wined3d_surface *surface) void surface_update_draw_binding(struct wined3d_surface *surface)
{ {
if (!surface_is_offscreen(surface) || wined3d_settings.offscreen_rendering_mode != ORM_FBO) if (!surface_is_offscreen(surface) || wined3d_settings.offscreen_rendering_mode != ORM_FBO)
surface->draw_binding = SFLAG_INDRAWABLE; surface->draw_binding = WINED3D_LOCATION_DRAWABLE;
else if (surface->resource.multisample_type) else if (surface->resource.multisample_type)
surface->draw_binding = SFLAG_INRB_MULTISAMPLE; surface->draw_binding = WINED3D_LOCATION_RB_MULTISAMPLE;
else else
surface->draw_binding = SFLAG_INTEXTURE; surface->draw_binding = WINED3D_LOCATION_TEXTURE_RGB;
} }
void surface_set_swapchain(struct wined3d_surface *surface, struct wined3d_swapchain *swapchain) void surface_set_swapchain(struct wined3d_surface *surface, struct wined3d_swapchain *swapchain)
@ -508,32 +509,32 @@ static HRESULT surface_create_dib_section(struct wined3d_surface *surface)
static void surface_get_memory(const struct wined3d_surface *surface, struct wined3d_bo_address *data, static void surface_get_memory(const struct wined3d_surface *surface, struct wined3d_bo_address *data,
DWORD location) DWORD location)
{ {
if (location & SFLAG_INBUFFER) if (location & WINED3D_LOCATION_BUFFER)
{ {
data->addr = NULL; data->addr = NULL;
data->buffer_object = surface->pbo; data->buffer_object = surface->pbo;
return; return;
} }
if (location & SFLAG_INUSERMEM) if (location & WINED3D_LOCATION_USER_MEMORY)
{ {
data->addr = surface->user_memory; data->addr = surface->user_memory;
data->buffer_object = 0; data->buffer_object = 0;
return; return;
} }
if (location & SFLAG_INDIB) if (location & WINED3D_LOCATION_DIB)
{ {
data->addr = surface->dib.bitmap_data; data->addr = surface->dib.bitmap_data;
data->buffer_object = 0; data->buffer_object = 0;
return; return;
} }
if (location & SFLAG_INSYSMEM) if (location & WINED3D_LOCATION_SYSMEM)
{ {
data->addr = surface->resource.heap_memory; data->addr = surface->resource.heap_memory;
data->buffer_object = 0; data->buffer_object = 0;
return; return;
} }
ERR("Unexpected locations %s.\n", debug_surflocation(location)); ERR("Unexpected locations %s.\n", wined3d_debug_location(location));
data->addr = NULL; data->addr = NULL;
data->buffer_object = 0; data->buffer_object = 0;
} }
@ -582,34 +583,34 @@ static void surface_prepare_system_memory(struct wined3d_surface *surface)
if (!wined3d_resource_allocate_sysmem(&surface->resource)) if (!wined3d_resource_allocate_sysmem(&surface->resource))
ERR("Failed to allocate system memory.\n"); ERR("Failed to allocate system memory.\n");
if (surface->locations & SFLAG_INSYSMEM) if (surface->locations & WINED3D_LOCATION_SYSMEM)
ERR("Surface without system memory has SFLAG_INSYSMEM set.\n"); ERR("Surface without system memory has WINED3D_LOCATION_SYSMEM set.\n");
} }
void surface_prepare_map_memory(struct wined3d_surface *surface) void surface_prepare_map_memory(struct wined3d_surface *surface)
{ {
switch (surface->map_binding) switch (surface->map_binding)
{ {
case SFLAG_INUSERMEM: case WINED3D_LOCATION_SYSMEM:
if (!surface->user_memory)
ERR("Map binding is set to SFLAG_INUSERMEM but surface->user_memory is NULL.\n");
break;
case SFLAG_INDIB:
if (!surface->dib.bitmap_data)
ERR("Map binding is set to SFLAG_INDIB but surface->dib.bitmap_data is NULL.\n");
break;
case SFLAG_INSYSMEM:
surface_prepare_system_memory(surface); surface_prepare_system_memory(surface);
break; break;
case SFLAG_INBUFFER: case WINED3D_LOCATION_USER_MEMORY:
if (!surface->user_memory)
ERR("Map binding is set to WINED3D_LOCATION_USER_MEMORY but surface->user_memory is NULL.\n");
break;
case WINED3D_LOCATION_DIB:
if (!surface->dib.bitmap_data)
ERR("Map binding is set to WINED3D_LOCATION_DIB but surface->dib.bitmap_data is NULL.\n");
break;
case WINED3D_LOCATION_BUFFER:
surface_prepare_buffer(surface); surface_prepare_buffer(surface);
break; break;
default: default:
ERR("Unexpected map binding %s.\n", debug_surflocation(surface->map_binding)); ERR("Unexpected map binding %s.\n", wined3d_debug_location(surface->map_binding));
} }
} }
@ -619,7 +620,7 @@ static void surface_evict_sysmem(struct wined3d_surface *surface)
return; return;
wined3d_resource_free_sysmem(&surface->resource); wined3d_resource_free_sysmem(&surface->resource);
surface_invalidate_location(surface, SFLAG_INSYSMEM); surface_invalidate_location(surface, WINED3D_LOCATION_SYSMEM);
} }
static void surface_force_reload(struct wined3d_surface *surface) static void surface_force_reload(struct wined3d_surface *surface)
@ -647,7 +648,7 @@ static void surface_release_client_storage(struct wined3d_surface *surface)
context_release(context); context_release(context);
surface_invalidate_location(surface, SFLAG_INTEXTURE | SFLAG_INSRGBTEX); surface_invalidate_location(surface, WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB);
surface_force_reload(surface); surface_force_reload(surface);
} }
@ -747,10 +748,10 @@ static HRESULT surface_private_setup(struct wined3d_surface *surface)
} }
if (surface->resource.usage & WINED3DUSAGE_DEPTHSTENCIL) if (surface->resource.usage & WINED3DUSAGE_DEPTHSTENCIL)
surface->locations = SFLAG_DISCARDED; surface->locations = WINED3D_LOCATION_DISCARDED;
if (surface_use_pbo(surface)) if (surface_use_pbo(surface))
surface->map_binding = SFLAG_INBUFFER; surface->map_binding = WINED3D_LOCATION_BUFFER;
return WINED3D_OK; return WINED3D_OK;
} }
@ -770,11 +771,11 @@ static void surface_realize_palette(struct wined3d_surface *surface)
{ {
/* Make sure the texture is up to date. This call doesn't do /* Make sure the texture is up to date. This call doesn't do
* anything if the texture is already up to date. */ * anything if the texture is already up to date. */
surface_load_location(surface, SFLAG_INTEXTURE); surface_load_location(surface, WINED3D_LOCATION_TEXTURE_RGB);
/* We want to force a palette refresh, so mark the drawable as not being up to date */ /* We want to force a palette refresh, so mark the drawable as not being up to date */
if (!surface_is_offscreen(surface)) if (!surface_is_offscreen(surface))
surface_invalidate_location(surface, SFLAG_INDRAWABLE); surface_invalidate_location(surface, WINED3D_LOCATION_DRAWABLE);
} }
else else
{ {
@ -822,12 +823,12 @@ static void surface_unmap(struct wined3d_surface *surface)
switch (surface->map_binding) switch (surface->map_binding)
{ {
case SFLAG_INUSERMEM: case WINED3D_LOCATION_SYSMEM:
case SFLAG_INDIB: case WINED3D_LOCATION_USER_MEMORY:
case SFLAG_INSYSMEM: case WINED3D_LOCATION_DIB:
break; break;
case SFLAG_INBUFFER: case WINED3D_LOCATION_BUFFER:
context = context_acquire(device, NULL); context = context_acquire(device, NULL);
gl_info = context->gl_info; gl_info = context->gl_info;
@ -839,10 +840,10 @@ static void surface_unmap(struct wined3d_surface *surface)
break; break;
default: default:
ERR("Unexpected map binding %s.\n", debug_surflocation(surface->map_binding)); ERR("Unexpected map binding %s.\n", wined3d_debug_location(surface->map_binding));
} }
if (surface->locations & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE)) if (surface->locations & (WINED3D_LOCATION_DRAWABLE | WINED3D_LOCATION_TEXTURE_RGB))
{ {
TRACE("Not dirtified, nothing to do.\n"); TRACE("Not dirtified, nothing to do.\n");
return; return;
@ -874,9 +875,9 @@ static void surface_depth_blt_fbo(const struct wined3d_device *device,
TRACE("device %p\n", device); TRACE("device %p\n", device);
TRACE("src_surface %p, src_location %s, src_rect %s,\n", TRACE("src_surface %p, src_location %s, src_rect %s,\n",
src_surface, debug_surflocation(src_location), wine_dbgstr_rect(src_rect)); src_surface, wined3d_debug_location(src_location), wine_dbgstr_rect(src_rect));
TRACE("dst_surface %p, dst_location %s, dst_rect %s.\n", TRACE("dst_surface %p, dst_location %s, dst_rect %s.\n",
dst_surface, debug_surflocation(dst_location), wine_dbgstr_rect(dst_rect)); dst_surface, wined3d_debug_location(dst_location), wine_dbgstr_rect(dst_rect));
src_mask = src_surface->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL); src_mask = src_surface->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL);
dst_mask = dst_surface->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL); dst_mask = dst_surface->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL);
@ -969,9 +970,9 @@ static void surface_blt_fbo(const struct wined3d_device *device, enum wined3d_te
TRACE("device %p, filter %s,\n", device, debug_d3dtexturefiltertype(filter)); TRACE("device %p, filter %s,\n", device, debug_d3dtexturefiltertype(filter));
TRACE("src_surface %p, src_location %s, src_rect %s,\n", TRACE("src_surface %p, src_location %s, src_rect %s,\n",
src_surface, debug_surflocation(src_location), wine_dbgstr_rect(src_rect_in)); src_surface, wined3d_debug_location(src_location), wine_dbgstr_rect(src_rect_in));
TRACE("dst_surface %p, dst_location %s, dst_rect %s.\n", TRACE("dst_surface %p, dst_location %s, dst_rect %s.\n",
dst_surface, debug_surflocation(dst_location), wine_dbgstr_rect(dst_rect_in)); dst_surface, wined3d_debug_location(dst_location), wine_dbgstr_rect(dst_rect_in));
src_rect = *src_rect_in; src_rect = *src_rect_in;
dst_rect = *dst_rect_in; dst_rect = *dst_rect_in;
@ -991,11 +992,11 @@ static void surface_blt_fbo(const struct wined3d_device *device, enum wined3d_te
} }
/* Resolve the source surface first if needed. */ /* Resolve the source surface first if needed. */
if (src_location == SFLAG_INRB_MULTISAMPLE if (src_location == WINED3D_LOCATION_RB_MULTISAMPLE
&& (src_surface->resource.format->id != dst_surface->resource.format->id && (src_surface->resource.format->id != dst_surface->resource.format->id
|| abs(src_rect.bottom - src_rect.top) != abs(dst_rect.bottom - dst_rect.top) || abs(src_rect.bottom - src_rect.top) != abs(dst_rect.bottom - dst_rect.top)
|| abs(src_rect.right - src_rect.left) != abs(dst_rect.right - dst_rect.left))) || abs(src_rect.right - src_rect.left) != abs(dst_rect.right - dst_rect.left)))
src_location = SFLAG_INRB_RESOLVED; src_location = WINED3D_LOCATION_RB_RESOLVED;
/* Make sure the locations are up-to-date. Loading the destination /* Make sure the locations are up-to-date. Loading the destination
* surface isn't required if the entire surface is overwritten. (And is * surface isn't required if the entire surface is overwritten. (And is
@ -1005,8 +1006,8 @@ static void surface_blt_fbo(const struct wined3d_device *device, enum wined3d_te
if (!surface_is_full_rect(dst_surface, &dst_rect)) if (!surface_is_full_rect(dst_surface, &dst_rect))
surface_load_location(dst_surface, dst_location); surface_load_location(dst_surface, dst_location);
if (src_location == SFLAG_INDRAWABLE) context = context_acquire(device, src_surface); if (src_location == WINED3D_LOCATION_DRAWABLE) context = context_acquire(device, src_surface);
else if (dst_location == SFLAG_INDRAWABLE) context = context_acquire(device, dst_surface); else if (dst_location == WINED3D_LOCATION_DRAWABLE) context = context_acquire(device, dst_surface);
else context = context_acquire(device, NULL); else context = context_acquire(device, NULL);
if (!context->valid) if (!context->valid)
@ -1018,7 +1019,7 @@ static void surface_blt_fbo(const struct wined3d_device *device, enum wined3d_te
gl_info = context->gl_info; gl_info = context->gl_info;
if (src_location == SFLAG_INDRAWABLE) if (src_location == WINED3D_LOCATION_DRAWABLE)
{ {
TRACE("Source surface %p is onscreen.\n", src_surface); TRACE("Source surface %p is onscreen.\n", src_surface);
buffer = surface_get_gl_buffer(src_surface); buffer = surface_get_gl_buffer(src_surface);
@ -1035,7 +1036,7 @@ static void surface_blt_fbo(const struct wined3d_device *device, enum wined3d_te
checkGLcall("glReadBuffer()"); checkGLcall("glReadBuffer()");
context_check_fbo_status(context, GL_READ_FRAMEBUFFER); context_check_fbo_status(context, GL_READ_FRAMEBUFFER);
if (dst_location == SFLAG_INDRAWABLE) if (dst_location == WINED3D_LOCATION_DRAWABLE)
{ {
TRACE("Destination surface %p is onscreen.\n", dst_surface); TRACE("Destination surface %p is onscreen.\n", dst_surface);
buffer = surface_get_gl_buffer(dst_surface); buffer = surface_get_gl_buffer(dst_surface);
@ -1066,7 +1067,7 @@ static void surface_blt_fbo(const struct wined3d_device *device, enum wined3d_te
checkGLcall("glBlitFramebuffer()"); checkGLcall("glBlitFramebuffer()");
if (wined3d_settings.strict_draw_ordering if (wined3d_settings.strict_draw_ordering
|| (dst_location == SFLAG_INDRAWABLE || (dst_location == WINED3D_LOCATION_DRAWABLE
&& dst_surface->swapchain->front_buffer == dst_surface)) && dst_surface->swapchain->front_buffer == dst_surface))
gl_info->gl_ops.gl.p_glFlush(); gl_info->gl_ops.gl.p_glFlush();
@ -1252,7 +1253,7 @@ static void surface_remove_pbo(struct wined3d_surface *surface, const struct win
checkGLcall("glDeleteBuffersARB(1, &surface->pbo)"); checkGLcall("glDeleteBuffersARB(1, &surface->pbo)");
surface->pbo = 0; surface->pbo = 0;
surface_invalidate_location(surface, SFLAG_INBUFFER); surface_invalidate_location(surface, WINED3D_LOCATION_BUFFER);
} }
static void surface_unload(struct wined3d_resource *resource) static void surface_unload(struct wined3d_resource *resource)
@ -1278,8 +1279,8 @@ static void surface_unload(struct wined3d_resource *resource)
* and all flags get lost */ * and all flags get lost */
surface_prepare_system_memory(surface); surface_prepare_system_memory(surface);
memset(surface->resource.heap_memory, 0, surface->resource.size); memset(surface->resource.heap_memory, 0, surface->resource.size);
surface_validate_location(surface, SFLAG_INSYSMEM); surface_validate_location(surface, WINED3D_LOCATION_SYSMEM);
surface_invalidate_location(surface, ~SFLAG_INSYSMEM); surface_invalidate_location(surface, ~WINED3D_LOCATION_SYSMEM);
/* We also get here when the ddraw swapchain is destroyed, for example /* We also get here when the ddraw swapchain is destroyed, for example
* for a mode switch. In this case this surface won't necessarily be * for a mode switch. In this case this surface won't necessarily be
@ -1375,7 +1376,7 @@ static HRESULT gdi_surface_private_setup(struct wined3d_surface *surface)
hr = surface_create_dib_section(surface); hr = surface_create_dib_section(surface);
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
surface->map_binding = SFLAG_INDIB; surface->map_binding = WINED3D_LOCATION_DIB;
/* We don't mind the nonpow2 stuff in GDI. */ /* We don't mind the nonpow2 stuff in GDI. */
surface->pow2Width = surface->resource.width; surface->pow2Width = surface->resource.width;
@ -1970,7 +1971,7 @@ HRESULT surface_upload_from_surface(struct wined3d_surface *dst_surface, const P
if (update_w == dst_w && update_h == dst_h) if (update_w == dst_w && update_h == dst_h)
surface_prepare_texture(dst_surface, context, FALSE); surface_prepare_texture(dst_surface, context, FALSE);
else else
surface_load_location(dst_surface, SFLAG_INTEXTURE); surface_load_location(dst_surface, WINED3D_LOCATION_TEXTURE_RGB);
wined3d_texture_bind(dst_surface->container, context, FALSE); wined3d_texture_bind(dst_surface->container, context, FALSE);
surface_get_memory(src_surface, &data, src_surface->locations); surface_get_memory(src_surface, &data, src_surface->locations);
@ -1982,8 +1983,8 @@ HRESULT surface_upload_from_surface(struct wined3d_surface *dst_surface, const P
context_release(context); context_release(context);
surface_validate_location(dst_surface, SFLAG_INTEXTURE); surface_validate_location(dst_surface, WINED3D_LOCATION_TEXTURE_RGB);
surface_invalidate_location(dst_surface, ~SFLAG_INTEXTURE); surface_invalidate_location(dst_surface, ~WINED3D_LOCATION_TEXTURE_RGB);
return WINED3D_OK; return WINED3D_OK;
} }
@ -2171,7 +2172,7 @@ GLenum surface_get_gl_buffer(const struct wined3d_surface *surface)
void surface_load(struct wined3d_surface *surface, BOOL srgb) void surface_load(struct wined3d_surface *surface, BOOL srgb)
{ {
DWORD location = srgb ? SFLAG_INSRGBTEX : SFLAG_INTEXTURE; DWORD location = srgb ? WINED3D_LOCATION_TEXTURE_SRGB : WINED3D_LOCATION_TEXTURE_RGB;
BOOL ck_changed; BOOL ck_changed;
TRACE("surface %p, srgb %#x.\n", surface, srgb); TRACE("surface %p, srgb %#x.\n", surface, srgb);
@ -2655,8 +2656,8 @@ HRESULT CDECL wined3d_surface_update_desc(struct wined3d_surface *surface,
surface->user_memory = mem; surface->user_memory = mem;
if (surface->user_memory) if (surface->user_memory)
{ {
surface->map_binding = SFLAG_INUSERMEM; surface->map_binding = WINED3D_LOCATION_USER_MEMORY;
valid_location = SFLAG_INUSERMEM; valid_location = WINED3D_LOCATION_USER_MEMORY;
} }
surface->pitch = pitch; surface->pitch = pitch;
surface->resource.format = format; surface->resource.format = format;
@ -2671,8 +2672,8 @@ HRESULT CDECL wined3d_surface_update_desc(struct wined3d_surface *surface,
* If the surface didn't use PBOs previously but could now, don't * If the surface didn't use PBOs previously but could now, don't
* change it - whatever made us not use PBOs might come back, e.g. * change it - whatever made us not use PBOs might come back, e.g.
* color keys. */ * color keys. */
if (surface->map_binding == SFLAG_INBUFFER && !surface_use_pbo(surface)) if (surface->map_binding == WINED3D_LOCATION_BUFFER && !surface_use_pbo(surface))
surface->map_binding = create_dib ? SFLAG_INDIB : SFLAG_INSYSMEM; surface->map_binding = create_dib ? WINED3D_LOCATION_DIB : WINED3D_LOCATION_SYSMEM;
if (create_dib) if (create_dib)
{ {
@ -2682,13 +2683,13 @@ HRESULT CDECL wined3d_surface_update_desc(struct wined3d_surface *surface,
return hr; return hr;
} }
if (!valid_location) if (!valid_location)
valid_location = SFLAG_INDIB; valid_location = WINED3D_LOCATION_DIB;
} }
if (!valid_location) if (!valid_location)
{ {
surface_prepare_system_memory(surface); surface_prepare_system_memory(surface);
valid_location = SFLAG_INSYSMEM; valid_location = WINED3D_LOCATION_SYSMEM;
} }
surface_validate_location(surface, valid_location); surface_validate_location(surface, valid_location);
@ -3080,7 +3081,7 @@ HRESULT CDECL wined3d_surface_map(struct wined3d_surface *surface,
if (flags & WINED3D_MAP_DISCARD) if (flags & WINED3D_MAP_DISCARD)
{ {
TRACE("WINED3D_MAP_DISCARD flag passed, marking %s as up to date.\n", TRACE("WINED3D_MAP_DISCARD flag passed, marking %s as up to date.\n",
debug_surflocation(surface->map_binding)); wined3d_debug_location(surface->map_binding));
surface_validate_location(surface, surface->map_binding); surface_validate_location(surface, surface->map_binding);
} }
else else
@ -3096,15 +3097,19 @@ HRESULT CDECL wined3d_surface_map(struct wined3d_surface *surface,
switch (surface->map_binding) switch (surface->map_binding)
{ {
case SFLAG_INUSERMEM: case WINED3D_LOCATION_SYSMEM:
base_memory = surface->resource.heap_memory;
break;
case WINED3D_LOCATION_USER_MEMORY:
base_memory = surface->user_memory; base_memory = surface->user_memory;
break; break;
case SFLAG_INDIB: case WINED3D_LOCATION_DIB:
base_memory = surface->dib.bitmap_data; base_memory = surface->dib.bitmap_data;
break; break;
case SFLAG_INBUFFER: case WINED3D_LOCATION_BUFFER:
context = context_acquire(device, NULL); context = context_acquire(device, NULL);
gl_info = context->gl_info; gl_info = context->gl_info;
@ -3116,12 +3121,8 @@ HRESULT CDECL wined3d_surface_map(struct wined3d_surface *surface,
context_release(context); context_release(context);
break; break;
case SFLAG_INSYSMEM:
base_memory = surface->resource.heap_memory;
break;
default: default:
ERR("Unexpected map binding %s.\n", debug_surflocation(surface->map_binding)); ERR("Unexpected map binding %s.\n", wined3d_debug_location(surface->map_binding));
base_memory = NULL; base_memory = NULL;
} }
@ -3186,20 +3187,20 @@ HRESULT CDECL wined3d_surface_getdc(struct wined3d_surface *surface, HDC *dc)
{ {
if (surface->flags & SFLAG_CLIENT) if (surface->flags & SFLAG_CLIENT)
{ {
surface_load_location(surface, SFLAG_INSYSMEM); surface_load_location(surface, WINED3D_LOCATION_SYSMEM);
surface_release_client_storage(surface); surface_release_client_storage(surface);
} }
hr = surface_create_dib_section(surface); hr = surface_create_dib_section(surface);
if (FAILED(hr)) if (FAILED(hr))
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
if (!(surface->map_binding == SFLAG_INUSERMEM if (!(surface->map_binding == WINED3D_LOCATION_USER_MEMORY
|| surface->flags & SFLAG_PIN_SYSMEM || surface->flags & SFLAG_PIN_SYSMEM
|| surface->pbo)) || surface->pbo))
surface->map_binding = SFLAG_INDIB; surface->map_binding = WINED3D_LOCATION_DIB;
} }
surface_load_location(surface, SFLAG_INDIB); surface_load_location(surface, WINED3D_LOCATION_DIB);
surface_invalidate_location(surface, ~SFLAG_INDIB); surface_invalidate_location(surface, ~WINED3D_LOCATION_DIB);
if (surface->resource.format->id == WINED3DFMT_P8_UINT if (surface->resource.format->id == WINED3DFMT_P8_UINT
|| surface->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM) || surface->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
@ -3264,8 +3265,8 @@ HRESULT CDECL wined3d_surface_releasedc(struct wined3d_surface *surface, HDC dc)
surface->resource.map_count--; surface->resource.map_count--;
surface->flags &= ~SFLAG_DCINUSE; surface->flags &= ~SFLAG_DCINUSE;
if (surface->map_binding == SFLAG_INUSERMEM) if (surface->map_binding == WINED3D_LOCATION_USER_MEMORY)
surface_load_location(surface, SFLAG_INUSERMEM); surface_load_location(surface, WINED3D_LOCATION_USER_MEMORY);
return WINED3D_OK; return WINED3D_OK;
} }
@ -3978,8 +3979,8 @@ static void fb_copy_to_texture_direct(struct wined3d_surface *dst_surface, struc
/* The texture is now most up to date - If the surface is a render target /* The texture is now most up to date - If the surface is a render target
* and has a drawable, this path is never entered. */ * and has a drawable, this path is never entered. */
surface_validate_location(dst_surface, SFLAG_INTEXTURE); surface_validate_location(dst_surface, WINED3D_LOCATION_TEXTURE_RGB);
surface_invalidate_location(dst_surface, ~SFLAG_INTEXTURE); surface_invalidate_location(dst_surface, ~WINED3D_LOCATION_TEXTURE_RGB);
} }
/* Uses the hardware to stretch and flip the image */ /* Uses the hardware to stretch and flip the image */
@ -4047,7 +4048,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_surface *dst_surface, st
checkGLcall("glEnable(texture_target)"); checkGLcall("glEnable(texture_target)");
/* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */ /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
src_surface->locations &= ~SFLAG_INTEXTURE; src_surface->locations &= ~WINED3D_LOCATION_TEXTURE_RGB;
} }
/* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
@ -4251,8 +4252,8 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_surface *dst_surface, st
/* The texture is now most up to date - If the surface is a render target /* The texture is now most up to date - If the surface is a render target
* and has a drawable, this path is never entered. */ * and has a drawable, this path is never entered. */
surface_validate_location(dst_surface, SFLAG_INTEXTURE); surface_validate_location(dst_surface, WINED3D_LOCATION_TEXTURE_RGB);
surface_invalidate_location(dst_surface, ~SFLAG_INTEXTURE); surface_invalidate_location(dst_surface, ~WINED3D_LOCATION_TEXTURE_RGB);
} }
/* Front buffer coordinates are always full screen coordinates, but our GL /* Front buffer coordinates are always full screen coordinates, but our GL
@ -4618,8 +4619,8 @@ void surface_modify_ds_location(struct wined3d_surface *surface,
{ {
TRACE("surface %p, new location %#x, w %u, h %u.\n", surface, location, w, h); TRACE("surface %p, new location %#x, w %u, h %u.\n", surface, location, w, h);
if (((surface->locations & SFLAG_INTEXTURE) && !(location & SFLAG_INTEXTURE)) if (((surface->locations & WINED3D_LOCATION_TEXTURE_RGB) && !(location & WINED3D_LOCATION_TEXTURE_RGB))
|| (!(surface->locations & SFLAG_INTEXTURE) && (location & SFLAG_INTEXTURE))) || (!(surface->locations & WINED3D_LOCATION_TEXTURE_RGB) && (location & WINED3D_LOCATION_TEXTURE_RGB)))
wined3d_texture_set_dirty(surface->container); wined3d_texture_set_dirty(surface->container);
surface->ds_current_size.cx = w; surface->ds_current_size.cx = w;
@ -4665,24 +4666,24 @@ void surface_load_ds_location(struct wined3d_surface *surface, struct wined3d_co
return; return;
} }
if (surface->locations & SFLAG_DISCARDED) if (surface->locations & WINED3D_LOCATION_DISCARDED)
{ {
TRACE("Surface was discarded, no need copy data.\n"); TRACE("Surface was discarded, no need copy data.\n");
switch (location) switch (location)
{ {
case SFLAG_INTEXTURE: case WINED3D_LOCATION_TEXTURE_RGB:
surface_prepare_texture(surface, context, FALSE); surface_prepare_texture(surface, context, FALSE);
break; break;
case SFLAG_INRB_MULTISAMPLE: case WINED3D_LOCATION_RB_MULTISAMPLE:
surface_prepare_rb(surface, gl_info, TRUE); surface_prepare_rb(surface, gl_info, TRUE);
break; break;
case SFLAG_INDRAWABLE: case WINED3D_LOCATION_DRAWABLE:
/* Nothing to do */ /* Nothing to do */
break; break;
default: default:
FIXME("Unhandled location %#x\n", location); FIXME("Unhandled location %#x\n", location);
} }
surface->locations &= ~SFLAG_DISCARDED; surface->locations &= ~WINED3D_LOCATION_DISCARDED;
surface->locations |= location; surface->locations |= location;
surface->ds_current_size.cx = surface->resource.width; surface->ds_current_size.cx = surface->resource.width;
surface->ds_current_size.cy = surface->resource.height; surface->ds_current_size.cy = surface->resource.height;
@ -4698,7 +4699,7 @@ void surface_load_ds_location(struct wined3d_surface *surface, struct wined3d_co
return; return;
} }
if (location == SFLAG_INTEXTURE) if (location == WINED3D_LOCATION_TEXTURE_RGB)
{ {
GLint old_binding = 0; GLint old_binding = 0;
GLenum bind_target; GLenum bind_target;
@ -4718,7 +4719,7 @@ void surface_load_ds_location(struct wined3d_surface *surface, struct wined3d_co
/* Note that we use depth_blt here as well, rather than glCopyTexImage2D /* Note that we use depth_blt here as well, rather than glCopyTexImage2D
* directly on the FBO texture. That's because we need to flip. */ * directly on the FBO texture. That's because we need to flip. */
context_apply_fbo_state_blit(context, GL_FRAMEBUFFER, context_apply_fbo_state_blit(context, GL_FRAMEBUFFER,
context->swapchain->front_buffer, NULL, SFLAG_INDRAWABLE); context->swapchain->front_buffer, NULL, WINED3D_LOCATION_DRAWABLE);
if (surface->texture_target == GL_TEXTURE_RECTANGLE_ARB) if (surface->texture_target == GL_TEXTURE_RECTANGLE_ARB)
{ {
gl_info->gl_ops.gl.p_glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding); gl_info->gl_ops.gl.p_glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
@ -4747,7 +4748,7 @@ void surface_load_ds_location(struct wined3d_surface *surface, struct wined3d_co
gl_info->gl_ops.gl.p_glBindTexture(bind_target, old_binding); gl_info->gl_ops.gl.p_glBindTexture(bind_target, old_binding);
context_apply_fbo_state_blit(context, GL_FRAMEBUFFER, context_apply_fbo_state_blit(context, GL_FRAMEBUFFER,
NULL, surface, SFLAG_INTEXTURE); NULL, surface, WINED3D_LOCATION_TEXTURE_RGB);
context_set_draw_buffer(context, GL_NONE); context_set_draw_buffer(context, GL_NONE);
/* Do the actual blit */ /* Do the actual blit */
@ -4759,12 +4760,12 @@ void surface_load_ds_location(struct wined3d_surface *surface, struct wined3d_co
if (wined3d_settings.strict_draw_ordering) if (wined3d_settings.strict_draw_ordering)
gl_info->gl_ops.gl.p_glFlush(); /* Flush to ensure ordering across contexts. */ gl_info->gl_ops.gl.p_glFlush(); /* Flush to ensure ordering across contexts. */
} }
else if (location == SFLAG_INDRAWABLE) else if (location == WINED3D_LOCATION_DRAWABLE)
{ {
TRACE("Copying depth texture to onscreen depth buffer.\n"); TRACE("Copying depth texture to onscreen depth buffer.\n");
context_apply_fbo_state_blit(context, GL_FRAMEBUFFER, context_apply_fbo_state_blit(context, GL_FRAMEBUFFER,
context->swapchain->front_buffer, NULL, SFLAG_INDRAWABLE); context->swapchain->front_buffer, NULL, WINED3D_LOCATION_DRAWABLE);
surface_depth_blt(surface, context, surface->container->texture_rgb.name, surface_depth_blt(surface, context, surface->container->texture_rgb.name,
0, surface->pow2Height - h, w, h, surface->texture_target); 0, surface->pow2Height - h, w, h, surface->texture_target);
checkGLcall("depth_blt"); checkGLcall("depth_blt");
@ -4786,16 +4787,16 @@ void surface_load_ds_location(struct wined3d_surface *surface, struct wined3d_co
void surface_validate_location(struct wined3d_surface *surface, DWORD location) void surface_validate_location(struct wined3d_surface *surface, DWORD location)
{ {
TRACE("surface %p, location %s.\n", surface, debug_surflocation(location)); TRACE("surface %p, location %s.\n", surface, wined3d_debug_location(location));
surface->locations |= location; surface->locations |= location;
} }
void surface_invalidate_location(struct wined3d_surface *surface, DWORD location) void surface_invalidate_location(struct wined3d_surface *surface, DWORD location)
{ {
TRACE("surface %p, location %s.\n", surface, debug_surflocation(location)); TRACE("surface %p, location %s.\n", surface, wined3d_debug_location(location));
if (location & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) if (location & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
wined3d_texture_set_dirty(surface->container); wined3d_texture_set_dirty(surface->container);
surface->locations &= ~location; surface->locations &= ~location;
@ -4807,17 +4808,17 @@ static DWORD resource_access_from_location(DWORD location)
{ {
switch (location) switch (location)
{ {
case SFLAG_INSYSMEM: case WINED3D_LOCATION_SYSMEM:
case SFLAG_INUSERMEM: case WINED3D_LOCATION_USER_MEMORY:
case SFLAG_INDIB: case WINED3D_LOCATION_DIB:
case SFLAG_INBUFFER: case WINED3D_LOCATION_BUFFER:
return WINED3D_RESOURCE_ACCESS_CPU; return WINED3D_RESOURCE_ACCESS_CPU;
case SFLAG_INDRAWABLE: case WINED3D_LOCATION_DRAWABLE:
case SFLAG_INSRGBTEX: case WINED3D_LOCATION_TEXTURE_SRGB:
case SFLAG_INTEXTURE: case WINED3D_LOCATION_TEXTURE_RGB:
case SFLAG_INRB_MULTISAMPLE: case WINED3D_LOCATION_RB_MULTISAMPLE:
case SFLAG_INRB_RESOLVED: case WINED3D_LOCATION_RB_RESOLVED:
return WINED3D_RESOURCE_ACCESS_GPU; return WINED3D_RESOURCE_ACCESS_GPU;
default: default:
@ -4871,11 +4872,11 @@ static void surface_load_sysmem(struct wined3d_surface *surface,
return; return;
} }
if (surface->locations & (SFLAG_INRB_MULTISAMPLE | SFLAG_INRB_RESOLVED)) if (surface->locations & (WINED3D_LOCATION_RB_MULTISAMPLE | WINED3D_LOCATION_RB_RESOLVED))
surface_load_location(surface, SFLAG_INTEXTURE); surface_load_location(surface, WINED3D_LOCATION_TEXTURE_RGB);
/* Download the surface to system memory. */ /* Download the surface to system memory. */
if (surface->locations & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) if (surface->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
{ {
struct wined3d_device *device = surface->resource.device; struct wined3d_device *device = surface->resource.device;
struct wined3d_context *context; struct wined3d_context *context;
@ -4883,7 +4884,8 @@ static void surface_load_sysmem(struct wined3d_surface *surface,
/* TODO: Use already acquired context when possible. */ /* TODO: Use already acquired context when possible. */
context = context_acquire(device, NULL); context = context_acquire(device, NULL);
wined3d_texture_bind_and_dirtify(surface->container, context, !(surface->locations & SFLAG_INTEXTURE)); wined3d_texture_bind_and_dirtify(surface->container, context,
!(surface->locations & WINED3D_LOCATION_TEXTURE_RGB));
surface_download_data(surface, gl_info, dst_location); surface_download_data(surface, gl_info, dst_location);
context_release(context); context_release(context);
@ -4891,14 +4893,14 @@ static void surface_load_sysmem(struct wined3d_surface *surface,
return; return;
} }
if (surface->locations & SFLAG_INDRAWABLE) if (surface->locations & WINED3D_LOCATION_DRAWABLE)
{ {
read_from_framebuffer(surface, dst_location); read_from_framebuffer(surface, dst_location);
return; return;
} }
FIXME("Can't load surface %p with location flags %s into sysmem.\n", FIXME("Can't load surface %p with location flags %s into sysmem.\n",
surface, debug_surflocation(surface->locations)); surface, wined3d_debug_location(surface->locations));
} }
static HRESULT surface_load_drawable(struct wined3d_surface *surface, static HRESULT surface_load_drawable(struct wined3d_surface *surface,
@ -4908,12 +4910,12 @@ static HRESULT surface_load_drawable(struct wined3d_surface *surface,
if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && surface_is_offscreen(surface)) if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && surface_is_offscreen(surface))
{ {
ERR("Trying to load offscreen surface into SFLAG_INDRAWABLE.\n"); ERR("Trying to load offscreen surface into WINED3D_LOCATION_DRAWABLE.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
surface_get_rect(surface, NULL, &r); surface_get_rect(surface, NULL, &r);
surface_load_location(surface, SFLAG_INTEXTURE); surface_load_location(surface, WINED3D_LOCATION_TEXTURE_RGB);
surface_blt_to_drawable(surface->resource.device, surface_blt_to_drawable(surface->resource.device,
WINED3D_TEXF_POINT, FALSE, surface, &r, surface, &r); WINED3D_TEXF_POINT, FALSE, surface, &r, surface, &r);
@ -4935,38 +4937,38 @@ static HRESULT surface_load_texture(struct wined3d_surface *surface,
if (wined3d_settings.offscreen_rendering_mode != ORM_FBO if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
&& surface_is_offscreen(surface) && surface_is_offscreen(surface)
&& (surface->locations & SFLAG_INDRAWABLE)) && (surface->locations & WINED3D_LOCATION_DRAWABLE))
{ {
surface_load_fb_texture(surface, srgb); surface_load_fb_texture(surface, srgb);
return WINED3D_OK; return WINED3D_OK;
} }
if (surface->locations & (SFLAG_INSRGBTEX | SFLAG_INTEXTURE) if (surface->locations & (WINED3D_LOCATION_TEXTURE_SRGB | WINED3D_LOCATION_TEXTURE_RGB)
&& (surface->resource.format->flags & WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB) && (surface->resource.format->flags & WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB)
&& fbo_blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT, && fbo_blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
NULL, surface->resource.usage, surface->resource.pool, surface->resource.format, NULL, surface->resource.usage, surface->resource.pool, surface->resource.format,
NULL, surface->resource.usage, surface->resource.pool, surface->resource.format)) NULL, surface->resource.usage, surface->resource.pool, surface->resource.format))
{ {
if (srgb) if (srgb)
surface_blt_fbo(device, WINED3D_TEXF_POINT, surface, SFLAG_INTEXTURE, surface_blt_fbo(device, WINED3D_TEXF_POINT, surface, WINED3D_LOCATION_TEXTURE_RGB,
&src_rect, surface, SFLAG_INSRGBTEX, &src_rect); &src_rect, surface, WINED3D_LOCATION_TEXTURE_SRGB, &src_rect);
else else
surface_blt_fbo(device, WINED3D_TEXF_POINT, surface, SFLAG_INSRGBTEX, surface_blt_fbo(device, WINED3D_TEXF_POINT, surface, WINED3D_LOCATION_TEXTURE_SRGB,
&src_rect, surface, SFLAG_INTEXTURE, &src_rect); &src_rect, surface, WINED3D_LOCATION_TEXTURE_RGB, &src_rect);
return WINED3D_OK; return WINED3D_OK;
} }
if (surface->locations & (SFLAG_INRB_MULTISAMPLE | SFLAG_INRB_RESOLVED) if (surface->locations & (WINED3D_LOCATION_RB_MULTISAMPLE | WINED3D_LOCATION_RB_RESOLVED)
&& (!srgb || (surface->resource.format->flags & WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB)) && (!srgb || (surface->resource.format->flags & WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB))
&& fbo_blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT, && fbo_blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
NULL, surface->resource.usage, surface->resource.pool, surface->resource.format, NULL, surface->resource.usage, surface->resource.pool, surface->resource.format,
NULL, surface->resource.usage, surface->resource.pool, surface->resource.format)) NULL, surface->resource.usage, surface->resource.pool, surface->resource.format))
{ {
DWORD src_location = surface->locations & SFLAG_INRB_RESOLVED ? DWORD src_location = surface->locations & WINED3D_LOCATION_RB_RESOLVED ?
SFLAG_INRB_RESOLVED : SFLAG_INRB_MULTISAMPLE; WINED3D_LOCATION_RB_RESOLVED : WINED3D_LOCATION_RB_MULTISAMPLE;
DWORD dst_location = srgb ? SFLAG_INSRGBTEX : SFLAG_INTEXTURE; DWORD dst_location = srgb ? WINED3D_LOCATION_TEXTURE_SRGB : WINED3D_LOCATION_TEXTURE_RGB;
RECT rect = {0, 0, surface->resource.width, surface->resource.height}; RECT rect = {0, 0, surface->resource.width, surface->resource.height};
surface_blt_fbo(device, WINED3D_TEXF_POINT, surface, src_location, surface_blt_fbo(device, WINED3D_TEXF_POINT, surface, src_location,
@ -4982,7 +4984,8 @@ static HRESULT surface_load_texture(struct wined3d_surface *surface,
if (srgb) if (srgb)
{ {
if ((surface->locations & (SFLAG_INTEXTURE | surface->map_binding)) == SFLAG_INTEXTURE) if ((surface->locations & (WINED3D_LOCATION_TEXTURE_RGB | surface->map_binding))
== WINED3D_LOCATION_TEXTURE_RGB)
{ {
/* Performance warning... */ /* Performance warning... */
FIXME("Downloading RGB surface %p to reload it as sRGB.\n", surface); FIXME("Downloading RGB surface %p to reload it as sRGB.\n", surface);
@ -4992,7 +4995,8 @@ static HRESULT surface_load_texture(struct wined3d_surface *surface,
} }
else else
{ {
if ((surface->locations & (SFLAG_INSRGBTEX | surface->map_binding)) == SFLAG_INSRGBTEX) if ((surface->locations & (WINED3D_LOCATION_TEXTURE_SRGB | surface->map_binding))
== WINED3D_LOCATION_TEXTURE_SRGB)
{ {
/* Performance warning... */ /* Performance warning... */
FIXME("Downloading sRGB surface %p to reload it as RGB.\n", surface); FIXME("Downloading sRGB surface %p to reload it as RGB.\n", surface);
@ -5006,7 +5010,7 @@ static HRESULT surface_load_texture(struct wined3d_surface *surface,
WARN("Trying to load a texture from sysmem, but no simple location is valid.\n"); WARN("Trying to load a texture from sysmem, but no simple location is valid.\n");
/* Lets hope we get it from somewhere... */ /* Lets hope we get it from somewhere... */
surface_prepare_system_memory(surface); surface_prepare_system_memory(surface);
surface_load_location(surface, SFLAG_INSYSMEM); surface_load_location(surface, WINED3D_LOCATION_SYSMEM);
} }
/* TODO: Use already acquired context when possible. */ /* TODO: Use already acquired context when possible. */
@ -5033,9 +5037,9 @@ static HRESULT surface_load_texture(struct wined3d_surface *surface,
TRACE("Removing the pbo attached to surface %p.\n", surface); TRACE("Removing the pbo attached to surface %p.\n", surface);
if (surface->flags & SFLAG_DIBSECTION) if (surface->flags & SFLAG_DIBSECTION)
surface->map_binding = SFLAG_INDIB; surface->map_binding = WINED3D_LOCATION_DIB;
else else
surface->map_binding = SFLAG_INSYSMEM; surface->map_binding = WINED3D_LOCATION_SYSMEM;
surface_prepare_map_memory(surface); surface_prepare_map_memory(surface);
surface_load_location(surface, surface->map_binding); surface_load_location(surface, surface->map_binding);
@ -5099,11 +5103,12 @@ static void surface_multisample_resolve(struct wined3d_surface *surface)
{ {
RECT rect = {0, 0, surface->resource.width, surface->resource.height}; RECT rect = {0, 0, surface->resource.width, surface->resource.height};
if (!(surface->locations & SFLAG_INRB_MULTISAMPLE)) if (!(surface->locations & WINED3D_LOCATION_RB_MULTISAMPLE))
ERR("Trying to resolve multisampled surface %p, but location SFLAG_INRB_MULTISAMPLE not current.\n", surface); ERR("Trying to resolve multisampled surface %p, but location WINED3D_LOCATION_RB_MULTISAMPLE not current.\n",
surface);
surface_blt_fbo(surface->resource.device, WINED3D_TEXF_POINT, surface_blt_fbo(surface->resource.device, WINED3D_TEXF_POINT,
surface, SFLAG_INRB_MULTISAMPLE, &rect, surface, SFLAG_INRB_RESOLVED, &rect); surface, WINED3D_LOCATION_RB_MULTISAMPLE, &rect, surface, WINED3D_LOCATION_RB_RESOLVED, &rect);
} }
HRESULT surface_load_location(struct wined3d_surface *surface, DWORD location) HRESULT surface_load_location(struct wined3d_surface *surface, DWORD location)
@ -5112,18 +5117,18 @@ HRESULT surface_load_location(struct wined3d_surface *surface, DWORD location)
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
HRESULT hr; HRESULT hr;
TRACE("surface %p, location %s.\n", surface, debug_surflocation(location)); TRACE("surface %p, location %s.\n", surface, wined3d_debug_location(location));
if (surface->resource.usage & WINED3DUSAGE_DEPTHSTENCIL) if (surface->resource.usage & WINED3DUSAGE_DEPTHSTENCIL)
{ {
if (location == SFLAG_INTEXTURE && surface->locations & SFLAG_INDRAWABLE) if (location == WINED3D_LOCATION_TEXTURE_RGB && surface->locations & WINED3D_LOCATION_DRAWABLE)
{ {
struct wined3d_context *context = context_acquire(device, NULL); struct wined3d_context *context = context_acquire(device, NULL);
surface_load_ds_location(surface, context, location); surface_load_ds_location(surface, context, location);
context_release(context); context_release(context);
return WINED3D_OK; return WINED3D_OK;
} }
else if (location & surface->locations && surface->draw_binding != SFLAG_INDRAWABLE) else if (location & surface->locations && surface->draw_binding != WINED3D_LOCATION_DRAWABLE)
{ {
/* Already up to date, nothing to do. */ /* Already up to date, nothing to do. */
return WINED3D_OK; return WINED3D_OK;
@ -5131,7 +5136,7 @@ HRESULT surface_load_location(struct wined3d_surface *surface, DWORD location)
else else
{ {
FIXME("Unimplemented copy from %s to %s for depth/stencil buffers.\n", FIXME("Unimplemented copy from %s to %s for depth/stencil buffers.\n",
debug_surflocation(surface->locations), debug_surflocation(location)); wined3d_debug_location(surface->locations), wined3d_debug_location(location));
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
} }
@ -5159,25 +5164,25 @@ HRESULT surface_load_location(struct wined3d_surface *surface, DWORD location)
switch (location) switch (location)
{ {
case SFLAG_INDIB: case WINED3D_LOCATION_DIB:
case SFLAG_INUSERMEM: case WINED3D_LOCATION_USER_MEMORY:
case SFLAG_INSYSMEM: case WINED3D_LOCATION_SYSMEM:
case SFLAG_INBUFFER: case WINED3D_LOCATION_BUFFER:
surface_load_sysmem(surface, gl_info, location); surface_load_sysmem(surface, gl_info, location);
break; break;
case SFLAG_INDRAWABLE: case WINED3D_LOCATION_DRAWABLE:
if (FAILED(hr = surface_load_drawable(surface, gl_info))) if (FAILED(hr = surface_load_drawable(surface, gl_info)))
return hr; return hr;
break; break;
case SFLAG_INRB_RESOLVED: case WINED3D_LOCATION_RB_RESOLVED:
surface_multisample_resolve(surface); surface_multisample_resolve(surface);
break; break;
case SFLAG_INTEXTURE: case WINED3D_LOCATION_TEXTURE_RGB:
case SFLAG_INSRGBTEX: case WINED3D_LOCATION_TEXTURE_SRGB:
if (FAILED(hr = surface_load_texture(surface, gl_info, location == SFLAG_INSRGBTEX))) if (FAILED(hr = surface_load_texture(surface, gl_info, location == WINED3D_LOCATION_TEXTURE_SRGB)))
return hr; return hr;
break; break;
@ -5188,7 +5193,7 @@ HRESULT surface_load_location(struct wined3d_surface *surface, DWORD location)
surface_validate_location(surface, location); surface_validate_location(surface, location);
if (location != SFLAG_INSYSMEM && (surface->locations & SFLAG_INSYSMEM)) if (location != WINED3D_LOCATION_SYSMEM && (surface->locations & WINED3D_LOCATION_SYSMEM))
surface_evict_sysmem(surface); surface_evict_sysmem(surface);
return WINED3D_OK; return WINED3D_OK;
@ -6218,8 +6223,8 @@ HRESULT CDECL wined3d_surface_blt(struct wined3d_surface *dst_surface, const REC
TRACE("Color blit.\n"); TRACE("Color blit.\n");
/* Upload */ /* Upload */
if ((src_surface->locations & SFLAG_INSYSMEM) if ((src_surface->locations & WINED3D_LOCATION_SYSMEM)
&& !(dst_surface->locations & SFLAG_INSYSMEM)) && !(dst_surface->locations & WINED3D_LOCATION_SYSMEM))
{ {
if (scale) if (scale)
TRACE("Not doing upload because of scaling.\n"); TRACE("Not doing upload because of scaling.\n");
@ -6367,7 +6372,7 @@ static HRESULT surface_init(struct wined3d_surface *surface, struct wined3d_text
} }
surface_set_container(surface, container); surface_set_container(surface, container);
surface_validate_location(surface, SFLAG_INSYSMEM); surface_validate_location(surface, WINED3D_LOCATION_SYSMEM);
list_init(&surface->renderbuffers); list_init(&surface->renderbuffers);
list_init(&surface->overlays); list_init(&surface->overlays);
@ -6390,7 +6395,7 @@ static HRESULT surface_init(struct wined3d_surface *surface, struct wined3d_text
if (lockable && (desc->usage & WINED3DUSAGE_RENDERTARGET)) if (lockable && (desc->usage & WINED3DUSAGE_RENDERTARGET))
surface->flags |= SFLAG_DYNLOCK; surface->flags |= SFLAG_DYNLOCK;
surface->map_binding = SFLAG_INSYSMEM; surface->map_binding = WINED3D_LOCATION_SYSMEM;
/* Call the private setup routine */ /* Call the private setup routine */
hr = surface->surface_ops->surface_private_setup(surface); hr = surface->surface_ops->surface_private_setup(surface);
@ -6407,13 +6412,13 @@ static HRESULT surface_init(struct wined3d_surface *surface, struct wined3d_text
* after a wined3d_surface_getdc() call. */ * after a wined3d_surface_getdc() call. */
if ((desc->usage & WINED3DUSAGE_OWNDC) && !surface->hDC if ((desc->usage & WINED3DUSAGE_OWNDC) && !surface->hDC
&& SUCCEEDED(surface_create_dib_section(surface))) && SUCCEEDED(surface_create_dib_section(surface)))
surface->map_binding = SFLAG_INDIB; surface->map_binding = WINED3D_LOCATION_DIB;
if (surface->map_binding == SFLAG_INDIB) if (surface->map_binding == WINED3D_LOCATION_DIB)
{ {
wined3d_resource_free_sysmem(&surface->resource); wined3d_resource_free_sysmem(&surface->resource);
surface_validate_location(surface, SFLAG_INDIB); surface_validate_location(surface, WINED3D_LOCATION_DIB);
surface_invalidate_location(surface, SFLAG_INSYSMEM); surface_invalidate_location(surface, WINED3D_LOCATION_SYSMEM);
} }
return hr; return hr;

40
dlls/wined3d/swapchain.c
View File

@ -297,11 +297,11 @@ static void swapchain_blit(const struct wined3d_swapchain *swapchain,
if (gl_info->fbo_ops.glBlitFramebuffer && is_identity_fixup(backbuffer->resource.format->color_fixup)) if (gl_info->fbo_ops.glBlitFramebuffer && is_identity_fixup(backbuffer->resource.format->color_fixup))
{ {
DWORD location = SFLAG_INTEXTURE; DWORD location = WINED3D_LOCATION_TEXTURE_RGB;
if (backbuffer->resource.multisample_type) if (backbuffer->resource.multisample_type)
{ {
location = SFLAG_INRB_RESOLVED; location = WINED3D_LOCATION_RB_RESOLVED;
surface_load_location(backbuffer, location); surface_load_location(backbuffer, location);
} }
@ -309,7 +309,8 @@ static void swapchain_blit(const struct wined3d_swapchain *swapchain,
gl_info->gl_ops.gl.p_glReadBuffer(GL_COLOR_ATTACHMENT0); gl_info->gl_ops.gl.p_glReadBuffer(GL_COLOR_ATTACHMENT0);
context_check_fbo_status(context, GL_READ_FRAMEBUFFER); context_check_fbo_status(context, GL_READ_FRAMEBUFFER);
context_apply_fbo_state_blit(context, GL_DRAW_FRAMEBUFFER, swapchain->front_buffer, NULL, SFLAG_INDRAWABLE); context_apply_fbo_state_blit(context, GL_DRAW_FRAMEBUFFER, swapchain->front_buffer,
NULL, WINED3D_LOCATION_DRAWABLE);
context_set_draw_buffer(context, GL_BACK); context_set_draw_buffer(context, GL_BACK);
context_invalidate_state(context, STATE_FRAMEBUFFER); context_invalidate_state(context, STATE_FRAMEBUFFER);
@ -351,7 +352,8 @@ static void swapchain_blit(const struct wined3d_swapchain *swapchain,
if (is_complex_fixup(backbuffer->resource.format->color_fixup)) if (is_complex_fixup(backbuffer->resource.format->color_fixup))
gl_filter = GL_NEAREST; gl_filter = GL_NEAREST;
context_apply_fbo_state_blit(context2, GL_FRAMEBUFFER, swapchain->front_buffer, NULL, SFLAG_INDRAWABLE); context_apply_fbo_state_blit(context2, GL_FRAMEBUFFER, swapchain->front_buffer,
NULL, WINED3D_LOCATION_DRAWABLE);
context_bind_texture(context2, backbuffer->texture_target, backbuffer->container->texture_rgb.name); context_bind_texture(context2, backbuffer->texture_target, backbuffer->container->texture_rgb.name);
/* Set up the texture. The surface is not in a wined3d_texture /* Set up the texture. The surface is not in a wined3d_texture
@ -498,8 +500,8 @@ static void swapchain_gl_present(struct wined3d_swapchain *swapchain, const RECT
*/ */
if (!swapchain->render_to_fbo && render_to_fbo && wined3d_settings.offscreen_rendering_mode == ORM_FBO) if (!swapchain->render_to_fbo && render_to_fbo && wined3d_settings.offscreen_rendering_mode == ORM_FBO)
{ {
surface_load_location(back_buffer, SFLAG_INTEXTURE); surface_load_location(back_buffer, WINED3D_LOCATION_TEXTURE_RGB);
surface_invalidate_location(back_buffer, SFLAG_INDRAWABLE); surface_invalidate_location(back_buffer, WINED3D_LOCATION_DRAWABLE);
swapchain->render_to_fbo = TRUE; swapchain->render_to_fbo = TRUE;
swapchain_update_draw_bindings(swapchain); swapchain_update_draw_bindings(swapchain);
} }
@ -541,8 +543,8 @@ static void swapchain_gl_present(struct wined3d_swapchain *swapchain, const RECT
} }
} }
if (!swapchain->render_to_fbo && ((swapchain->front_buffer->locations & SFLAG_INSYSMEM) if (!swapchain->render_to_fbo && ((swapchain->front_buffer->locations & WINED3D_LOCATION_SYSMEM)
|| (back_buffer->locations & SFLAG_INSYSMEM))) || (back_buffer->locations & WINED3D_LOCATION_SYSMEM)))
{ {
/* Both memory copies of the surfaces are ok, flip them around too instead of dirtifying /* Both memory copies of the surfaces are ok, flip them around too instead of dirtifying
* Doesn't work with render_to_fbo because we're not flipping * Doesn't work with render_to_fbo because we're not flipping
@ -556,20 +558,20 @@ static void swapchain_gl_present(struct wined3d_swapchain *swapchain, const RECT
/* Tell the front buffer surface that is has been modified. However, /* Tell the front buffer surface that is has been modified. However,
* the other locations were preserved during that, so keep the flags. * the other locations were preserved during that, so keep the flags.
* This serves to update the emulated overlay, if any. */ * This serves to update the emulated overlay, if any. */
surface_validate_location(front, SFLAG_INDRAWABLE); surface_validate_location(front, WINED3D_LOCATION_DRAWABLE);
} }
else else
{ {
surface_validate_location(front, SFLAG_INDRAWABLE); surface_validate_location(front, WINED3D_LOCATION_DRAWABLE);
surface_invalidate_location(front, ~SFLAG_INDRAWABLE); surface_invalidate_location(front, ~WINED3D_LOCATION_DRAWABLE);
surface_validate_location(back_buffer, SFLAG_INDRAWABLE); surface_validate_location(back_buffer, WINED3D_LOCATION_DRAWABLE);
surface_invalidate_location(back_buffer, ~SFLAG_INDRAWABLE); surface_invalidate_location(back_buffer, ~WINED3D_LOCATION_DRAWABLE);
} }
} }
else else
{ {
surface_validate_location(swapchain->front_buffer, SFLAG_INDRAWABLE); surface_validate_location(swapchain->front_buffer, WINED3D_LOCATION_DRAWABLE);
surface_invalidate_location(swapchain->front_buffer, ~SFLAG_INDRAWABLE); surface_invalidate_location(swapchain->front_buffer, ~WINED3D_LOCATION_DRAWABLE);
/* If the swapeffect is DISCARD, the back buffer is undefined. That means the SYSMEM /* If the swapeffect is DISCARD, the back buffer is undefined. That means the SYSMEM
* and INTEXTURE copies can keep their old content if they have any defined content. * and INTEXTURE copies can keep their old content if they have any defined content.
* If the swapeffect is COPY, the content remains the same. If it is FLIP however, * If the swapeffect is COPY, the content remains the same. If it is FLIP however,
@ -587,7 +589,7 @@ static void swapchain_gl_present(struct wined3d_swapchain *swapchain, const RECT
if (swapchain->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL if (swapchain->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
|| fb->depth_stencil->flags & SFLAG_DISCARD) || fb->depth_stencil->flags & SFLAG_DISCARD)
{ {
surface_modify_ds_location(fb->depth_stencil, SFLAG_DISCARDED, surface_modify_ds_location(fb->depth_stencil, WINED3D_LOCATION_DISCARDED,
fb->depth_stencil->resource.width, fb->depth_stencil->resource.width,
fb->depth_stencil->resource.height); fb->depth_stencil->resource.height);
if (fb->depth_stencil == swapchain->device->onscreen_depth_stencil) if (fb->depth_stencil == swapchain->device->onscreen_depth_stencil)
@ -623,7 +625,7 @@ void x11_copy_to_screen(const struct wined3d_swapchain *swapchain, const RECT *r
TRACE("Copying surface %p to screen.\n", front); TRACE("Copying surface %p to screen.\n", front);
surface_load_location(front, SFLAG_INDIB); surface_load_location(front, WINED3D_LOCATION_DIB);
src_dc = front->hDC; src_dc = front->hDC;
window = swapchain->win_handle; window = swapchain->win_handle;
@ -846,8 +848,8 @@ static HRESULT swapchain_init(struct wined3d_swapchain *swapchain, struct wined3
surface_set_swapchain(swapchain->front_buffer, swapchain); surface_set_swapchain(swapchain->front_buffer, swapchain);
if (!(device->wined3d->flags & WINED3D_NO3D)) if (!(device->wined3d->flags & WINED3D_NO3D))
{ {
surface_validate_location(swapchain->front_buffer, SFLAG_INDRAWABLE); surface_validate_location(swapchain->front_buffer, WINED3D_LOCATION_DRAWABLE);
surface_invalidate_location(swapchain->front_buffer, ~SFLAG_INDRAWABLE); surface_invalidate_location(swapchain->front_buffer, ~WINED3D_LOCATION_DRAWABLE);
} }
/* MSDN says we're only allowed a single fullscreen swapchain per device, /* MSDN says we're only allowed a single fullscreen swapchain per device,

23
dlls/wined3d/utils.c
View File

@ -2794,22 +2794,6 @@ void dump_color_fixup_desc(struct color_fixup_desc fixup)
TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : ""); TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
} }
const char *debug_surflocation(DWORD flag) {
char buf[172];
buf[0] = 0;
if (flag & SFLAG_INSYSMEM) strcat(buf, " | SFLAG_INSYSMEM"); /* 17 */
if (flag & SFLAG_INDRAWABLE) strcat(buf, " | SFLAG_INDRAWABLE"); /* 19 */
if (flag & SFLAG_INTEXTURE) strcat(buf, " | SFLAG_INTEXTURE"); /* 18 */
if (flag & SFLAG_INSRGBTEX) strcat(buf, " | SFLAG_INSRGBTEX"); /* 18 */
if (flag & SFLAG_INRB_MULTISAMPLE) strcat(buf, " | SFLAG_INRB_MULTISAMPLE"); /* 25 */
if (flag & SFLAG_INRB_RESOLVED) strcat(buf, " | SFLAG_INRB_RESOLVED"); /* 22 */
if (flag & SFLAG_INUSERMEM) strcat(buf, " | SFLAG_INUSERMEM"); /* 18 */
if (flag & SFLAG_INDIB) strcat(buf, " | SFLAG_INDIB"); /* 14 */
if (flag & SFLAG_INBUFFER) strcat(buf, " | SFLAG_INBUFFER"); /* 17 */
return wine_dbg_sprintf("%s", buf[0] ? buf + 3 : "0");
}
BOOL is_invalid_op(const struct wined3d_state *state, int stage, BOOL is_invalid_op(const struct wined3d_state *state, int stage,
enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3) enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3)
{ {
@ -3792,15 +3776,20 @@ void wined3d_get_draw_rect(const struct wined3d_state *state, RECT *rect)
const char *wined3d_debug_location(DWORD location) const char *wined3d_debug_location(DWORD location)
{ {
char buf[200]; char buf[294];
buf[0] = '\0'; buf[0] = '\0';
#define LOCATION_TO_STR(u) if (location & u) { strcat(buf, " | "#u); location &= ~u; } #define LOCATION_TO_STR(u) if (location & u) { strcat(buf, " | "#u); location &= ~u; }
LOCATION_TO_STR(WINED3D_LOCATION_DISCARDED); LOCATION_TO_STR(WINED3D_LOCATION_DISCARDED);
LOCATION_TO_STR(WINED3D_LOCATION_SYSMEM); LOCATION_TO_STR(WINED3D_LOCATION_SYSMEM);
LOCATION_TO_STR(WINED3D_LOCATION_USER_MEMORY);
LOCATION_TO_STR(WINED3D_LOCATION_DIB);
LOCATION_TO_STR(WINED3D_LOCATION_BUFFER); LOCATION_TO_STR(WINED3D_LOCATION_BUFFER);
LOCATION_TO_STR(WINED3D_LOCATION_TEXTURE_RGB); LOCATION_TO_STR(WINED3D_LOCATION_TEXTURE_RGB);
LOCATION_TO_STR(WINED3D_LOCATION_TEXTURE_SRGB); LOCATION_TO_STR(WINED3D_LOCATION_TEXTURE_SRGB);
LOCATION_TO_STR(WINED3D_LOCATION_DRAWABLE);
LOCATION_TO_STR(WINED3D_LOCATION_RB_MULTISAMPLE);
LOCATION_TO_STR(WINED3D_LOCATION_RB_RESOLVED);
#undef LOCATION_TO_STR #undef LOCATION_TO_STR
if (location) FIXME("Unrecognized location flag(s) %#x.\n", location); if (location) FIXME("Unrecognized location flag(s) %#x.\n", location);

22
dlls/wined3d/wined3d_private.h
View File

@ -2119,9 +2119,14 @@ void wined3d_texture_set_dirty(struct wined3d_texture *texture) DECLSPEC_HIDDEN;
#define WINED3D_LOCATION_DISCARDED 0x00000001 #define WINED3D_LOCATION_DISCARDED 0x00000001
#define WINED3D_LOCATION_SYSMEM 0x00000002 #define WINED3D_LOCATION_SYSMEM 0x00000002
#define WINED3D_LOCATION_BUFFER 0x00000004 #define WINED3D_LOCATION_USER_MEMORY 0x00000004
#define WINED3D_LOCATION_TEXTURE_RGB 0x00000008 #define WINED3D_LOCATION_DIB 0x00000008
#define WINED3D_LOCATION_TEXTURE_SRGB 0x00000010 #define WINED3D_LOCATION_BUFFER 0x00000010
#define WINED3D_LOCATION_TEXTURE_RGB 0x00000020
#define WINED3D_LOCATION_TEXTURE_SRGB 0x00000040
#define WINED3D_LOCATION_DRAWABLE 0x00000080
#define WINED3D_LOCATION_RB_MULTISAMPLE 0x00000100
#define WINED3D_LOCATION_RB_RESOLVED 0x00000200
const char *wined3d_debug_location(DWORD location) DECLSPEC_HIDDEN; const char *wined3d_debug_location(DWORD location) DECLSPEC_HIDDEN;
@ -2295,16 +2300,6 @@ void flip_surface(struct wined3d_surface *front, struct wined3d_surface *back) D
#define SFLAG_DIBSECTION 0x00000400 /* Has a DIB section attached for GetDC. */ #define SFLAG_DIBSECTION 0x00000400 /* Has a DIB section attached for GetDC. */
#define SFLAG_ALLOCATED 0x00000800 /* A GL texture is allocated for this surface. */ #define SFLAG_ALLOCATED 0x00000800 /* A GL texture is allocated for this surface. */
#define SFLAG_SRGBALLOCATED 0x00001000 /* A sRGB GL texture is allocated for this surface. */ #define SFLAG_SRGBALLOCATED 0x00001000 /* A sRGB GL texture is allocated for this surface. */
#define SFLAG_INSYSMEM 0x00002000 /* The system memory copy is current. */
#define SFLAG_INUSERMEM 0x00004000 /* The user memory copy is current. */
#define SFLAG_INDIB 0x00008000 /* The DIB copy is current. */
#define SFLAG_INBUFFER 0x00010000 /* The PBO copy is current. */
#define SFLAG_INTEXTURE 0x00020000 /* The GL texture is current. */
#define SFLAG_INSRGBTEX 0x00040000 /* The GL sRGB texture is current. */
#define SFLAG_INDRAWABLE 0x00080000 /* The GL drawable is current. */
#define SFLAG_INRB_MULTISAMPLE 0x00100000 /* The multisample renderbuffer is current. */
#define SFLAG_INRB_RESOLVED 0x00200000 /* The resolved renderbuffer is current. */
#define SFLAG_DISCARDED 0x00400000 /* Surface was discarded, allocating new location is enough. */
/* In some conditions the surface memory must not be freed: /* In some conditions the surface memory must not be freed:
* SFLAG_CONVERTED: Converting the data back would take too long * SFLAG_CONVERTED: Converting the data back would take too long
@ -2652,7 +2647,6 @@ const char *debug_fbostatus(GLenum status) DECLSPEC_HIDDEN;
const char *debug_glerror(GLenum error) DECLSPEC_HIDDEN; const char *debug_glerror(GLenum error) DECLSPEC_HIDDEN;
const char *debug_d3dtop(enum wined3d_texture_op d3dtop) DECLSPEC_HIDDEN; const char *debug_d3dtop(enum wined3d_texture_op d3dtop) DECLSPEC_HIDDEN;
void dump_color_fixup_desc(struct color_fixup_desc fixup) DECLSPEC_HIDDEN; void dump_color_fixup_desc(struct color_fixup_desc fixup) DECLSPEC_HIDDEN;
const char *debug_surflocation(DWORD flag) DECLSPEC_HIDDEN;
BOOL is_invalid_op(const struct wined3d_state *state, int stage, BOOL is_invalid_op(const struct wined3d_state *state, int stage,
enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3) DECLSPEC_HIDDEN; enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3) DECLSPEC_HIDDEN;