Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com>
---
dlls/wined3d/buffer.c | 203 +++++++++++++++++++++--------------------
dlls/wined3d/view.c | 14 +--
dlls/wined3d/wined3d_private.h | 3 +-
3 files changed, 115 insertions(+), 105 deletions(-)
diff --git a/dlls/wined3d/buffer.c b/dlls/wined3d/buffer.c
index 4b66193746f..1481e9bc6f6 100644
--- a/dlls/wined3d/buffer.c
+++ b/dlls/wined3d/buffer.c
@@ -133,9 +133,9 @@ void wined3d_buffer_invalidate_location(struct wined3d_buffer *buffer, DWORD loc
}
/* 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. */
@@ -194,14 +194,14 @@ static void buffer_destroy_buffer_object(struct wined3d_buffer *buffer, struct w
}
/* 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;
GLenum gl_usage = GL_STATIC_DRAW;
GLenum error;
- TRACE("Creating an OpenGL buffer object for wined3d_buffer %p with usage %s.\n",
- buffer, debug_d3dusage(buffer->resource.usage));
+ TRACE("Creating an OpenGL buffer object for wined3d buffer %p with usage %s.\n",
+ buffer_gl, debug_d3dusage(buffer_gl->b.resource.usage));
/* Make sure that the gl error is cleared. Do not use checkGLcall
* 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
* 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();
- 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);
goto fail;
}
- buffer_bind(buffer, context);
+ wined3d_buffer_gl_bind(buffer_gl, context);
error = gl_info->gl_ops.gl.p_glGetError();
if (error != GL_NO_ERROR)
{
@@ -232,22 +232,24 @@ static BOOL buffer_create_buffer_object(struct wined3d_buffer *buffer, struct wi
goto fail;
}
- if (buffer->resource.usage & WINED3DUSAGE_DYNAMIC)
+ if (buffer_gl->b.resource.usage & WINED3DUSAGE_DYNAMIC)
{
TRACE("Buffer has WINED3DUSAGE_DYNAMIC set.\n");
gl_usage = GL_STREAM_DRAW_ARB;
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->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE));
+ GL_EXTCALL(glBufferParameteriAPPLE(buffer_gl->buffer_type_hint,
+ GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE));
+ GL_EXTCALL(glBufferParameteriAPPLE(buffer_gl->buffer_type_hint,
+ GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE));
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. */
}
- 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();
if (error != GL_NO_ERROR)
{
@@ -255,17 +257,17 @@ static BOOL buffer_create_buffer_object(struct wined3d_buffer *buffer, struct wi
goto fail;
}
- buffer->buffer_object_usage = gl_usage;
- buffer_invalidate_bo_range(buffer, 0, 0);
+ buffer_gl->b.buffer_object_usage = gl_usage;
+ buffer_invalidate_bo_range(&buffer_gl->b, 0, 0);
return TRUE;
fail:
/* 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");
- buffer->flags &= ~WINED3D_BUFFER_USE_BO;
- buffer_destroy_buffer_object(buffer, context);
- buffer_clear_dirty_areas(buffer);
+ buffer_gl->b.flags &= ~WINED3D_BUFFER_USE_BO;
+ buffer_destroy_buffer_object(&buffer_gl->b, context);
+ buffer_clear_dirty_areas(&buffer_gl->b);
return FALSE;
}
@@ -532,18 +534,18 @@ ULONG CDECL wined3d_buffer_incref(struct wined3d_buffer *buffer)
}
/* 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 struct wined3d_gl_info *gl_info = context->gl_info;
const struct wined3d_map_range *range;
- buffer_bind(buffer, context);
+ wined3d_buffer_gl_bind(buffer_gl, context);
while (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));
}
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);
}
@@ -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);
return FALSE;
}
- return buffer_create_buffer_object(buffer, context);
+ return wined3d_buffer_gl_create_buffer_object(wined3d_buffer_gl(buffer), context);
default:
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,
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;
TRACE("buffer %p, context %p, location %s.\n",
@@ -672,15 +676,15 @@ BOOL wined3d_buffer_load_location(struct wined3d_buffer *buffer,
switch (location)
{
case WINED3D_LOCATION_SYSMEM:
- buffer_bind(buffer, context);
- GL_EXTCALL(glGetBufferSubData(buffer->buffer_type_hint, 0, buffer->resource.size,
+ wined3d_buffer_gl_bind(buffer_gl, context);
+ GL_EXTCALL(glGetBufferSubData(buffer_gl->buffer_type_hint, 0, buffer->resource.size,
buffer->resource.heap_memory));
checkGLcall("buffer download");
break;
case WINED3D_LOCATION_BUFFER:
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);
else
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 */
-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;
HRESULT hr;
@@ -821,16 +826,17 @@ static void buffer_sync_apple(struct wined3d_buffer *buffer, DWORD flags, const
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");
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)
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;
}
- TRACE("Synchronizing buffer %p.\n", buffer);
- ret = wined3d_fence_wait(buffer->fence, buffer->resource.device);
+ TRACE("Synchronizing buffer %p.\n", buffer_gl);
+ ret = wined3d_fence_wait(buffer_gl->b.fence, buffer_gl->b.resource.device);
switch (ret)
{
case WINED3D_FENCE_NOT_STARTED:
@@ -863,16 +869,16 @@ static void buffer_sync_apple(struct wined3d_buffer *buffer, DWORD flags, const
}
drop_fence:
- if (buffer->fence)
+ if (buffer_gl->b.fence)
{
- wined3d_fence_destroy(buffer->fence);
- buffer->fence = NULL;
+ wined3d_fence_destroy(buffer_gl->b.fence);
+ buffer_gl->b.fence = NULL;
}
gl_info->gl_ops.gl.p_glFinish();
- GL_EXTCALL(glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE));
- checkGLcall("glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE)");
- buffer->flags &= ~WINED3D_BUFFER_APPLESYNC;
+ GL_EXTCALL(glBufferParameteriAPPLE(buffer_gl->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_gl->b.flags &= ~WINED3D_BUFFER_APPLESYNC;
}
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;
}
-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;
LONG count;
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;
@@ -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)))
- || (!(flags & WINED3D_MAP_WRITE) && (buffer->locations & WINED3D_LOCATION_SYSMEM))
- || buffer->flags & WINED3D_BUFFER_PIN_SYSMEM)
+ || (!(flags & WINED3D_MAP_WRITE) && (buffer_gl->b.locations & WINED3D_LOCATION_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);
- wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM);
+ wined3d_buffer_load_location(&buffer_gl->b, context, WINED3D_LOCATION_SYSMEM);
context_release(context);
}
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
{
@@ -1043,19 +1050,19 @@ static HRESULT wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UI
gl_info = context->gl_info;
if (flags & WINED3D_MAP_DISCARD)
- wined3d_buffer_validate_location(buffer, WINED3D_LOCATION_BUFFER);
+ wined3d_buffer_validate_location(&buffer_gl->b, WINED3D_LOCATION_BUFFER);
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)
- 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)
- wined3d_buffer_evict_sysmem(buffer);
+ if ((flags & WINED3D_MAP_DISCARD) && buffer_gl->b.resource.heap_memory)
+ wined3d_buffer_evict_sysmem(&buffer_gl->b);
if (count == 1)
{
- buffer_bind(buffer, context);
+ wined3d_buffer_gl_bind(buffer_gl, context);
/* Filter redundant WINED3D_MAP_DISCARD maps. The 3DMark2001
* 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
* currently in use, while the proprietary NVIDIA driver
* appears to do this unconditionally. */
- if (buffer->flags & WINED3D_BUFFER_DISCARD)
+ if (buffer_gl->b.flags & WINED3D_BUFFER_DISCARD)
flags &= ~WINED3D_MAP_DISCARD;
if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
{
GLbitfield mapflags = wined3d_resource_gl_map_flags(flags);
- buffer->map_ptr = GL_EXTCALL(glMapBufferRange(buffer->buffer_type_hint,
- 0, buffer->resource.size, mapflags));
+ buffer_gl->b.map_ptr = GL_EXTCALL(glMapBufferRange(buffer_gl->buffer_type_hint,
+ 0, buffer_gl->b.resource.size, mapflags));
checkGLcall("glMapBufferRange");
}
else
{
- if (buffer->flags & WINED3D_BUFFER_APPLESYNC)
- buffer_sync_apple(buffer, flags, gl_info);
- buffer->map_ptr = GL_EXTCALL(glMapBuffer(buffer->buffer_type_hint,
+ if (buffer_gl->b.flags & WINED3D_BUFFER_APPLESYNC)
+ wined3d_buffer_gl_sync_apple(buffer_gl, flags, gl_info);
+ buffer_gl->b.map_ptr = GL_EXTCALL(glMapBuffer(buffer_gl->buffer_type_hint,
GL_READ_WRITE));
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");
- 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
* all on the Nvidia Linux driver, which is the only driver
* that returns unaligned pointers.
*/
TRACE("Dynamic buffer, dropping VBO.\n");
- wined3d_buffer_drop_bo(buffer);
+ wined3d_buffer_drop_bo(&buffer_gl->b);
}
else
{
TRACE("Falling back to doublebuffered operation.\n");
- wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM);
- buffer->flags |= WINED3D_BUFFER_PIN_SYSMEM;
+ wined3d_buffer_load_location(&buffer_gl->b, context, WINED3D_LOCATION_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)
- 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;
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;
}
-static void wined3d_buffer_unmap(struct wined3d_buffer *buffer)
+static void wined3d_buffer_gl_unmap(struct wined3d_buffer_gl *buffer_gl)
{
ULONG i;
- TRACE("buffer %p.\n", buffer);
+ TRACE("buffer_gl %p.\n", buffer_gl);
/* In the case that the number of Unmap calls > the
* number of Map calls, d3d returns always D3D_OK.
* This is also needed to prevent Map from returning garbage on
* 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");
return;
}
- if (--buffer->resource.map_count)
+ if (--buffer_gl->b.resource.map_count)
{
/* Delay loading the buffer until everything is unlocked */
TRACE("Ignoring unmap.\n");
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;
struct wined3d_context *context;
context = context_acquire(device, NULL, 0);
gl_info = context->gl_info;
- buffer_bind(buffer, context);
+ wined3d_buffer_gl_bind(buffer_gl, context);
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,
- buffer->maps[i].offset, buffer->maps[i].size));
+ GL_EXTCALL(glFlushMappedBufferRange(buffer_gl->buffer_type_hint,
+ buffer_gl->b.maps[i].offset, buffer_gl->b.maps[i].size));
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,
- buffer->maps[i].offset, buffer->maps[i].size));
+ GL_EXTCALL(glFlushMappedBufferRangeAPPLE(buffer_gl->buffer_type_hint,
+ buffer_gl->b.maps[i].offset, buffer_gl->b.maps[i].size));
checkGLcall("glFlushMappedBufferRangeAPPLE");
}
}
- GL_EXTCALL(glUnmapBuffer(buffer->buffer_type_hint));
+ GL_EXTCALL(glUnmapBuffer(buffer_gl->buffer_type_hint));
context_release(context);
- buffer_clear_dirty_areas(buffer);
- buffer->map_ptr = NULL;
+ buffer_clear_dirty_areas(&buffer_gl->b);
+ 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;
context = context_acquire(dst_buffer->resource.device, NULL, 0);
- context_copy_bo_address(context, &dst, dst_buffer->buffer_type_hint,
- &src, src_buffer->buffer_type_hint, size);
+ context_copy_bo_address(context, &dst, wined3d_buffer_gl(dst_buffer)->buffer_type_hint,
+ &src, wined3d_buffer_gl(src_buffer)->buffer_type_hint, size);
context_release(context);
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;
}
- 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,
@@ -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,
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;
if (sub_resource_idx)
@@ -1293,8 +1300,8 @@ static HRESULT buffer_resource_sub_resource_map(struct wined3d_resource *resourc
offset = size = 0;
}
- map_desc->row_pitch = map_desc->slice_pitch = buffer->desc.byte_width;
- return wined3d_buffer_map(buffer, offset, size, (BYTE **)&map_desc->data, flags);
+ map_desc->row_pitch = map_desc->slice_pitch = buffer_gl->b.desc.byte_width;
+ 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)
@@ -1305,7 +1312,7 @@ static HRESULT buffer_resource_sub_resource_unmap(struct wined3d_resource *resou
return E_INVALIDARG;
}
- wined3d_buffer_unmap(buffer_from_resource(resource));
+ wined3d_buffer_gl_unmap(wined3d_buffer_gl(buffer_from_resource(resource)));
return WINED3D_OK;
}
@@ -1377,7 +1384,6 @@ static HRESULT wined3d_buffer_init(struct wined3d_buffer *buffer, struct wined3d
return hr;
}
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->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,
struct wined3d_buffer **buffer)
{
+ const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
struct wined3d_buffer_gl *object;
HRESULT hr;
@@ -1456,6 +1463,8 @@ HRESULT CDECL wined3d_buffer_create(struct wined3d_device *device, const struct
if (!(object = heap_alloc_zero(sizeof(*object))))
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)))
{
WARN("Failed to initialize buffer, hr %#x.\n", hr);
diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c
index 7bb8b81c0db..35d15e63195 100644
--- a/dlls/wined3d/view.c
+++ b/dlls/wined3d/view.c
@@ -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_format_gl *format;
+ struct wined3d_buffer_gl *buffer_gl;
struct wined3d_resource *resource;
- struct wined3d_buffer *buffer;
unsigned int offset, size;
resource = view->resource;
@@ -1049,13 +1049,13 @@ void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_vi
return;
}
- buffer = buffer_from_resource(resource);
- wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER);
+ buffer_gl = wined3d_buffer_gl(buffer_from_resource(resource));
+ wined3d_buffer_load_location(&buffer_gl->b, context, WINED3D_LOCATION_BUFFER);
wined3d_unordered_access_view_invalidate_location(view, ~WINED3D_LOCATION_BUFFER);
- get_buffer_view_range(buffer, &view->desc, &format->f, &offset, &size);
- context_bind_bo(context, buffer->buffer_type_hint, buffer->buffer_object);
- GL_EXTCALL(glClearBufferSubData(buffer->buffer_type_hint, format->internal,
+ get_buffer_view_range(&buffer_gl->b, &view->desc, &format->f, &offset, &size);
+ context_bind_bo(context, buffer_gl->buffer_type_hint, buffer_gl->b.buffer_object);
+ GL_EXTCALL(glClearBufferSubData(buffer_gl->buffer_type_hint, format->internal,
offset, size, format->format, format->type, clear_value));
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.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));
wined3d_buffer_invalidate_location(buffer, ~dst_location);
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 0402603c527..226fdd0d3f5 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -3760,7 +3760,6 @@ struct wined3d_buffer
GLuint buffer_object;
GLenum buffer_object_usage;
- GLenum buffer_type_hint;
unsigned int bind_flags;
DWORD flags;
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 b;
+
+ GLenum buffer_type_hint;
};
static inline struct wined3d_buffer_gl *wined3d_buffer_gl(struct wined3d_buffer *buffer)
--
2.11.0
