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

wined3d: Move the "buffer_type_hint" field from struct wined3d_buffer to struct wined3d_buffer_gl. 

Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Henri Verbeet 2018-10-26 16:43:08 +03:30 committed by Alexandre Julliard
parent 15962381e2
commit 12b5c91485
3 changed files with 115 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

203
dlls/wined3d/buffer.c
View File

@ -133,9 +133,9 @@ void wined3d_buffer_invalidate_location(struct wined3d_buffer *buffer, DWORD loc
} }
/* Context activation is done by the caller. */ /* Context activation is done by the caller. */
static void buffer_bind(struct wined3d_buffer *buffer, struct wined3d_context *context) static void wined3d_buffer_gl_bind(struct wined3d_buffer_gl *buffer_gl, struct wined3d_context *context)
{ {
context_bind_bo(context, buffer->buffer_type_hint, buffer->buffer_object); context_bind_bo(context, buffer_gl->buffer_type_hint, buffer_gl->b.buffer_object);
} }
/* Context activation is done by the caller. */ /* Context activation is done by the caller. */
@ -194,14 +194,14 @@ static void buffer_destroy_buffer_object(struct wined3d_buffer *buffer, struct w
} }
/* Context activation is done by the caller. */ /* Context activation is done by the caller. */
static BOOL buffer_create_buffer_object(struct wined3d_buffer *buffer, struct wined3d_context *context) static BOOL wined3d_buffer_gl_create_buffer_object(struct wined3d_buffer_gl *buffer_gl, struct wined3d_context *context)
{ {
const struct wined3d_gl_info *gl_info = context->gl_info; const struct wined3d_gl_info *gl_info = context->gl_info;
GLenum gl_usage = GL_STATIC_DRAW; GLenum gl_usage = GL_STATIC_DRAW;
GLenum error; GLenum error;
TRACE("Creating an OpenGL buffer object for wined3d_buffer %p with usage %s.\n", TRACE("Creating an OpenGL buffer object for wined3d buffer %p with usage %s.\n",
buffer, debug_d3dusage(buffer->resource.usage)); buffer_gl, debug_d3dusage(buffer_gl->b.resource.usage));
/* Make sure that the gl error is cleared. Do not use checkGLcall /* Make sure that the gl error is cleared. Do not use checkGLcall
* here because checkGLcall just prints a fixme and continues. However, * here because checkGLcall just prints a fixme and continues. However,
@ -216,15 +216,15 @@ static BOOL buffer_create_buffer_object(struct wined3d_buffer *buffer, struct wi
* to be verified to check if the rhw and color values are in the correct * to be verified to check if the rhw and color values are in the correct
* format. */ * format. */
GL_EXTCALL(glGenBuffers(1, &buffer->buffer_object)); GL_EXTCALL(glGenBuffers(1, &buffer_gl->b.buffer_object));
error = gl_info->gl_ops.gl.p_glGetError(); error = gl_info->gl_ops.gl.p_glGetError();
if (!buffer->buffer_object || error != GL_NO_ERROR) if (!buffer_gl->b.buffer_object || error != GL_NO_ERROR)
{ {
ERR("Failed to create a BO with error %s (%#x).\n", debug_glerror(error), error); ERR("Failed to create a BO with error %s (%#x).\n", debug_glerror(error), error);
goto fail; goto fail;
} }
buffer_bind(buffer, context); wined3d_buffer_gl_bind(buffer_gl, context);
error = gl_info->gl_ops.gl.p_glGetError(); error = gl_info->gl_ops.gl.p_glGetError();
if (error != GL_NO_ERROR) if (error != GL_NO_ERROR)
{ {
@ -232,22 +232,24 @@ static BOOL buffer_create_buffer_object(struct wined3d_buffer *buffer, struct wi
goto fail; goto fail;
} }
if (buffer->resource.usage & WINED3DUSAGE_DYNAMIC) if (buffer_gl->b.resource.usage & WINED3DUSAGE_DYNAMIC)
{ {
TRACE("Buffer has WINED3DUSAGE_DYNAMIC set.\n"); TRACE("Buffer has WINED3DUSAGE_DYNAMIC set.\n");
gl_usage = GL_STREAM_DRAW_ARB; gl_usage = GL_STREAM_DRAW_ARB;
if (gl_info->supported[APPLE_FLUSH_BUFFER_RANGE]) if (gl_info->supported[APPLE_FLUSH_BUFFER_RANGE])
{ {
GL_EXTCALL(glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE)); GL_EXTCALL(glBufferParameteriAPPLE(buffer_gl->buffer_type_hint,
GL_EXTCALL(glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE)); GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE));
GL_EXTCALL(glBufferParameteriAPPLE(buffer_gl->buffer_type_hint,
GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE));
checkGLcall("glBufferParameteriAPPLE"); checkGLcall("glBufferParameteriAPPLE");
buffer->flags |= WINED3D_BUFFER_APPLESYNC; buffer_gl->b.flags |= WINED3D_BUFFER_APPLESYNC;
} }
/* No setup is needed here for GL_ARB_map_buffer_range. */ /* No setup is needed here for GL_ARB_map_buffer_range. */
} }
GL_EXTCALL(glBufferData(buffer->buffer_type_hint, buffer->resource.size, NULL, gl_usage)); GL_EXTCALL(glBufferData(buffer_gl->buffer_type_hint, buffer_gl->b.resource.size, NULL, gl_usage));
error = gl_info->gl_ops.gl.p_glGetError(); error = gl_info->gl_ops.gl.p_glGetError();
if (error != GL_NO_ERROR) if (error != GL_NO_ERROR)
{ {
@ -255,17 +257,17 @@ static BOOL buffer_create_buffer_object(struct wined3d_buffer *buffer, struct wi
goto fail; goto fail;
} }
buffer->buffer_object_usage = gl_usage; buffer_gl->b.buffer_object_usage = gl_usage;
buffer_invalidate_bo_range(buffer, 0, 0); buffer_invalidate_bo_range(&buffer_gl->b, 0, 0);
return TRUE; return TRUE;
fail: fail:
/* Clean up all BO init, but continue because we can work without a BO :-) */ /* Clean up all BO init, but continue because we can work without a BO :-) */
ERR("Failed to create a buffer object. Continuing, but performance issues may occur.\n"); ERR("Failed to create a buffer object. Continuing, but performance issues may occur.\n");
buffer->flags &= ~WINED3D_BUFFER_USE_BO; buffer_gl->b.flags &= ~WINED3D_BUFFER_USE_BO;
buffer_destroy_buffer_object(buffer, context); buffer_destroy_buffer_object(&buffer_gl->b, context);
buffer_clear_dirty_areas(buffer); buffer_clear_dirty_areas(&buffer_gl->b);
return FALSE; return FALSE;
} }
@ -532,18 +534,18 @@ ULONG CDECL wined3d_buffer_incref(struct wined3d_buffer *buffer)
} }
/* Context activation is done by the caller. */ /* Context activation is done by the caller. */
static void wined3d_buffer_upload_ranges(struct wined3d_buffer *buffer, struct wined3d_context *context, static void wined3d_buffer_gl_upload_ranges(struct wined3d_buffer_gl *buffer_gl, struct wined3d_context *context,
const void *data, unsigned int data_offset, unsigned int range_count, const struct wined3d_map_range *ranges) const void *data, unsigned int data_offset, unsigned int range_count, const struct wined3d_map_range *ranges)
{ {
const struct wined3d_gl_info *gl_info = context->gl_info; const struct wined3d_gl_info *gl_info = context->gl_info;
const struct wined3d_map_range *range; const struct wined3d_map_range *range;
buffer_bind(buffer, context); wined3d_buffer_gl_bind(buffer_gl, context);
while (range_count--) while (range_count--)
{ {
range = &ranges[range_count]; range = &ranges[range_count];
GL_EXTCALL(glBufferSubData(buffer->buffer_type_hint, GL_EXTCALL(glBufferSubData(buffer_gl->buffer_type_hint,
range->offset, range->size, (BYTE *)data + range->offset - data_offset)); range->offset, range->size, (BYTE *)data + range->offset - data_offset));
} }
checkGLcall("glBufferSubData"); checkGLcall("glBufferSubData");
@ -600,7 +602,8 @@ static void buffer_conversion_upload(struct wined3d_buffer *buffer, struct wined
} }
} }
wined3d_buffer_upload_ranges(buffer, context, data, 0, buffer->modified_areas, buffer->maps); wined3d_buffer_gl_upload_ranges(wined3d_buffer_gl(buffer),
context, data, 0, buffer->modified_areas, buffer->maps);
heap_free(data); heap_free(data);
} }
@ -627,7 +630,7 @@ static BOOL wined3d_buffer_prepare_location(struct wined3d_buffer *buffer,
WARN("Trying to create BO for buffer %p with no WINED3D_BUFFER_USE_BO.\n", buffer); WARN("Trying to create BO for buffer %p with no WINED3D_BUFFER_USE_BO.\n", buffer);
return FALSE; return FALSE;
} }
return buffer_create_buffer_object(buffer, context); return wined3d_buffer_gl_create_buffer_object(wined3d_buffer_gl(buffer), context);
default: default:
ERR("Invalid location %s.\n", wined3d_debug_location(location)); ERR("Invalid location %s.\n", wined3d_debug_location(location));
@ -638,6 +641,7 @@ static BOOL wined3d_buffer_prepare_location(struct wined3d_buffer *buffer,
BOOL wined3d_buffer_load_location(struct wined3d_buffer *buffer, BOOL wined3d_buffer_load_location(struct wined3d_buffer *buffer,
struct wined3d_context *context, DWORD location) struct wined3d_context *context, DWORD location)
{ {
struct wined3d_buffer_gl *buffer_gl = wined3d_buffer_gl(buffer);
const struct wined3d_gl_info *gl_info = context->gl_info; const struct wined3d_gl_info *gl_info = context->gl_info;
TRACE("buffer %p, context %p, location %s.\n", TRACE("buffer %p, context %p, location %s.\n",
@ -672,15 +676,15 @@ BOOL wined3d_buffer_load_location(struct wined3d_buffer *buffer,
switch (location) switch (location)
{ {
case WINED3D_LOCATION_SYSMEM: case WINED3D_LOCATION_SYSMEM:
buffer_bind(buffer, context); wined3d_buffer_gl_bind(buffer_gl, context);
GL_EXTCALL(glGetBufferSubData(buffer->buffer_type_hint, 0, buffer->resource.size, GL_EXTCALL(glGetBufferSubData(buffer_gl->buffer_type_hint, 0, buffer->resource.size,
buffer->resource.heap_memory)); buffer->resource.heap_memory));
checkGLcall("buffer download"); checkGLcall("buffer download");
break; break;
case WINED3D_LOCATION_BUFFER: case WINED3D_LOCATION_BUFFER:
if (!buffer->conversion_map) if (!buffer->conversion_map)
wined3d_buffer_upload_ranges(buffer, context, buffer->resource.heap_memory, wined3d_buffer_gl_upload_ranges(buffer_gl, context, buffer->resource.heap_memory,
0, buffer->modified_areas, buffer->maps); 0, buffer->modified_areas, buffer->maps);
else else
buffer_conversion_upload(buffer, context); buffer_conversion_upload(buffer, context);
@ -809,7 +813,8 @@ void * CDECL wined3d_buffer_get_parent(const struct wined3d_buffer *buffer)
} }
/* The caller provides a context and binds the buffer */ /* The caller provides a context and binds the buffer */
static void buffer_sync_apple(struct wined3d_buffer *buffer, DWORD flags, const struct wined3d_gl_info *gl_info) static void wined3d_buffer_gl_sync_apple(struct wined3d_buffer_gl *buffer_gl,
DWORD flags, const struct wined3d_gl_info *gl_info)
{ {
enum wined3d_fence_result ret; enum wined3d_fence_result ret;
HRESULT hr; HRESULT hr;
@ -821,16 +826,17 @@ static void buffer_sync_apple(struct wined3d_buffer *buffer, DWORD flags, const
if (flags & WINED3D_MAP_DISCARD) if (flags & WINED3D_MAP_DISCARD)
{ {
GL_EXTCALL(glBufferData(buffer->buffer_type_hint, buffer->resource.size, NULL, buffer->buffer_object_usage)); GL_EXTCALL(glBufferData(buffer_gl->buffer_type_hint, buffer_gl->b.resource.size,
NULL, buffer_gl->b.buffer_object_usage));
checkGLcall("glBufferData"); checkGLcall("glBufferData");
return; return;
} }
if (!buffer->fence) if (!buffer_gl->b.fence)
{ {
TRACE("Creating fence for buffer %p.\n", buffer); TRACE("Creating fence for buffer %p.\n", buffer_gl);
if (FAILED(hr = wined3d_fence_create(buffer->resource.device, &buffer->fence))) if (FAILED(hr = wined3d_fence_create(buffer_gl->b.resource.device, &buffer_gl->b.fence)))
{ {
if (hr == WINED3DERR_NOTAVAILABLE) if (hr == WINED3DERR_NOTAVAILABLE)
FIXME("Fences not supported, dropping async buffer locks.\n"); FIXME("Fences not supported, dropping async buffer locks.\n");
@ -844,8 +850,8 @@ static void buffer_sync_apple(struct wined3d_buffer *buffer, DWORD flags, const
return; return;
} }
TRACE("Synchronizing buffer %p.\n", buffer); TRACE("Synchronizing buffer %p.\n", buffer_gl);
ret = wined3d_fence_wait(buffer->fence, buffer->resource.device); ret = wined3d_fence_wait(buffer_gl->b.fence, buffer_gl->b.resource.device);
switch (ret) switch (ret)
{ {
case WINED3D_FENCE_NOT_STARTED: case WINED3D_FENCE_NOT_STARTED:
@ -863,16 +869,16 @@ static void buffer_sync_apple(struct wined3d_buffer *buffer, DWORD flags, const
} }
drop_fence: drop_fence:
if (buffer->fence) if (buffer_gl->b.fence)
{ {
wined3d_fence_destroy(buffer->fence); wined3d_fence_destroy(buffer_gl->b.fence);
buffer->fence = NULL; buffer_gl->b.fence = NULL;
} }
gl_info->gl_ops.gl.p_glFinish(); gl_info->gl_ops.gl.p_glFinish();
GL_EXTCALL(glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE)); GL_EXTCALL(glBufferParameteriAPPLE(buffer_gl->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE));
checkGLcall("glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE)"); checkGLcall("glBufferParameteriAPPLE(buffer_gl->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE)");
buffer->flags &= ~WINED3D_BUFFER_APPLESYNC; buffer_gl->b.flags &= ~WINED3D_BUFFER_APPLESYNC;
} }
static void buffer_mark_used(struct wined3d_buffer *buffer) static void buffer_mark_used(struct wined3d_buffer *buffer)
@ -996,18 +1002,19 @@ struct wined3d_resource * CDECL wined3d_buffer_get_resource(struct wined3d_buffe
return &buffer->resource; return &buffer->resource;
} }
static HRESULT wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UINT size, BYTE **data, DWORD flags) static HRESULT wined3d_buffer_gl_map(struct wined3d_buffer_gl *buffer_gl,
unsigned int offset, unsigned int size, BYTE **data, DWORD flags)
{ {
struct wined3d_device *device = buffer->resource.device; struct wined3d_device *device = buffer_gl->b.resource.device;
struct wined3d_context *context; struct wined3d_context *context;
LONG count; LONG count;
BYTE *base; BYTE *base;
TRACE("buffer %p, offset %u, size %u, data %p, flags %#x.\n", buffer, offset, size, data, flags); TRACE("buffer_gl %p, offset %u, size %u, data %p, flags %#x.\n", buffer_gl, offset, size, data, flags);
count = ++buffer->resource.map_count; count = ++buffer_gl->b.resource.map_count;
if (buffer->buffer_object) if (buffer_gl->b.buffer_object)
{ {
unsigned int dirty_offset = offset, dirty_size = size; unsigned int dirty_offset = offset, dirty_size = size;
@ -1022,18 +1029,18 @@ static HRESULT wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UI
} }
if (((flags & WINED3D_MAP_WRITE) && !(flags & (WINED3D_MAP_NOOVERWRITE | WINED3D_MAP_DISCARD))) if (((flags & WINED3D_MAP_WRITE) && !(flags & (WINED3D_MAP_NOOVERWRITE | WINED3D_MAP_DISCARD)))
|| (!(flags & WINED3D_MAP_WRITE) && (buffer->locations & WINED3D_LOCATION_SYSMEM)) || (!(flags & WINED3D_MAP_WRITE) && (buffer_gl->b.locations & WINED3D_LOCATION_SYSMEM))
|| buffer->flags & WINED3D_BUFFER_PIN_SYSMEM) || buffer_gl->b.flags & WINED3D_BUFFER_PIN_SYSMEM)
{ {
if (!(buffer->locations & WINED3D_LOCATION_SYSMEM)) if (!(buffer_gl->b.locations & WINED3D_LOCATION_SYSMEM))
{ {
context = context_acquire(device, NULL, 0); context = context_acquire(device, NULL, 0);
wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM); wined3d_buffer_load_location(&buffer_gl->b, context, WINED3D_LOCATION_SYSMEM);
context_release(context); context_release(context);
} }
if (flags & WINED3D_MAP_WRITE) if (flags & WINED3D_MAP_WRITE)
wined3d_buffer_invalidate_range(buffer, WINED3D_LOCATION_BUFFER, dirty_offset, dirty_size); wined3d_buffer_invalidate_range(&buffer_gl->b, WINED3D_LOCATION_BUFFER, dirty_offset, dirty_size);
} }
else else
{ {
@ -1043,19 +1050,19 @@ static HRESULT wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UI
gl_info = context->gl_info; gl_info = context->gl_info;
if (flags & WINED3D_MAP_DISCARD) if (flags & WINED3D_MAP_DISCARD)
wined3d_buffer_validate_location(buffer, WINED3D_LOCATION_BUFFER); wined3d_buffer_validate_location(&buffer_gl->b, WINED3D_LOCATION_BUFFER);
else else
wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER); wined3d_buffer_load_location(&buffer_gl->b, context, WINED3D_LOCATION_BUFFER);
if (flags & WINED3D_MAP_WRITE) if (flags & WINED3D_MAP_WRITE)
buffer_invalidate_bo_range(buffer, dirty_offset, dirty_size); buffer_invalidate_bo_range(&buffer_gl->b, dirty_offset, dirty_size);
if ((flags & WINED3D_MAP_DISCARD) && buffer->resource.heap_memory) if ((flags & WINED3D_MAP_DISCARD) && buffer_gl->b.resource.heap_memory)
wined3d_buffer_evict_sysmem(buffer); wined3d_buffer_evict_sysmem(&buffer_gl->b);
if (count == 1) if (count == 1)
{ {
buffer_bind(buffer, context); wined3d_buffer_gl_bind(buffer_gl, context);
/* Filter redundant WINED3D_MAP_DISCARD maps. The 3DMark2001 /* Filter redundant WINED3D_MAP_DISCARD maps. The 3DMark2001
* multitexture fill rate test seems to depend on this. When * multitexture fill rate test seems to depend on this. When
@ -1064,49 +1071,49 @@ static HRESULT wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UI
* buffer. The r600g driver only does this when the buffer is * buffer. The r600g driver only does this when the buffer is
* currently in use, while the proprietary NVIDIA driver * currently in use, while the proprietary NVIDIA driver
* appears to do this unconditionally. */ * appears to do this unconditionally. */
if (buffer->flags & WINED3D_BUFFER_DISCARD) if (buffer_gl->b.flags & WINED3D_BUFFER_DISCARD)
flags &= ~WINED3D_MAP_DISCARD; flags &= ~WINED3D_MAP_DISCARD;
if (gl_info->supported[ARB_MAP_BUFFER_RANGE]) if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
{ {
GLbitfield mapflags = wined3d_resource_gl_map_flags(flags); GLbitfield mapflags = wined3d_resource_gl_map_flags(flags);
buffer->map_ptr = GL_EXTCALL(glMapBufferRange(buffer->buffer_type_hint, buffer_gl->b.map_ptr = GL_EXTCALL(glMapBufferRange(buffer_gl->buffer_type_hint,
0, buffer->resource.size, mapflags)); 0, buffer_gl->b.resource.size, mapflags));
checkGLcall("glMapBufferRange"); checkGLcall("glMapBufferRange");
} }
else else
{ {
if (buffer->flags & WINED3D_BUFFER_APPLESYNC) if (buffer_gl->b.flags & WINED3D_BUFFER_APPLESYNC)
buffer_sync_apple(buffer, flags, gl_info); wined3d_buffer_gl_sync_apple(buffer_gl, flags, gl_info);
buffer->map_ptr = GL_EXTCALL(glMapBuffer(buffer->buffer_type_hint, buffer_gl->b.map_ptr = GL_EXTCALL(glMapBuffer(buffer_gl->buffer_type_hint,
GL_READ_WRITE)); GL_READ_WRITE));
checkGLcall("glMapBuffer"); checkGLcall("glMapBuffer");
} }
if (((DWORD_PTR)buffer->map_ptr) & (RESOURCE_ALIGNMENT - 1)) if (((DWORD_PTR)buffer_gl->b.map_ptr) & (RESOURCE_ALIGNMENT - 1))
{ {
WARN("Pointer %p is not %u byte aligned.\n", buffer->map_ptr, RESOURCE_ALIGNMENT); WARN("Pointer %p is not %u byte aligned.\n", buffer_gl->b.map_ptr, RESOURCE_ALIGNMENT);
GL_EXTCALL(glUnmapBuffer(buffer->buffer_type_hint)); GL_EXTCALL(glUnmapBuffer(buffer_gl->buffer_type_hint));
checkGLcall("glUnmapBuffer"); checkGLcall("glUnmapBuffer");
buffer->map_ptr = NULL; buffer_gl->b.map_ptr = NULL;
if (buffer->resource.usage & WINED3DUSAGE_DYNAMIC) if (buffer_gl->b.resource.usage & WINED3DUSAGE_DYNAMIC)
{ {
/* The extra copy is more expensive than not using VBOs at /* The extra copy is more expensive than not using VBOs at
* all on the Nvidia Linux driver, which is the only driver * all on the Nvidia Linux driver, which is the only driver
* that returns unaligned pointers. * that returns unaligned pointers.
*/ */
TRACE("Dynamic buffer, dropping VBO.\n"); TRACE("Dynamic buffer, dropping VBO.\n");
wined3d_buffer_drop_bo(buffer); wined3d_buffer_drop_bo(&buffer_gl->b);
} }
else else
{ {
TRACE("Falling back to doublebuffered operation.\n"); TRACE("Falling back to doublebuffered operation.\n");
wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM); wined3d_buffer_load_location(&buffer_gl->b, context, WINED3D_LOCATION_SYSMEM);
buffer->flags |= WINED3D_BUFFER_PIN_SYSMEM; buffer_gl->b.flags |= WINED3D_BUFFER_PIN_SYSMEM;
} }
TRACE("New pointer is %p.\n", buffer->resource.heap_memory); TRACE("New pointer is %p.\n", buffer_gl->b.resource.heap_memory);
} }
} }
@ -1114,10 +1121,10 @@ static HRESULT wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UI
} }
if (flags & WINED3D_MAP_DISCARD) if (flags & WINED3D_MAP_DISCARD)
buffer->flags |= WINED3D_BUFFER_DISCARD; buffer_gl->b.flags |= WINED3D_BUFFER_DISCARD;
} }
base = buffer->map_ptr ? buffer->map_ptr : buffer->resource.heap_memory; base = buffer_gl->b.map_ptr ? buffer_gl->b.map_ptr : buffer_gl->b.resource.heap_memory;
*data = base + offset; *data = base + offset;
TRACE("Returning memory at %p (base %p, offset %u).\n", *data, base, offset); TRACE("Returning memory at %p (base %p, offset %u).\n", *data, base, offset);
@ -1126,64 +1133,64 @@ static HRESULT wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UI
return WINED3D_OK; return WINED3D_OK;
} }
static void wined3d_buffer_unmap(struct wined3d_buffer *buffer) static void wined3d_buffer_gl_unmap(struct wined3d_buffer_gl *buffer_gl)
{ {
ULONG i; ULONG i;
TRACE("buffer %p.\n", buffer); TRACE("buffer_gl %p.\n", buffer_gl);
/* In the case that the number of Unmap calls > the /* In the case that the number of Unmap calls > the
* number of Map calls, d3d returns always D3D_OK. * number of Map calls, d3d returns always D3D_OK.
* This is also needed to prevent Map from returning garbage on * This is also needed to prevent Map from returning garbage on
* the next call (this will happen if the lock_count is < 0). */ * the next call (this will happen if the lock_count is < 0). */
if (!buffer->resource.map_count) if (!buffer_gl->b.resource.map_count)
{ {
WARN("Unmap called without a previous map call.\n"); WARN("Unmap called without a previous map call.\n");
return; return;
} }
if (--buffer->resource.map_count) if (--buffer_gl->b.resource.map_count)
{ {
/* Delay loading the buffer until everything is unlocked */ /* Delay loading the buffer until everything is unlocked */
TRACE("Ignoring unmap.\n"); TRACE("Ignoring unmap.\n");
return; return;
} }
if (buffer->map_ptr) if (buffer_gl->b.map_ptr)
{ {
struct wined3d_device *device = buffer->resource.device; struct wined3d_device *device = buffer_gl->b.resource.device;
const struct wined3d_gl_info *gl_info; const struct wined3d_gl_info *gl_info;
struct wined3d_context *context; struct wined3d_context *context;
context = context_acquire(device, NULL, 0); context = context_acquire(device, NULL, 0);
gl_info = context->gl_info; gl_info = context->gl_info;
buffer_bind(buffer, context); wined3d_buffer_gl_bind(buffer_gl, context);
if (gl_info->supported[ARB_MAP_BUFFER_RANGE]) if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
{ {
for (i = 0; i < buffer->modified_areas; ++i) for (i = 0; i < buffer_gl->b.modified_areas; ++i)
{ {
GL_EXTCALL(glFlushMappedBufferRange(buffer->buffer_type_hint, GL_EXTCALL(glFlushMappedBufferRange(buffer_gl->buffer_type_hint,
buffer->maps[i].offset, buffer->maps[i].size)); buffer_gl->b.maps[i].offset, buffer_gl->b.maps[i].size));
checkGLcall("glFlushMappedBufferRange"); checkGLcall("glFlushMappedBufferRange");
} }
} }
else if (buffer->flags & WINED3D_BUFFER_APPLESYNC) else if (buffer_gl->b.flags & WINED3D_BUFFER_APPLESYNC)
{ {
for (i = 0; i < buffer->modified_areas; ++i) for (i = 0; i < buffer_gl->b.modified_areas; ++i)
{ {
GL_EXTCALL(glFlushMappedBufferRangeAPPLE(buffer->buffer_type_hint, GL_EXTCALL(glFlushMappedBufferRangeAPPLE(buffer_gl->buffer_type_hint,
buffer->maps[i].offset, buffer->maps[i].size)); buffer_gl->b.maps[i].offset, buffer_gl->b.maps[i].size));
checkGLcall("glFlushMappedBufferRangeAPPLE"); checkGLcall("glFlushMappedBufferRangeAPPLE");
} }
} }
GL_EXTCALL(glUnmapBuffer(buffer->buffer_type_hint)); GL_EXTCALL(glUnmapBuffer(buffer_gl->buffer_type_hint));
context_release(context); context_release(context);
buffer_clear_dirty_areas(buffer); buffer_clear_dirty_areas(&buffer_gl->b);
buffer->map_ptr = NULL; buffer_gl->b.map_ptr = NULL;
} }
} }
@ -1204,8 +1211,8 @@ void wined3d_buffer_copy(struct wined3d_buffer *dst_buffer, unsigned int dst_off
src.addr += src_offset; src.addr += src_offset;
context = context_acquire(dst_buffer->resource.device, NULL, 0); context = context_acquire(dst_buffer->resource.device, NULL, 0);
context_copy_bo_address(context, &dst, dst_buffer->buffer_type_hint, context_copy_bo_address(context, &dst, wined3d_buffer_gl(dst_buffer)->buffer_type_hint,
&src, src_buffer->buffer_type_hint, size); &src, wined3d_buffer_gl(src_buffer)->buffer_type_hint, size);
context_release(context); context_release(context);
wined3d_buffer_invalidate_range(dst_buffer, ~dst_location, dst_offset, size); wined3d_buffer_invalidate_range(dst_buffer, ~dst_location, dst_offset, size);
@ -1227,7 +1234,7 @@ void wined3d_buffer_upload_data(struct wined3d_buffer *buffer, struct wined3d_co
range.size = buffer->resource.size; range.size = buffer->resource.size;
} }
wined3d_buffer_upload_ranges(buffer, context, data, range.offset, 1, &range); wined3d_buffer_gl_upload_ranges(wined3d_buffer_gl(buffer), context, data, range.offset, 1, &range);
} }
static void wined3d_buffer_init_data(struct wined3d_buffer *buffer, static void wined3d_buffer_init_data(struct wined3d_buffer *buffer,
@ -1274,7 +1281,7 @@ static void buffer_resource_preload(struct wined3d_resource *resource)
static HRESULT buffer_resource_sub_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx, static HRESULT buffer_resource_sub_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx,
struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags) struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags)
{ {
struct wined3d_buffer *buffer = buffer_from_resource(resource); struct wined3d_buffer_gl *buffer_gl = wined3d_buffer_gl(buffer_from_resource(resource));
UINT offset, size; UINT offset, size;
if (sub_resource_idx) if (sub_resource_idx)
@ -1293,8 +1300,8 @@ static HRESULT buffer_resource_sub_resource_map(struct wined3d_resource *resourc
offset = size = 0; offset = size = 0;
} }
map_desc->row_pitch = map_desc->slice_pitch = buffer->desc.byte_width; map_desc->row_pitch = map_desc->slice_pitch = buffer_gl->b.desc.byte_width;
return wined3d_buffer_map(buffer, offset, size, (BYTE **)&map_desc->data, flags); return wined3d_buffer_gl_map(buffer_gl, offset, size, (BYTE **)&map_desc->data, flags);
} }
static HRESULT buffer_resource_sub_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx) static HRESULT buffer_resource_sub_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx)
@ -1305,7 +1312,7 @@ static HRESULT buffer_resource_sub_resource_unmap(struct wined3d_resource *resou
return E_INVALIDARG; return E_INVALIDARG;
} }
wined3d_buffer_unmap(buffer_from_resource(resource)); wined3d_buffer_gl_unmap(wined3d_buffer_gl(buffer_from_resource(resource)));
return WINED3D_OK; return WINED3D_OK;
} }
@ -1377,7 +1384,6 @@ static HRESULT wined3d_buffer_init(struct wined3d_buffer *buffer, struct wined3d
return hr; return hr;
} }
buffer->desc = *desc; buffer->desc = *desc;
buffer->buffer_type_hint = buffer_type_hint_from_bind_flags(gl_info, desc->bind_flags);
buffer->bind_flags = desc->bind_flags; buffer->bind_flags = desc->bind_flags;
buffer->locations = data ? WINED3D_LOCATION_DISCARDED : WINED3D_LOCATION_SYSMEM; buffer->locations = data ? WINED3D_LOCATION_DISCARDED : WINED3D_LOCATION_SYSMEM;
@ -1444,6 +1450,7 @@ HRESULT CDECL wined3d_buffer_create(struct wined3d_device *device, const struct
const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops, const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops,
struct wined3d_buffer **buffer) struct wined3d_buffer **buffer)
{ {
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
struct wined3d_buffer_gl *object; struct wined3d_buffer_gl *object;
HRESULT hr; HRESULT hr;
@ -1456,6 +1463,8 @@ HRESULT CDECL wined3d_buffer_create(struct wined3d_device *device, const struct
if (!(object = heap_alloc_zero(sizeof(*object)))) if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
object->buffer_type_hint = buffer_type_hint_from_bind_flags(gl_info, desc->bind_flags);
if (FAILED(hr = wined3d_buffer_init(&object->b, device, desc, data, parent, parent_ops))) if (FAILED(hr = wined3d_buffer_init(&object->b, device, desc, data, parent, parent_ops)))
{ {
WARN("Failed to initialize buffer, hr %#x.\n", hr); WARN("Failed to initialize buffer, hr %#x.\n", hr);

14
dlls/wined3d/view.c
View File

@ -1023,8 +1023,8 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi
{ {
const struct wined3d_gl_info *gl_info = context->gl_info; const struct wined3d_gl_info *gl_info = context->gl_info;
const struct wined3d_format_gl *format; const struct wined3d_format_gl *format;
struct wined3d_buffer_gl *buffer_gl;
struct wined3d_resource *resource; struct wined3d_resource *resource;
struct wined3d_buffer *buffer;
unsigned int offset, size; unsigned int offset, size;
resource = view->resource; resource = view->resource;
@ -1049,13 +1049,13 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi
return; return;
} }
buffer = buffer_from_resource(resource); buffer_gl = wined3d_buffer_gl(buffer_from_resource(resource));
wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER); wined3d_buffer_load_location(&buffer_gl->b, context, WINED3D_LOCATION_BUFFER);
wined3d_unordered_access_view_invalidate_location(view, ~WINED3D_LOCATION_BUFFER); wined3d_unordered_access_view_invalidate_location(view, ~WINED3D_LOCATION_BUFFER);
get_buffer_view_range(buffer, &view->desc, &format->f, &offset, &size); get_buffer_view_range(&buffer_gl->b, &view->desc, &format->f, &offset, &size);
context_bind_bo(context, buffer->buffer_type_hint, buffer->buffer_object); context_bind_bo(context, buffer_gl->buffer_type_hint, buffer_gl->b.buffer_object);
GL_EXTCALL(glClearBufferSubData(buffer->buffer_type_hint, format->internal, GL_EXTCALL(glClearBufferSubData(buffer_gl->buffer_type_hint, format->internal,
offset, size, format->format, format->type, clear_value)); offset, size, format->format, format->type, clear_value));
checkGLcall("clear unordered access view"); checkGLcall("clear unordered access view");
} }
@ -1092,7 +1092,7 @@ void wined3d_unordered_access_view_copy_counter(struct wined3d_unordered_access_
src.buffer_object = view->counter_bo; src.buffer_object = view->counter_bo;
src.addr = NULL; src.addr = NULL;
context_copy_bo_address(context, &dst, buffer->buffer_type_hint, context_copy_bo_address(context, &dst, wined3d_buffer_gl(buffer)->buffer_type_hint,
&src, GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint)); &src, GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint));
wined3d_buffer_invalidate_location(buffer, ~dst_location); wined3d_buffer_invalidate_location(buffer, ~dst_location);

3
dlls/wined3d/wined3d_private.h
View File

@ -3760,7 +3760,6 @@ struct wined3d_buffer
GLuint buffer_object; GLuint buffer_object;
GLenum buffer_object_usage; GLenum buffer_object_usage;
GLenum buffer_type_hint;
unsigned int bind_flags; unsigned int bind_flags;
DWORD flags; DWORD flags;
DWORD locations; DWORD locations;
@ -3799,6 +3798,8 @@ void wined3d_buffer_upload_data(struct wined3d_buffer *buffer, struct wined3d_co
struct wined3d_buffer_gl struct wined3d_buffer_gl
{ {
struct wined3d_buffer b; struct wined3d_buffer b;
GLenum buffer_type_hint;
}; };
static inline struct wined3d_buffer_gl *wined3d_buffer_gl(struct wined3d_buffer *buffer) static inline struct wined3d_buffer_gl *wined3d_buffer_gl(struct wined3d_buffer *buffer)