2 * Copyright 2002-2005 Jason Edmeades
3 * Copyright 2002-2005 Raphael Junqueira
4 * Copyright 2004 Christian Costa
5 * Copyright 2005 Oliver Stieber
6 * Copyright 2007-2011, 2013-2014 Stefan Dösinger for CodeWeavers
7 * Copyright 2009-2010 Henri Verbeet for CodeWeavers
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wined3d_private.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
29 #define WINED3D_BUFFER_HASDESC 0x01 /* A vertex description has been found. */
30 #define WINED3D_BUFFER_USE_BO 0x02 /* Use a buffer object for this buffer. */
32 #define VB_MAXDECLCHANGES 100 /* After that number of decl changes we stop converting */
33 #define VB_RESETDECLCHANGE 1000 /* Reset the decl changecount after that number of draws */
34 #define VB_MAXFULLCONVERSIONS 5 /* Number of full conversions before we stop converting */
35 #define VB_RESETFULLCONVS 20 /* Reset full conversion counts after that number of draws */
37 #define SB_MIN_SIZE (512 * 1024) /* Minimum size of an allocated streaming buffer. */
39 struct wined3d_buffer_ops
41 BOOL (*buffer_prepare_location
)(struct wined3d_buffer
*buffer
,
42 struct wined3d_context
*context
, unsigned int location
);
43 void (*buffer_unload_location
)(struct wined3d_buffer
*buffer
,
44 struct wined3d_context
*context
, unsigned int location
);
47 static void wined3d_buffer_evict_sysmem(struct wined3d_buffer
*buffer
)
49 if (buffer
->resource
.pin_sysmem
)
51 TRACE("Not evicting system memory for buffer %p.\n", buffer
);
55 TRACE("Evicting system memory for buffer %p.\n", buffer
);
56 wined3d_buffer_invalidate_location(buffer
, WINED3D_LOCATION_SYSMEM
);
57 wined3d_resource_free_sysmem(&buffer
->resource
);
60 static void buffer_invalidate_bo_range(struct wined3d_buffer
*buffer
, unsigned int offset
, unsigned int size
)
62 if (!offset
&& (!size
|| size
== buffer
->resource
.size
))
65 if (offset
> buffer
->resource
.size
|| size
> buffer
->resource
.size
- offset
)
67 WARN("Invalid range specified, invalidating entire buffer.\n");
71 if (!wined3d_array_reserve((void **)&buffer
->maps
, &buffer
->maps_size
,
72 buffer
->modified_areas
+ 1, sizeof(*buffer
->maps
)))
74 ERR("Failed to allocate maps array, invalidating entire buffer.\n");
78 buffer
->maps
[buffer
->modified_areas
].offset
= offset
;
79 buffer
->maps
[buffer
->modified_areas
].size
= size
;
80 ++buffer
->modified_areas
;
84 buffer
->modified_areas
= 1;
85 buffer
->maps
[0].offset
= 0;
86 buffer
->maps
[0].size
= buffer
->resource
.size
;
89 static inline void buffer_clear_dirty_areas(struct wined3d_buffer
*This
)
91 This
->modified_areas
= 0;
94 static BOOL
buffer_is_dirty(const struct wined3d_buffer
*buffer
)
96 return !!buffer
->modified_areas
;
99 static BOOL
buffer_is_fully_dirty(const struct wined3d_buffer
*buffer
)
101 return buffer
->modified_areas
== 1
102 && !buffer
->maps
->offset
&& buffer
->maps
->size
== buffer
->resource
.size
;
105 static void wined3d_buffer_validate_location(struct wined3d_buffer
*buffer
, DWORD location
)
107 TRACE("buffer %p, location %s.\n", buffer
, wined3d_debug_location(location
));
109 if (location
& WINED3D_LOCATION_BUFFER
)
110 buffer_clear_dirty_areas(buffer
);
112 buffer
->locations
|= location
;
114 TRACE("New locations flags are %s.\n", wined3d_debug_location(buffer
->locations
));
117 static void wined3d_buffer_invalidate_range(struct wined3d_buffer
*buffer
, DWORD location
,
118 unsigned int offset
, unsigned int size
)
120 TRACE("buffer %p, location %s, offset %u, size %u.\n",
121 buffer
, wined3d_debug_location(location
), offset
, size
);
123 if (location
& WINED3D_LOCATION_BUFFER
)
124 buffer_invalidate_bo_range(buffer
, offset
, size
);
126 buffer
->locations
&= ~location
;
128 TRACE("New locations flags are %s.\n", wined3d_debug_location(buffer
->locations
));
130 if (!buffer
->locations
)
131 ERR("Buffer %p does not have any up to date location.\n", buffer
);
134 void wined3d_buffer_invalidate_location(struct wined3d_buffer
*buffer
, uint32_t location
)
136 wined3d_buffer_invalidate_range(buffer
, location
, 0, 0);
139 GLenum
wined3d_buffer_gl_binding_from_bind_flags(const struct wined3d_gl_info
*gl_info
, uint32_t bind_flags
)
142 return GL_PIXEL_UNPACK_BUFFER
;
144 /* We must always return GL_ELEMENT_ARRAY_BUFFER here;
145 * wined3d_device_gl_create_bo() checks the GL binding to see whether we
146 * can suballocate, and we cannot suballocate if this BO might be used for
147 * an index buffer. */
148 if (bind_flags
& WINED3D_BIND_INDEX_BUFFER
)
149 return GL_ELEMENT_ARRAY_BUFFER
;
151 if (bind_flags
& (WINED3D_BIND_SHADER_RESOURCE
| WINED3D_BIND_UNORDERED_ACCESS
)
152 && gl_info
->supported
[ARB_TEXTURE_BUFFER_OBJECT
])
153 return GL_TEXTURE_BUFFER
;
155 if (bind_flags
& WINED3D_BIND_CONSTANT_BUFFER
)
156 return GL_UNIFORM_BUFFER
;
158 if (bind_flags
& WINED3D_BIND_STREAM_OUTPUT
)
159 return GL_TRANSFORM_FEEDBACK_BUFFER
;
161 if (bind_flags
& WINED3D_BIND_INDIRECT_BUFFER
162 && gl_info
->supported
[ARB_DRAW_INDIRECT
])
163 return GL_DRAW_INDIRECT_BUFFER
;
165 if (bind_flags
& ~(WINED3D_BIND_VERTEX_BUFFER
| WINED3D_BIND_INDEX_BUFFER
))
166 FIXME("Unhandled bind flags %#x.\n", bind_flags
);
168 return GL_ARRAY_BUFFER
;
171 /* Context activation is done by the caller. */
172 static void wined3d_buffer_gl_destroy_buffer_object(struct wined3d_buffer_gl
*buffer_gl
,
173 struct wined3d_context_gl
*context_gl
)
175 struct wined3d_resource
*resource
= &buffer_gl
->b
.resource
;
176 struct wined3d_bo_gl
*bo_gl
;
178 if (!buffer_gl
->b
.buffer_object
)
180 bo_gl
= wined3d_bo_gl(buffer_gl
->b
.buffer_object
);
182 if (context_gl
->c
.transform_feedback_active
&& (resource
->bind_flags
& WINED3D_BIND_STREAM_OUTPUT
)
183 && wined3d_context_is_graphics_state_dirty(&context_gl
->c
, STATE_STREAM_OUTPUT
))
185 /* It's illegal to (un)bind GL_TRANSFORM_FEEDBACK_BUFFER while transform
186 * feedback is active. Deleting a buffer implicitly unbinds it, so we
187 * need to end transform feedback here if this buffer was bound.
189 * This should only be possible if STATE_STREAM_OUTPUT is dirty; if we
190 * do a draw call before destroying this buffer then the draw call will
191 * already rebind the GL target. */
192 WARN("Deleting buffer object for buffer %p, disabling transform feedback.\n", buffer_gl
);
193 wined3d_context_gl_end_transform_feedback(context_gl
);
196 buffer_gl
->b
.bo_user
.valid
= false;
197 list_remove(&buffer_gl
->b
.bo_user
.entry
);
198 wined3d_context_gl_destroy_bo(context_gl
, bo_gl
);
200 buffer_gl
->b
.buffer_object
= NULL
;
203 /* Context activation is done by the caller. */
204 static BOOL
wined3d_buffer_gl_create_buffer_object(struct wined3d_buffer_gl
*buffer_gl
,
205 struct wined3d_context_gl
*context_gl
)
207 struct wined3d_device_gl
*device_gl
= wined3d_device_gl(buffer_gl
->b
.resource
.device
);
208 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
209 GLenum usage
= GL_STATIC_DRAW
;
210 GLbitfield gl_storage_flags
;
211 struct wined3d_bo_gl
*bo
;
212 bool coherent
= true;
216 TRACE("Creating an OpenGL buffer object for wined3d buffer %p with usage %s.\n",
217 buffer_gl
, debug_d3dusage(buffer_gl
->b
.resource
.usage
));
219 if (!(bo
= heap_alloc(sizeof(*bo
))))
222 size
= buffer_gl
->b
.resource
.size
;
223 binding
= wined3d_buffer_gl_binding_from_bind_flags(gl_info
, buffer_gl
->b
.resource
.bind_flags
);
224 if (buffer_gl
->b
.resource
.usage
& WINED3DUSAGE_DYNAMIC
)
226 usage
= GL_STREAM_DRAW_ARB
;
229 gl_storage_flags
= wined3d_resource_gl_storage_flags(&buffer_gl
->b
.resource
);
230 if (!wined3d_device_gl_create_bo(device_gl
, context_gl
, size
, binding
, usage
, coherent
, gl_storage_flags
, bo
))
232 ERR("Failed to create OpenGL buffer object.\n");
233 buffer_gl
->b
.flags
&= ~WINED3D_BUFFER_USE_BO
;
234 buffer_clear_dirty_areas(&buffer_gl
->b
);
239 list_add_head(&bo
->b
.users
, &buffer_gl
->b
.bo_user
.entry
);
240 buffer_gl
->b
.buffer_object
= &bo
->b
;
241 buffer_invalidate_bo_range(&buffer_gl
->b
, 0, 0);
246 static BOOL
buffer_process_converted_attribute(struct wined3d_buffer
*buffer
,
247 const enum wined3d_buffer_conversion_type conversion_type
,
248 const struct wined3d_stream_info_element
*attrib
, UINT
*stride_this_run
)
250 const struct wined3d_format
*format
= attrib
->format
;
255 /* Check for some valid situations which cause us pain. One is if the buffer is used for
256 * constant attributes(stride = 0), the other one is if the buffer is used on two streams
257 * with different strides. In the 2nd case we might have to drop conversion entirely,
258 * it is possible that the same bytes are once read as FLOAT2 and once as UBYTE4N.
262 FIXME("%s used with stride 0, let's hope we get the vertex stride from somewhere else.\n",
263 debug_d3dformat(format
->id
));
265 else if (attrib
->stride
!= *stride_this_run
&& *stride_this_run
)
267 FIXME("Got two concurrent strides, %d and %d.\n", attrib
->stride
, *stride_this_run
);
271 *stride_this_run
= attrib
->stride
;
272 if (buffer
->stride
!= *stride_this_run
)
274 /* We rely that this happens only on the first converted attribute that is found,
275 * if at all. See above check
277 TRACE("Reconverting because converted attributes occur, and the stride changed.\n");
278 buffer
->stride
= *stride_this_run
;
279 heap_free(buffer
->conversion_map
);
280 buffer
->conversion_map
= heap_calloc(buffer
->stride
, sizeof(*buffer
->conversion_map
));
285 data
= ((DWORD_PTR
)attrib
->data
.addr
) % buffer
->stride
;
286 for (i
= 0; i
< format
->byte_count
; ++i
)
288 DWORD_PTR idx
= (data
+ i
) % buffer
->stride
;
289 if (buffer
->conversion_map
[idx
] != conversion_type
)
291 TRACE("Byte %Iu in vertex changed:\n", idx
);
292 TRACE(" It was type %#x, is %#x now.\n", buffer
->conversion_map
[idx
], conversion_type
);
294 buffer
->conversion_map
[idx
] = conversion_type
;
301 #define WINED3D_BUFFER_FIXUP_D3DCOLOR 0x01
302 #define WINED3D_BUFFER_FIXUP_XYZRHW 0x02
304 static BOOL
buffer_check_attribute(struct wined3d_buffer
*This
, const struct wined3d_stream_info
*si
,
305 const struct wined3d_state
*state
, UINT attrib_idx
, DWORD fixup_flags
, UINT
*stride_this_run
)
307 const struct wined3d_stream_info_element
*attrib
= &si
->elements
[attrib_idx
];
308 enum wined3d_format_id format
;
311 /* Ignore attributes that do not have our vbo. After that check we can be sure that the attribute is
312 * there, on nonexistent attribs the vbo is 0.
314 if (!(si
->use_map
& (1u << attrib_idx
))
315 || state
->streams
[attrib
->stream_idx
].buffer
!= This
)
318 format
= attrib
->format
->id
;
319 /* Look for newly appeared conversion */
320 if (fixup_flags
& WINED3D_BUFFER_FIXUP_D3DCOLOR
&& format
== WINED3DFMT_B8G8R8A8_UNORM
)
322 ret
= buffer_process_converted_attribute(This
, CONV_D3DCOLOR
, attrib
, stride_this_run
);
324 else if (fixup_flags
& WINED3D_BUFFER_FIXUP_XYZRHW
&& si
->position_transformed
)
326 if (format
!= WINED3DFMT_R32G32B32A32_FLOAT
)
328 FIXME("Unexpected format %s for transformed position.\n", debug_d3dformat(format
));
332 ret
= buffer_process_converted_attribute(This
, CONV_POSITIONT
, attrib
, stride_this_run
);
334 else if (This
->conversion_map
)
336 ret
= buffer_process_converted_attribute(This
, CONV_NONE
, attrib
, stride_this_run
);
342 static BOOL
buffer_find_decl(struct wined3d_buffer
*This
, const struct wined3d_stream_info
*si
,
343 const struct wined3d_state
*state
, DWORD fixup_flags
)
345 UINT stride_this_run
= 0;
348 /* In d3d7 the vertex buffer declaration NEVER changes because it is stored in the d3d7 vertex buffer.
349 * Once we have our declaration there is no need to look it up again. Index buffers also never need
350 * conversion, so once the (empty) conversion structure is created don't bother checking again
352 if (This
->flags
& WINED3D_BUFFER_HASDESC
)
354 if(This
->resource
.usage
& WINED3DUSAGE_STATICDECL
) return FALSE
;
359 TRACE("No fixup required.\n");
360 if(This
->conversion_map
)
362 heap_free(This
->conversion_map
);
363 This
->conversion_map
= NULL
;
371 TRACE("Finding vertex buffer conversion information\n");
372 /* Certain declaration types need some fixups before we can pass them to
373 * opengl. This means D3DCOLOR attributes with fixed function vertex
374 * processing, FLOAT4 POSITIONT with fixed function, and FLOAT16 if
375 * GL_ARB_half_float_vertex is not supported.
377 * Note for d3d8 and d3d9:
378 * The vertex buffer FVF doesn't help with finding them, we have to use
379 * the decoded vertex declaration and pick the things that concern the
380 * current buffer. A problem with this is that this can change between
381 * draws, so we have to validate the information and reprocess the buffer
382 * if it changes, and avoid false positives for performance reasons.
383 * WineD3D doesn't even know the vertex buffer any more, it is managed
384 * by the client libraries and passed to SetStreamSource and ProcessVertices
387 * We have to distinguish between vertex shaders and fixed function to
388 * pick the way we access the strided vertex information.
390 * This code sets up a per-byte array with the size of the detected
391 * stride of the arrays in the buffer. For each byte we have a field
392 * that marks the conversion needed on this byte. For example, the
393 * following declaration with fixed function vertex processing:
401 * { POSITIONT }{ NORMAL }{ DIFFUSE }{SPECULAR }
402 * [P][P][P][P][P][P][P][P][P][P][P][P][P][P][P][P][0][0][0][0][0][0][0][0][0][0][0][0][F][F][F][F][F][F][F][F][C][C][C][C]
404 * Where in this example map P means 4 component position conversion, 0
405 * means no conversion, F means FLOAT16_2 conversion and C means D3DCOLOR
406 * conversion (red / blue swizzle).
408 * If we're doing conversion and the stride changes we have to reconvert
409 * the whole buffer. Note that we do not mind if the semantic changes,
410 * we only care for the conversion type. So if the NORMAL is replaced
411 * with a TEXCOORD, nothing has to be done, or if the DIFFUSE is replaced
412 * with a D3DCOLOR BLENDWEIGHT we can happily dismiss the change. Some
413 * conversion types depend on the semantic as well, for example a FLOAT4
414 * texcoord needs no conversion while a FLOAT4 positiont needs one
417 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_POSITION
,
418 fixup_flags
, &stride_this_run
) || ret
;
419 fixup_flags
&= ~WINED3D_BUFFER_FIXUP_XYZRHW
;
421 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_BLENDWEIGHT
,
422 fixup_flags
, &stride_this_run
) || ret
;
423 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_BLENDINDICES
,
424 fixup_flags
, &stride_this_run
) || ret
;
425 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_NORMAL
,
426 fixup_flags
, &stride_this_run
) || ret
;
427 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_DIFFUSE
,
428 fixup_flags
, &stride_this_run
) || ret
;
429 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_SPECULAR
,
430 fixup_flags
, &stride_this_run
) || ret
;
431 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_TEXCOORD0
,
432 fixup_flags
, &stride_this_run
) || ret
;
433 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_TEXCOORD1
,
434 fixup_flags
, &stride_this_run
) || ret
;
435 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_TEXCOORD2
,
436 fixup_flags
, &stride_this_run
) || ret
;
437 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_TEXCOORD3
,
438 fixup_flags
, &stride_this_run
) || ret
;
439 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_TEXCOORD4
,
440 fixup_flags
, &stride_this_run
) || ret
;
441 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_TEXCOORD5
,
442 fixup_flags
, &stride_this_run
) || ret
;
443 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_TEXCOORD6
,
444 fixup_flags
, &stride_this_run
) || ret
;
445 ret
= buffer_check_attribute(This
, si
, state
, WINED3D_FFP_TEXCOORD7
,
446 fixup_flags
, &stride_this_run
) || ret
;
448 if (!stride_this_run
&& This
->conversion_map
)
452 ERR("no converted attributes found, old conversion map exists, and no declaration change?\n");
453 heap_free(This
->conversion_map
);
454 This
->conversion_map
= NULL
;
458 if (ret
) TRACE("Conversion information changed\n");
463 static inline unsigned int fixup_d3dcolor(DWORD
*dst_color
)
465 DWORD src_color
= *dst_color
;
467 /* Color conversion like in draw_primitive_immediate_mode(). Watch out for
468 * endianness. If we want this to work on big-endian machines as well we
469 * have to consider more things.
471 * 0xff000000: Alpha mask
472 * 0x00ff0000: Blue mask
473 * 0x0000ff00: Green mask
474 * 0x000000ff: Red mask
477 *dst_color
|= (src_color
& 0xff00ff00u
); /* Alpha Green */
478 *dst_color
|= (src_color
& 0x00ff0000u
) >> 16; /* Red */
479 *dst_color
|= (src_color
& 0x000000ffu
) << 16; /* Blue */
481 return sizeof(*dst_color
);
484 static inline unsigned int fixup_transformed_pos(struct wined3d_vec4
*p
)
486 /* rhw conversion like in position_float4(). */
487 if (p
->w
!= 1.0f
&& p
->w
!= 0.0f
)
489 float w
= 1.0f
/ p
->w
;
499 ULONG CDECL
wined3d_buffer_incref(struct wined3d_buffer
*buffer
)
501 unsigned int refcount
= InterlockedIncrement(&buffer
->resource
.ref
);
503 TRACE("%p increasing refcount to %u.\n", buffer
, refcount
);
508 static void buffer_conversion_upload(struct wined3d_buffer
*buffer
, struct wined3d_context
*context
)
510 unsigned int i
, j
, range_idx
, start
, end
, vertex_count
;
511 struct wined3d_bo_address src
, dst
;
514 if (!wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_SYSMEM
))
516 ERR("Failed to load system memory.\n");
519 buffer
->resource
.pin_sysmem
= 1;
521 /* Now for each vertex in the buffer that needs conversion. */
522 vertex_count
= buffer
->resource
.size
/ buffer
->stride
;
524 if (!(data
= heap_alloc(buffer
->resource
.size
)))
526 ERR("Out of memory.\n");
530 for (range_idx
= 0; range_idx
< buffer
->modified_areas
; ++range_idx
)
532 start
= buffer
->maps
[range_idx
].offset
;
533 end
= start
+ buffer
->maps
[range_idx
].size
;
535 memcpy(data
+ start
, (BYTE
*)buffer
->resource
.heap_memory
+ start
, end
- start
);
536 for (i
= start
/ buffer
->stride
; i
< min((end
/ buffer
->stride
) + 1, vertex_count
); ++i
)
538 for (j
= 0; j
< buffer
->stride
;)
540 switch (buffer
->conversion_map
[j
])
547 j
+= fixup_d3dcolor((DWORD
*) (data
+ i
* buffer
->stride
+ j
));
550 j
+= fixup_transformed_pos((struct wined3d_vec4
*) (data
+ i
* buffer
->stride
+ j
));
553 FIXME("Unimplemented conversion %d in shifted conversion.\n", buffer
->conversion_map
[j
]);
560 dst
.buffer_object
= buffer
->buffer_object
;
562 src
.buffer_object
= NULL
;
564 wined3d_context_copy_bo_address(context
, &dst
, &src
, buffer
->modified_areas
, buffer
->maps
);
569 BOOL
wined3d_buffer_prepare_location(struct wined3d_buffer
*buffer
,
570 struct wined3d_context
*context
, unsigned int location
)
572 return buffer
->buffer_ops
->buffer_prepare_location(buffer
, context
, location
);
575 static void wined3d_buffer_unload_location(struct wined3d_buffer
*buffer
,
576 struct wined3d_context
*context
, unsigned int location
)
578 buffer
->buffer_ops
->buffer_unload_location(buffer
, context
, location
);
581 BOOL
wined3d_buffer_load_location(struct wined3d_buffer
*buffer
,
582 struct wined3d_context
*context
, uint32_t location
)
584 struct wined3d_bo_address src
, dst
;
585 struct wined3d_range range
;
587 TRACE("buffer %p, context %p, location %s.\n",
588 buffer
, context
, wined3d_debug_location(location
));
590 if (buffer
->locations
& location
)
592 TRACE("Location (%#x) is already up to date.\n", location
);
596 if (!buffer
->locations
)
598 ERR("Buffer %p does not have any up to date location.\n", buffer
);
599 wined3d_buffer_validate_location(buffer
, WINED3D_LOCATION_DISCARDED
);
600 return wined3d_buffer_load_location(buffer
, context
, location
);
603 TRACE("Current buffer location %s.\n", wined3d_debug_location(buffer
->locations
));
605 if (!wined3d_buffer_prepare_location(buffer
, context
, location
))
608 if (buffer
->locations
& WINED3D_LOCATION_DISCARDED
)
610 TRACE("Buffer previously discarded, nothing to do.\n");
611 wined3d_buffer_validate_location(buffer
, location
);
612 wined3d_buffer_invalidate_location(buffer
, WINED3D_LOCATION_DISCARDED
);
618 case WINED3D_LOCATION_SYSMEM
:
619 if (buffer
->locations
& WINED3D_LOCATION_CLEARED
)
621 memset(buffer
->resource
.heap_memory
, 0, buffer
->resource
.size
);
625 dst
.buffer_object
= NULL
;
626 dst
.addr
= buffer
->resource
.heap_memory
;
627 src
.buffer_object
= buffer
->buffer_object
;
630 range
.size
= buffer
->resource
.size
;
631 wined3d_context_copy_bo_address(context
, &dst
, &src
, 1, &range
);
635 case WINED3D_LOCATION_BUFFER
:
636 if (buffer
->locations
& WINED3D_LOCATION_CLEARED
)
638 /* FIXME: Clear the buffer on the GPU if possible. */
639 if (!wined3d_buffer_prepare_location(buffer
, context
, WINED3D_LOCATION_SYSMEM
))
641 memset(buffer
->resource
.heap_memory
, 0, buffer
->resource
.size
);
644 dst
.buffer_object
= buffer
->buffer_object
;
646 src
.buffer_object
= NULL
;
647 src
.addr
= buffer
->resource
.heap_memory
;
649 if (!buffer
->conversion_map
)
650 wined3d_context_copy_bo_address(context
, &dst
, &src
, buffer
->modified_areas
, buffer
->maps
);
652 buffer_conversion_upload(buffer
, context
);
656 ERR("Invalid location %s.\n", wined3d_debug_location(location
));
660 wined3d_buffer_validate_location(buffer
, location
);
661 if (buffer
->resource
.heap_memory
&& location
== WINED3D_LOCATION_BUFFER
662 && !(buffer
->resource
.usage
& WINED3DUSAGE_DYNAMIC
))
663 wined3d_buffer_evict_sysmem(buffer
);
668 /* Context activation is done by the caller. */
669 BYTE
*wined3d_buffer_load_sysmem(struct wined3d_buffer
*buffer
, struct wined3d_context
*context
)
671 if (wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_SYSMEM
))
672 buffer
->resource
.pin_sysmem
= 1;
673 return buffer
->resource
.heap_memory
;
676 DWORD
wined3d_buffer_get_memory(struct wined3d_buffer
*buffer
, struct wined3d_context
*context
,
677 struct wined3d_bo_address
*data
)
679 unsigned int locations
= buffer
->locations
;
681 TRACE("buffer %p, context %p, data %p, locations %s.\n",
682 buffer
, context
, data
, wined3d_debug_location(locations
));
684 if (locations
& (WINED3D_LOCATION_DISCARDED
| WINED3D_LOCATION_CLEARED
))
686 locations
= ((buffer
->flags
& WINED3D_BUFFER_USE_BO
) ? WINED3D_LOCATION_BUFFER
: WINED3D_LOCATION_SYSMEM
);
687 if (!wined3d_buffer_load_location(buffer
, context
, locations
))
689 data
->buffer_object
= 0;
694 if (locations
& WINED3D_LOCATION_BUFFER
)
696 data
->buffer_object
= buffer
->buffer_object
;
698 return WINED3D_LOCATION_BUFFER
;
700 if (locations
& WINED3D_LOCATION_SYSMEM
)
702 data
->buffer_object
= 0;
703 data
->addr
= buffer
->resource
.heap_memory
;
704 return WINED3D_LOCATION_SYSMEM
;
707 ERR("Unexpected locations %s.\n", wined3d_debug_location(locations
));
708 data
->buffer_object
= 0;
713 static void buffer_resource_unload(struct wined3d_resource
*resource
)
715 struct wined3d_buffer
*buffer
= buffer_from_resource(resource
);
717 TRACE("buffer %p.\n", buffer
);
719 if (buffer
->buffer_object
)
721 struct wined3d_context
*context
;
723 context
= context_acquire(resource
->device
, NULL
, 0);
725 wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_SYSMEM
);
726 wined3d_buffer_invalidate_location(buffer
, WINED3D_LOCATION_BUFFER
);
727 wined3d_buffer_unload_location(buffer
, context
, WINED3D_LOCATION_BUFFER
);
728 buffer_clear_dirty_areas(buffer
);
730 context_release(context
);
732 heap_free(buffer
->conversion_map
);
733 buffer
->conversion_map
= NULL
;
735 buffer
->conversion_stride
= 0;
736 buffer
->flags
&= ~WINED3D_BUFFER_HASDESC
;
739 resource_unload(resource
);
742 static void wined3d_buffer_drop_bo(struct wined3d_buffer
*buffer
)
744 buffer
->flags
&= ~WINED3D_BUFFER_USE_BO
;
745 buffer_resource_unload(&buffer
->resource
);
748 static void wined3d_buffer_destroy_object(void *object
)
750 struct wined3d_buffer
*buffer
= object
;
751 struct wined3d_context
*context
;
753 TRACE("buffer %p.\n", buffer
);
755 if (buffer
->buffer_object
)
757 context
= context_acquire(buffer
->resource
.device
, NULL
, 0);
758 wined3d_buffer_unload_location(buffer
, context
, WINED3D_LOCATION_BUFFER
);
759 context_release(context
);
761 heap_free(buffer
->conversion_map
);
762 heap_free(buffer
->maps
);
765 void wined3d_buffer_cleanup(struct wined3d_buffer
*buffer
)
767 wined3d_cs_destroy_object(buffer
->resource
.device
->cs
, wined3d_buffer_destroy_object
, buffer
);
768 resource_cleanup(&buffer
->resource
);
771 ULONG CDECL
wined3d_buffer_decref(struct wined3d_buffer
*buffer
)
773 unsigned int refcount
= InterlockedDecrement(&buffer
->resource
.ref
);
775 TRACE("%p decreasing refcount to %u.\n", buffer
, refcount
);
779 wined3d_mutex_lock();
780 buffer
->resource
.parent_ops
->wined3d_object_destroyed(buffer
->resource
.parent
);
781 buffer
->resource
.device
->adapter
->adapter_ops
->adapter_destroy_buffer(buffer
);
782 wined3d_mutex_unlock();
788 void * CDECL
wined3d_buffer_get_parent(const struct wined3d_buffer
*buffer
)
790 TRACE("buffer %p.\n", buffer
);
792 return buffer
->resource
.parent
;
795 /* Context activation is done by the caller. */
796 void wined3d_buffer_load(struct wined3d_buffer
*buffer
, struct wined3d_context
*context
,
797 const struct wined3d_state
*state
)
799 const struct wined3d_d3d_info
*d3d_info
= context
->d3d_info
;
800 BOOL decl_changed
= FALSE
;
802 TRACE("buffer %p.\n", buffer
);
804 if (buffer
->resource
.map_count
&& buffer
->map_ptr
)
806 FIXME("Buffer is mapped through buffer object, not loading.\n");
809 else if (buffer
->resource
.map_count
)
811 WARN("Loading mapped buffer.\n");
814 /* TODO: Make converting independent from VBOs */
815 if (!(buffer
->flags
& WINED3D_BUFFER_USE_BO
))
817 /* Not doing any conversion */
821 if (!wined3d_buffer_prepare_location(buffer
, context
, WINED3D_LOCATION_BUFFER
))
823 ERR("Failed to prepare buffer location.\n");
827 /* Reading the declaration makes only sense if we have valid state information
828 * (i.e., if this function is called during draws). */
831 DWORD fixup_flags
= 0;
835 if (!d3d_info
->vertex_bgra
&& !d3d_info
->ffp_generic_attributes
)
836 fixup_flags
|= WINED3D_BUFFER_FIXUP_D3DCOLOR
;
837 if (!d3d_info
->xyzrhw
)
838 fixup_flags
|= WINED3D_BUFFER_FIXUP_XYZRHW
;
841 decl_changed
= buffer_find_decl(buffer
, &context
->stream_info
, state
, fixup_flags
);
842 buffer
->flags
|= WINED3D_BUFFER_HASDESC
;
845 if (!decl_changed
&& !(buffer
->flags
& WINED3D_BUFFER_HASDESC
&& buffer_is_dirty(buffer
)))
847 ++buffer
->draw_count
;
848 if (buffer
->draw_count
> VB_RESETDECLCHANGE
)
849 buffer
->decl_change_count
= 0;
850 if (buffer
->draw_count
> VB_RESETFULLCONVS
)
851 buffer
->full_conversion_count
= 0;
855 /* If applications change the declaration over and over, reconverting all the time is a huge
856 * performance hit. So count the declaration changes and release the VBO if there are too many
857 * of them (and thus stop converting)
861 ++buffer
->decl_change_count
;
862 buffer
->draw_count
= 0;
864 if (buffer
->decl_change_count
> VB_MAXDECLCHANGES
865 || (buffer
->conversion_map
&& (buffer
->resource
.usage
& WINED3DUSAGE_DYNAMIC
)))
867 FIXME("Too many declaration changes or converting dynamic buffer, stopping converting.\n");
868 wined3d_buffer_drop_bo(buffer
);
872 /* The declaration changed, reload the whole buffer. */
873 WARN("Reloading buffer because of a vertex declaration change.\n");
874 buffer_invalidate_bo_range(buffer
, 0, 0);
878 /* However, it is perfectly fine to change the declaration every now and then. We don't want a game that
879 * changes it every minute drop the VBO after VB_MAX_DECL_CHANGES minutes. So count draws without
880 * decl changes and reset the decl change count after a specific number of them
882 if (buffer
->conversion_map
&& buffer_is_fully_dirty(buffer
))
884 ++buffer
->full_conversion_count
;
885 if (buffer
->full_conversion_count
> VB_MAXFULLCONVERSIONS
)
887 FIXME("Too many full buffer conversions, stopping converting.\n");
888 wined3d_buffer_drop_bo(buffer
);
894 ++buffer
->draw_count
;
895 if (buffer
->draw_count
> VB_RESETDECLCHANGE
)
896 buffer
->decl_change_count
= 0;
897 if (buffer
->draw_count
> VB_RESETFULLCONVS
)
898 buffer
->full_conversion_count
= 0;
902 if (!wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_BUFFER
))
903 ERR("Failed to load buffer location.\n");
906 struct wined3d_resource
* CDECL
wined3d_buffer_get_resource(struct wined3d_buffer
*buffer
)
908 TRACE("buffer %p.\n", buffer
);
910 return &buffer
->resource
;
913 static HRESULT
buffer_resource_sub_resource_get_desc(struct wined3d_resource
*resource
,
914 unsigned int sub_resource_idx
, struct wined3d_sub_resource_desc
*desc
)
916 if (sub_resource_idx
)
918 WARN("Invalid sub_resource_idx %u.\n", sub_resource_idx
);
922 desc
->format
= WINED3DFMT_R8_UNORM
;
923 desc
->multisample_type
= WINED3D_MULTISAMPLE_NONE
;
924 desc
->multisample_quality
= 0;
925 desc
->usage
= resource
->usage
;
926 desc
->bind_flags
= resource
->bind_flags
;
927 desc
->access
= resource
->access
;
928 desc
->width
= resource
->size
;
931 desc
->size
= resource
->size
;
935 static void buffer_resource_sub_resource_get_map_pitch(struct wined3d_resource
*resource
,
936 unsigned int sub_resource_idx
, unsigned int *row_pitch
, unsigned int *slice_pitch
)
938 *row_pitch
= *slice_pitch
= resource
->size
;
941 static HRESULT
buffer_resource_sub_resource_map(struct wined3d_resource
*resource
, unsigned int sub_resource_idx
,
942 void **map_ptr
, const struct wined3d_box
*box
, uint32_t flags
)
944 struct wined3d_buffer
*buffer
= buffer_from_resource(resource
);
945 unsigned int offset
, size
, dirty_offset
, dirty_size
;
946 struct wined3d_device
*device
= resource
->device
;
947 struct wined3d_context
*context
;
948 struct wined3d_bo_address addr
;
952 TRACE("resource %p, sub_resource_idx %u, map_ptr %p, box %s, flags %#x.\n",
953 resource
, sub_resource_idx
, map_ptr
, debug_box(box
), flags
);
955 dirty_offset
= offset
= box
->left
;
956 dirty_size
= size
= box
->right
- box
->left
;
958 count
= ++resource
->map_count
;
960 /* DISCARD invalidates the entire buffer, regardless of the specified
961 * offset and size. Some applications also depend on the entire buffer
962 * being uploaded in that case. Two such applications are Port Royale
963 * and Darkstar One. */
964 if (flags
& WINED3D_MAP_DISCARD
)
970 if (((flags
& WINED3D_MAP_WRITE
) && !(flags
& (WINED3D_MAP_NOOVERWRITE
| WINED3D_MAP_DISCARD
)))
971 || (!(flags
& WINED3D_MAP_WRITE
) && (buffer
->locations
& WINED3D_LOCATION_SYSMEM
))
972 || buffer
->resource
.pin_sysmem
973 || !(buffer
->flags
& WINED3D_BUFFER_USE_BO
))
975 if (!(buffer
->locations
& WINED3D_LOCATION_SYSMEM
))
977 context
= context_acquire(device
, NULL
, 0);
978 wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_SYSMEM
);
979 context_release(context
);
982 if (flags
& WINED3D_MAP_WRITE
)
983 wined3d_buffer_invalidate_range(buffer
, ~WINED3D_LOCATION_SYSMEM
, dirty_offset
, dirty_size
);
987 context
= context_acquire(device
, NULL
, 0);
989 if (flags
& WINED3D_MAP_DISCARD
)
991 if (!wined3d_buffer_prepare_location(buffer
, context
, WINED3D_LOCATION_BUFFER
))
993 context_release(context
);
994 return E_OUTOFMEMORY
;
996 wined3d_buffer_validate_location(buffer
, WINED3D_LOCATION_BUFFER
);
1000 wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_BUFFER
);
1003 if (flags
& WINED3D_MAP_WRITE
)
1005 wined3d_buffer_invalidate_location(buffer
, ~WINED3D_LOCATION_BUFFER
);
1006 buffer_invalidate_bo_range(buffer
, dirty_offset
, dirty_size
);
1009 if ((flags
& WINED3D_MAP_DISCARD
) && resource
->heap_memory
)
1010 wined3d_buffer_evict_sysmem(buffer
);
1014 addr
.buffer_object
= buffer
->buffer_object
;
1016 buffer
->map_ptr
= wined3d_context_map_bo_address(context
, &addr
, resource
->size
, flags
);
1018 /* We are accessing buffer->resource.client from the CS thread,
1019 * but it's safe because the client thread will wait for the
1020 * map to return, thus completely serializing this call with
1021 * other client code. */
1022 if (context
->d3d_info
->persistent_map
)
1023 buffer
->resource
.client
.addr
= addr
;
1025 if (((DWORD_PTR
)buffer
->map_ptr
) & (RESOURCE_ALIGNMENT
- 1))
1027 WARN("Pointer %p is not %u byte aligned.\n", buffer
->map_ptr
, RESOURCE_ALIGNMENT
);
1029 wined3d_context_unmap_bo_address(context
, &addr
, 0, NULL
);
1030 buffer
->map_ptr
= NULL
;
1032 if (resource
->usage
& WINED3DUSAGE_DYNAMIC
)
1034 /* The extra copy is more expensive than not using VBOs
1035 * at all on the NVIDIA Linux driver, which is the
1036 * only driver that returns unaligned pointers. */
1037 TRACE("Dynamic buffer, dropping VBO.\n");
1038 wined3d_buffer_drop_bo(buffer
);
1042 TRACE("Falling back to doublebuffered operation.\n");
1043 wined3d_buffer_load_location(buffer
, context
, WINED3D_LOCATION_SYSMEM
);
1044 buffer
->resource
.pin_sysmem
= 1;
1046 TRACE("New pointer is %p.\n", resource
->heap_memory
);
1050 context_release(context
);
1053 base
= buffer
->map_ptr
? buffer
->map_ptr
: resource
->heap_memory
;
1054 *map_ptr
= base
+ offset
;
1056 TRACE("Returning memory at %p (base %p, offset %u).\n", *map_ptr
, base
, offset
);
1061 static HRESULT
buffer_resource_sub_resource_unmap(struct wined3d_resource
*resource
, unsigned int sub_resource_idx
)
1063 struct wined3d_buffer
*buffer
= buffer_from_resource(resource
);
1064 unsigned int range_count
= buffer
->modified_areas
;
1065 struct wined3d_device
*device
= resource
->device
;
1066 struct wined3d_context
*context
;
1067 struct wined3d_bo_address addr
;
1069 TRACE("resource %p, sub_resource_idx %u.\n", resource
, sub_resource_idx
);
1071 if (sub_resource_idx
)
1073 WARN("Invalid sub_resource_idx %u.\n", sub_resource_idx
);
1074 return E_INVALIDARG
;
1077 if (!resource
->map_count
)
1079 WARN("Unmap called without a previous map call.\n");
1083 if (--resource
->map_count
)
1085 /* Delay loading the buffer until everything is unmapped. */
1086 TRACE("Ignoring unmap.\n");
1090 if (!buffer
->map_ptr
)
1093 context
= context_acquire(device
, NULL
, 0);
1095 addr
.buffer_object
= buffer
->buffer_object
;
1097 wined3d_context_unmap_bo_address(context
, &addr
, range_count
, buffer
->maps
);
1099 context_release(context
);
1101 buffer_clear_dirty_areas(buffer
);
1102 buffer
->map_ptr
= NULL
;
1107 static void wined3d_buffer_set_bo(struct wined3d_buffer
*buffer
, struct wined3d_context
*context
, struct wined3d_bo
*bo
)
1109 struct wined3d_bo
*prev_bo
= buffer
->buffer_object
;
1111 TRACE("buffer %p, context %p, bo %p.\n", buffer
, context
, bo
);
1115 struct wined3d_bo_user
*bo_user
;
1117 LIST_FOR_EACH_ENTRY(bo_user
, &prev_bo
->users
, struct wined3d_bo_user
, entry
)
1118 bo_user
->valid
= false;
1119 assert(list_empty(&bo
->users
));
1120 list_move_head(&bo
->users
, &prev_bo
->users
);
1122 wined3d_context_destroy_bo(context
, prev_bo
);
1127 list_add_head(&bo
->users
, &buffer
->bo_user
.entry
);
1130 buffer
->buffer_object
= bo
;
1133 void wined3d_buffer_copy_bo_address(struct wined3d_buffer
*dst_buffer
, struct wined3d_context
*context
,
1134 unsigned int dst_offset
, const struct wined3d_const_bo_address
*src_addr
, unsigned int size
)
1136 struct wined3d_bo_address dst_addr
;
1137 struct wined3d_range range
;
1140 dst_location
= wined3d_buffer_get_memory(dst_buffer
, context
, &dst_addr
);
1141 dst_addr
.addr
+= dst_offset
;
1145 wined3d_context_copy_bo_address(context
, &dst_addr
, (const struct wined3d_bo_address
*)src_addr
, 1, &range
);
1146 wined3d_buffer_invalidate_range(dst_buffer
, ~dst_location
, dst_offset
, size
);
1149 void wined3d_buffer_copy(struct wined3d_buffer
*dst_buffer
, unsigned int dst_offset
,
1150 struct wined3d_buffer
*src_buffer
, unsigned int src_offset
, unsigned int size
)
1152 struct wined3d_context
*context
;
1153 struct wined3d_bo_address src
;
1155 TRACE("dst_buffer %p, dst_offset %u, src_buffer %p, src_offset %u, size %u.\n",
1156 dst_buffer
, dst_offset
, src_buffer
, src_offset
, size
);
1158 context
= context_acquire(dst_buffer
->resource
.device
, NULL
, 0);
1160 wined3d_buffer_get_memory(src_buffer
, context
, &src
);
1161 src
.addr
+= src_offset
;
1163 wined3d_buffer_copy_bo_address(dst_buffer
, context
, dst_offset
, wined3d_const_bo_address(&src
), size
);
1165 context_release(context
);
1168 void wined3d_buffer_update_sub_resource(struct wined3d_buffer
*buffer
, struct wined3d_context
*context
,
1169 const struct upload_bo
*upload_bo
, unsigned int offset
, unsigned int size
)
1171 if (upload_bo
->flags
& UPLOAD_BO_RENAME_ON_UNMAP
)
1173 wined3d_buffer_set_bo(buffer
, context
, upload_bo
->addr
.buffer_object
);
1174 wined3d_buffer_validate_location(buffer
, WINED3D_LOCATION_BUFFER
);
1175 wined3d_buffer_invalidate_location(buffer
, ~WINED3D_LOCATION_BUFFER
);
1178 if (upload_bo
->addr
.buffer_object
&& upload_bo
->addr
.buffer_object
== buffer
->buffer_object
)
1180 struct wined3d_range range
;
1182 /* We need to flush changes, which is implicitly done by
1183 * wined3d_context_unmap_bo_address() even if we aren't actually going
1186 * We would also like to free up virtual address space used by this BO
1187 * if it's at a premium—note that this BO was allocated for an
1188 * accelerated map. Hence we unmap the BO instead of merely flushing it;
1189 * if we don't care about unmapping BOs then
1190 * wined3d_context_unmap_bo_address() will flush and return.
1192 range
.offset
= offset
;
1194 if (upload_bo
->addr
.buffer_object
->map_ptr
)
1195 wined3d_context_unmap_bo_address(context
, (const struct wined3d_bo_address
*)&upload_bo
->addr
, 1, &range
);
1199 wined3d_buffer_copy_bo_address(buffer
, context
, offset
, &upload_bo
->addr
, size
);
1203 static void wined3d_buffer_init_data(struct wined3d_buffer
*buffer
,
1204 struct wined3d_device
*device
, const struct wined3d_sub_resource_data
*data
)
1206 struct wined3d_resource
*resource
= &buffer
->resource
;
1207 struct wined3d_box box
;
1209 if (buffer
->flags
& WINED3D_BUFFER_USE_BO
)
1211 wined3d_box_set(&box
, 0, 0, resource
->size
, 1, 0, 1);
1212 wined3d_device_context_emit_update_sub_resource(&device
->cs
->c
, resource
,
1213 0, &box
, data
->data
, data
->row_pitch
, data
->slice_pitch
);
1217 memcpy(buffer
->resource
.heap_memory
, data
->data
, resource
->size
);
1218 wined3d_buffer_validate_location(buffer
, WINED3D_LOCATION_SYSMEM
);
1219 wined3d_buffer_invalidate_location(buffer
, ~WINED3D_LOCATION_SYSMEM
);
1223 static ULONG
buffer_resource_incref(struct wined3d_resource
*resource
)
1225 return wined3d_buffer_incref(buffer_from_resource(resource
));
1228 static ULONG
buffer_resource_decref(struct wined3d_resource
*resource
)
1230 return wined3d_buffer_decref(buffer_from_resource(resource
));
1233 static void buffer_resource_preload(struct wined3d_resource
*resource
)
1235 struct wined3d_context
*context
;
1237 context
= context_acquire(resource
->device
, NULL
, 0);
1238 wined3d_buffer_load(buffer_from_resource(resource
), context
, NULL
);
1239 context_release(context
);
1242 static const struct wined3d_resource_ops buffer_resource_ops
=
1244 buffer_resource_incref
,
1245 buffer_resource_decref
,
1246 buffer_resource_preload
,
1247 buffer_resource_unload
,
1248 buffer_resource_sub_resource_get_desc
,
1249 buffer_resource_sub_resource_get_map_pitch
,
1250 buffer_resource_sub_resource_map
,
1251 buffer_resource_sub_resource_unmap
,
1254 static HRESULT
wined3d_buffer_init(struct wined3d_buffer
*buffer
, struct wined3d_device
*device
,
1255 const struct wined3d_buffer_desc
*desc
, const struct wined3d_sub_resource_data
*data
,
1256 void *parent
, const struct wined3d_parent_ops
*parent_ops
, const struct wined3d_buffer_ops
*buffer_ops
)
1258 const struct wined3d_format
*format
= wined3d_get_format(device
->adapter
, WINED3DFMT_R8_UNORM
, desc
->bind_flags
);
1259 struct wined3d_resource
*resource
= &buffer
->resource
;
1260 unsigned int access
;
1263 TRACE("buffer %p, device %p, desc byte_width %u, usage %s, bind_flags %s, "
1264 "access %s, data %p, parent %p, parent_ops %p.\n",
1265 buffer
, device
, desc
->byte_width
, debug_d3dusage(desc
->usage
), wined3d_debug_bind_flags(desc
->bind_flags
),
1266 wined3d_debug_resource_access(desc
->access
), data
, parent
, parent_ops
);
1268 if (!desc
->byte_width
)
1270 WARN("Size 0 requested, returning E_INVALIDARG.\n");
1271 return E_INVALIDARG
;
1274 if (desc
->bind_flags
& WINED3D_BIND_CONSTANT_BUFFER
&& desc
->byte_width
& (WINED3D_CONSTANT_BUFFER_ALIGNMENT
- 1))
1276 WARN("Size %#x is not suitably aligned for constant buffers.\n", desc
->byte_width
);
1277 return E_INVALIDARG
;
1280 if (data
&& !data
->data
)
1282 WARN("Invalid sub-resource data specified.\n");
1283 return E_INVALIDARG
;
1286 access
= desc
->access
;
1287 if (desc
->bind_flags
& WINED3D_BIND_CONSTANT_BUFFER
&& wined3d_settings
.cb_access_map_w
)
1288 access
|= WINED3D_RESOURCE_ACCESS_MAP_W
;
1290 if (FAILED(hr
= resource_init(resource
, device
, WINED3D_RTYPE_BUFFER
, format
,
1291 WINED3D_MULTISAMPLE_NONE
, 0, desc
->usage
, desc
->bind_flags
, access
,
1292 desc
->byte_width
, 1, 1, desc
->byte_width
, parent
, parent_ops
, &buffer_resource_ops
)))
1294 WARN("Failed to initialize resource, hr %#lx.\n", hr
);
1297 buffer
->buffer_ops
= buffer_ops
;
1298 buffer
->structure_byte_stride
= desc
->structure_byte_stride
;
1299 buffer
->locations
= WINED3D_LOCATION_CLEARED
;
1301 TRACE("buffer %p, size %#x, usage %#x, memory @ %p.\n",
1302 buffer
, buffer
->resource
.size
, buffer
->resource
.usage
, buffer
->resource
.heap_memory
);
1304 if (device
->create_parms
.flags
& WINED3DCREATE_SOFTWARE_VERTEXPROCESSING
1305 || (desc
->usage
& WINED3DUSAGE_MANAGED
))
1307 /* SWvp and managed buffers always return the same pointer in buffer
1308 * maps and retain data in DISCARD maps. Keep a system memory copy of
1309 * the buffer to provide the same behavior to the application. */
1310 TRACE("Pinning system memory.\n");
1311 buffer
->resource
.pin_sysmem
= 1;
1312 buffer
->locations
= WINED3D_LOCATION_SYSMEM
;
1315 if (buffer
->locations
& WINED3D_LOCATION_SYSMEM
|| !(buffer
->flags
& WINED3D_BUFFER_USE_BO
))
1317 if (!wined3d_resource_prepare_sysmem(&buffer
->resource
))
1318 return E_OUTOFMEMORY
;
1321 if (!(buffer
->maps
= heap_alloc(sizeof(*buffer
->maps
))))
1323 ERR("Out of memory.\n");
1324 buffer_resource_unload(resource
);
1325 resource_cleanup(resource
);
1326 wined3d_resource_wait_idle(resource
);
1327 return E_OUTOFMEMORY
;
1329 buffer
->maps_size
= 1;
1331 if (buffer
->locations
& WINED3D_LOCATION_DISCARDED
)
1332 buffer
->resource
.client
.addr
.buffer_object
= CLIENT_BO_DISCARDED
;
1335 wined3d_buffer_init_data(buffer
, device
, data
);
1340 static BOOL
wined3d_buffer_no3d_prepare_location(struct wined3d_buffer
*buffer
,
1341 struct wined3d_context
*context
, unsigned int location
)
1343 if (location
== WINED3D_LOCATION_SYSMEM
)
1344 return wined3d_resource_prepare_sysmem(&buffer
->resource
);
1346 FIXME("Unhandled location %s.\n", wined3d_debug_location(location
));
1351 static void wined3d_buffer_no3d_unload_location(struct wined3d_buffer
*buffer
,
1352 struct wined3d_context
*context
, unsigned int location
)
1354 TRACE("buffer %p, context %p, location %s.\n", buffer
, context
, wined3d_debug_location(location
));
1357 static const struct wined3d_buffer_ops wined3d_buffer_no3d_ops
=
1359 wined3d_buffer_no3d_prepare_location
,
1360 wined3d_buffer_no3d_unload_location
,
1363 HRESULT
wined3d_buffer_no3d_init(struct wined3d_buffer
*buffer_no3d
, struct wined3d_device
*device
,
1364 const struct wined3d_buffer_desc
*desc
, const struct wined3d_sub_resource_data
*data
,
1365 void *parent
, const struct wined3d_parent_ops
*parent_ops
)
1367 TRACE("buffer_no3d %p, device %p, desc %p, data %p, parent %p, parent_ops %p.\n",
1368 buffer_no3d
, device
, desc
, data
, parent
, parent_ops
);
1370 return wined3d_buffer_init(buffer_no3d
, device
, desc
, data
, parent
, parent_ops
, &wined3d_buffer_no3d_ops
);
1373 static BOOL
wined3d_buffer_gl_prepare_location(struct wined3d_buffer
*buffer
,
1374 struct wined3d_context
*context
, unsigned int location
)
1376 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
1377 struct wined3d_buffer_gl
*buffer_gl
= wined3d_buffer_gl(buffer
);
1381 case WINED3D_LOCATION_SYSMEM
:
1382 return wined3d_resource_prepare_sysmem(&buffer
->resource
);
1384 case WINED3D_LOCATION_BUFFER
:
1385 if (buffer
->buffer_object
)
1388 if (!(buffer
->flags
& WINED3D_BUFFER_USE_BO
))
1390 WARN("Trying to create BO for buffer %p with no WINED3D_BUFFER_USE_BO.\n", buffer
);
1393 return wined3d_buffer_gl_create_buffer_object(buffer_gl
, context_gl
);
1396 ERR("Invalid location %s.\n", wined3d_debug_location(location
));
1401 static void wined3d_buffer_gl_unload_location(struct wined3d_buffer
*buffer
,
1402 struct wined3d_context
*context
, unsigned int location
)
1404 TRACE("buffer %p, context %p, location %s.\n", buffer
, context
, wined3d_debug_location(location
));
1408 case WINED3D_LOCATION_BUFFER
:
1409 wined3d_buffer_gl_destroy_buffer_object(wined3d_buffer_gl(buffer
), wined3d_context_gl(context
));
1413 ERR("Unhandled location %s.\n", wined3d_debug_location(location
));
1418 static const struct wined3d_buffer_ops wined3d_buffer_gl_ops
=
1420 wined3d_buffer_gl_prepare_location
,
1421 wined3d_buffer_gl_unload_location
,
1424 HRESULT
wined3d_buffer_gl_init(struct wined3d_buffer_gl
*buffer_gl
, struct wined3d_device
*device
,
1425 const struct wined3d_buffer_desc
*desc
, const struct wined3d_sub_resource_data
*data
,
1426 void *parent
, const struct wined3d_parent_ops
*parent_ops
)
1428 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
1430 TRACE("buffer_gl %p, device %p, desc %p, data %p, parent %p, parent_ops %p.\n",
1431 buffer_gl
, device
, desc
, data
, parent
, parent_ops
);
1433 /* Observations show that draw_primitive_immediate_mode() is faster on
1434 * dynamic vertex buffers than converting + draw_primitive_arrays().
1435 * (Half-Life 2 and others.) */
1436 if (!(desc
->access
& WINED3D_RESOURCE_ACCESS_GPU
))
1437 TRACE("Not creating a BO because the buffer is not GPU accessible.\n");
1438 else if (!gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
])
1439 TRACE("Not creating a BO because GL_ARB_vertex_buffer is not supported.\n");
1440 else if (!(gl_info
->supported
[APPLE_FLUSH_BUFFER_RANGE
] || gl_info
->supported
[ARB_MAP_BUFFER_RANGE
])
1441 && (desc
->usage
& WINED3DUSAGE_DYNAMIC
))
1442 TRACE("Not creating a BO because the buffer has dynamic usage and no GL support.\n");
1444 buffer_gl
->b
.flags
|= WINED3D_BUFFER_USE_BO
;
1446 return wined3d_buffer_init(&buffer_gl
->b
, device
, desc
, data
, parent
, parent_ops
, &wined3d_buffer_gl_ops
);
1449 VkBufferUsageFlags
vk_buffer_usage_from_bind_flags(uint32_t bind_flags
)
1451 VkBufferUsageFlags usage
;
1453 usage
= VK_BUFFER_USAGE_TRANSFER_SRC_BIT
| VK_BUFFER_USAGE_TRANSFER_DST_BIT
;
1454 if (bind_flags
& WINED3D_BIND_VERTEX_BUFFER
)
1455 usage
|= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
;
1456 if (bind_flags
& WINED3D_BIND_INDEX_BUFFER
)
1457 usage
|= VK_BUFFER_USAGE_INDEX_BUFFER_BIT
;
1458 if (bind_flags
& WINED3D_BIND_CONSTANT_BUFFER
)
1459 usage
|= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
;
1460 if (bind_flags
& WINED3D_BIND_SHADER_RESOURCE
)
1461 usage
|= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
;
1462 if (bind_flags
& WINED3D_BIND_STREAM_OUTPUT
)
1463 usage
|= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT
;
1464 if (bind_flags
& WINED3D_BIND_UNORDERED_ACCESS
)
1465 usage
|= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
;
1466 if (bind_flags
& WINED3D_BIND_INDIRECT_BUFFER
)
1467 usage
|= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
;
1468 if (bind_flags
& (WINED3D_BIND_RENDER_TARGET
| WINED3D_BIND_DEPTH_STENCIL
))
1469 FIXME("Ignoring some bind flags %#x.\n", bind_flags
);
1473 VkMemoryPropertyFlags
vk_memory_type_from_access_flags(uint32_t access
, uint32_t usage
)
1475 VkMemoryPropertyFlags memory_type
= 0;
1477 if (access
& WINED3D_RESOURCE_ACCESS_MAP_R
)
1478 memory_type
|= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
| VK_MEMORY_PROPERTY_HOST_CACHED_BIT
;
1479 else if (access
& WINED3D_RESOURCE_ACCESS_MAP_W
)
1480 memory_type
|= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
;
1481 else if (!(usage
& WINED3DUSAGE_DYNAMIC
))
1482 memory_type
|= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
;
1486 static BOOL
wined3d_buffer_vk_create_buffer_object(struct wined3d_buffer_vk
*buffer_vk
,
1487 struct wined3d_context_vk
*context_vk
)
1489 struct wined3d_resource
*resource
= &buffer_vk
->b
.resource
;
1490 struct wined3d_bo_vk
*bo_vk
;
1492 if (!(bo_vk
= heap_alloc(sizeof(*bo_vk
))))
1495 if (!(wined3d_context_vk_create_bo(context_vk
, resource
->size
,
1496 vk_buffer_usage_from_bind_flags(resource
->bind_flags
),
1497 vk_memory_type_from_access_flags(resource
->access
, resource
->usage
), bo_vk
)))
1499 WARN("Failed to create Vulkan buffer.\n");
1504 list_init(&buffer_vk
->b
.bo_user
.entry
);
1505 list_add_head(&bo_vk
->b
.users
, &buffer_vk
->b
.bo_user
.entry
);
1506 buffer_vk
->b
.buffer_object
= &bo_vk
->b
;
1507 buffer_invalidate_bo_range(&buffer_vk
->b
, 0, 0);
1512 const VkDescriptorBufferInfo
*wined3d_buffer_vk_get_buffer_info(struct wined3d_buffer_vk
*buffer_vk
)
1514 struct wined3d_bo_vk
*bo
= wined3d_bo_vk(buffer_vk
->b
.buffer_object
);
1516 if (buffer_vk
->b
.bo_user
.valid
)
1517 return &buffer_vk
->buffer_info
;
1519 buffer_vk
->buffer_info
.buffer
= bo
->vk_buffer
;
1520 buffer_vk
->buffer_info
.offset
= bo
->b
.buffer_offset
;
1521 buffer_vk
->buffer_info
.range
= buffer_vk
->b
.resource
.size
;
1522 buffer_vk
->b
.bo_user
.valid
= true;
1524 return &buffer_vk
->buffer_info
;
1527 static BOOL
wined3d_buffer_vk_prepare_location(struct wined3d_buffer
*buffer
,
1528 struct wined3d_context
*context
, unsigned int location
)
1532 case WINED3D_LOCATION_SYSMEM
:
1533 return wined3d_resource_prepare_sysmem(&buffer
->resource
);
1535 case WINED3D_LOCATION_BUFFER
:
1536 if (buffer
->buffer_object
)
1539 return wined3d_buffer_vk_create_buffer_object(wined3d_buffer_vk(buffer
), wined3d_context_vk(context
));
1542 FIXME("Unhandled location %s.\n", wined3d_debug_location(location
));
1547 static void wined3d_buffer_vk_unload_location(struct wined3d_buffer
*buffer
,
1548 struct wined3d_context
*context
, unsigned int location
)
1550 struct wined3d_context_vk
*context_vk
= wined3d_context_vk(context
);
1551 struct wined3d_bo_vk
*bo_vk
= wined3d_bo_vk(buffer
->buffer_object
);
1553 TRACE("buffer %p, context %p, location %s.\n", buffer
, context
, wined3d_debug_location(location
));
1557 case WINED3D_LOCATION_BUFFER
:
1558 buffer
->bo_user
.valid
= false;
1559 list_remove(&buffer
->bo_user
.entry
);
1560 wined3d_context_vk_destroy_bo(context_vk
, bo_vk
);
1562 buffer
->buffer_object
= NULL
;
1566 ERR("Unhandled location %s.\n", wined3d_debug_location(location
));
1571 static const struct wined3d_buffer_ops wined3d_buffer_vk_ops
=
1573 wined3d_buffer_vk_prepare_location
,
1574 wined3d_buffer_vk_unload_location
,
1577 HRESULT
wined3d_buffer_vk_init(struct wined3d_buffer_vk
*buffer_vk
, struct wined3d_device
*device
,
1578 const struct wined3d_buffer_desc
*desc
, const struct wined3d_sub_resource_data
*data
,
1579 void *parent
, const struct wined3d_parent_ops
*parent_ops
)
1581 const struct wined3d_vk_info
*vk_info
= &wined3d_adapter_vk(device
->adapter
)->vk_info
;
1583 TRACE("buffer_vk %p, device %p, desc %p, data %p, parent %p, parent_ops %p.\n",
1584 buffer_vk
, device
, desc
, data
, parent
, parent_ops
);
1586 if ((desc
->bind_flags
& WINED3D_BIND_STREAM_OUTPUT
)
1587 && !vk_info
->supported
[WINED3D_VK_EXT_TRANSFORM_FEEDBACK
])
1589 WARN("The Vulkan implementation does not support transform feedback.\n");
1590 return WINED3DERR_INVALIDCALL
;
1593 if (desc
->access
& WINED3D_RESOURCE_ACCESS_GPU
)
1594 buffer_vk
->b
.flags
|= WINED3D_BUFFER_USE_BO
;
1596 return wined3d_buffer_init(&buffer_vk
->b
, device
, desc
, data
, parent
, parent_ops
, &wined3d_buffer_vk_ops
);
1599 void wined3d_buffer_vk_barrier(struct wined3d_buffer_vk
*buffer_vk
,
1600 struct wined3d_context_vk
*context_vk
, uint32_t bind_mask
)
1602 uint32_t src_bind_mask
= 0;
1604 TRACE("buffer_vk %p, context_vk %p, bind_mask %s.\n",
1605 buffer_vk
, context_vk
, wined3d_debug_bind_flags(bind_mask
));
1607 if (bind_mask
& ~WINED3D_READ_ONLY_BIND_MASK
)
1609 src_bind_mask
= buffer_vk
->bind_mask
& WINED3D_READ_ONLY_BIND_MASK
;
1611 src_bind_mask
= buffer_vk
->bind_mask
;
1613 buffer_vk
->bind_mask
= bind_mask
;
1615 else if ((buffer_vk
->bind_mask
& bind_mask
) != bind_mask
)
1617 src_bind_mask
= buffer_vk
->bind_mask
& ~WINED3D_READ_ONLY_BIND_MASK
;
1618 buffer_vk
->bind_mask
|= bind_mask
;
1623 const struct wined3d_bo_vk
*bo
= wined3d_bo_vk(buffer_vk
->b
.buffer_object
);
1624 const struct wined3d_vk_info
*vk_info
= context_vk
->vk_info
;
1625 VkBufferMemoryBarrier vk_barrier
;
1627 TRACE(" %s -> %s.\n",
1628 wined3d_debug_bind_flags(src_bind_mask
), wined3d_debug_bind_flags(bind_mask
));
1630 wined3d_context_vk_end_current_render_pass(context_vk
);
1632 vk_barrier
.sType
= VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
;
1633 vk_barrier
.pNext
= NULL
;
1634 vk_barrier
.srcAccessMask
= vk_access_mask_from_bind_flags(src_bind_mask
);
1635 vk_barrier
.dstAccessMask
= vk_access_mask_from_bind_flags(bind_mask
);
1636 vk_barrier
.srcQueueFamilyIndex
= VK_QUEUE_FAMILY_IGNORED
;
1637 vk_barrier
.dstQueueFamilyIndex
= VK_QUEUE_FAMILY_IGNORED
;
1638 vk_barrier
.buffer
= bo
->vk_buffer
;
1639 vk_barrier
.offset
= bo
->b
.buffer_offset
;
1640 vk_barrier
.size
= buffer_vk
->b
.resource
.size
;
1641 VK_CALL(vkCmdPipelineBarrier(wined3d_context_vk_get_command_buffer(context_vk
),
1642 vk_pipeline_stage_mask_from_bind_flags(src_bind_mask
),
1643 vk_pipeline_stage_mask_from_bind_flags(bind_mask
),
1644 0, 0, NULL
, 1, &vk_barrier
, 0, NULL
));
1648 HRESULT CDECL
wined3d_buffer_create(struct wined3d_device
*device
, const struct wined3d_buffer_desc
*desc
,
1649 const struct wined3d_sub_resource_data
*data
, void *parent
, const struct wined3d_parent_ops
*parent_ops
,
1650 struct wined3d_buffer
**buffer
)
1652 TRACE("device %p, desc %p, data %p, parent %p, parent_ops %p, buffer %p.\n",
1653 device
, desc
, data
, parent
, parent_ops
, buffer
);
1655 return device
->adapter
->adapter_ops
->adapter_create_buffer(device
, desc
, data
, parent
, parent_ops
, buffer
);
1658 static HRESULT
wined3d_streaming_buffer_prepare(struct wined3d_device
*device
,
1659 struct wined3d_streaming_buffer
*buffer
, unsigned int min_size
)
1661 struct wined3d_buffer
*wined3d_buffer
;
1662 struct wined3d_buffer_desc desc
;
1663 unsigned int old_size
= 0;
1669 old_size
= buffer
->buffer
->resource
.size
;
1670 if (old_size
>= min_size
)
1674 size
= max(SB_MIN_SIZE
, max(old_size
* 2, min_size
));
1675 TRACE("Growing buffer to %u bytes.\n", size
);
1677 desc
.byte_width
= size
;
1678 desc
.usage
= WINED3DUSAGE_DYNAMIC
;
1679 desc
.bind_flags
= buffer
->bind_flags
;
1680 desc
.access
= WINED3D_RESOURCE_ACCESS_GPU
| WINED3D_RESOURCE_ACCESS_MAP_W
;
1681 desc
.misc_flags
= 0;
1682 desc
.structure_byte_stride
= 0;
1684 if (SUCCEEDED(hr
= wined3d_buffer_create(device
, &desc
, NULL
, NULL
, &wined3d_null_parent_ops
, &wined3d_buffer
)))
1687 wined3d_buffer_decref(buffer
->buffer
);
1688 buffer
->buffer
= wined3d_buffer
;
1694 HRESULT CDECL
wined3d_streaming_buffer_map(struct wined3d_device
*device
,
1695 struct wined3d_streaming_buffer
*buffer
, unsigned int size
, unsigned int stride
,
1696 unsigned int *ret_pos
, void **ret_data
)
1698 unsigned int map_flags
= WINED3D_MAP_WRITE
;
1699 struct wined3d_resource
*resource
;
1700 struct wined3d_map_desc map_desc
;
1701 unsigned int pos
, align
;
1702 struct wined3d_box box
;
1705 TRACE("device %p, buffer %p, size %u, stride %u, ret_pos %p, ret_data %p.\n",
1706 device
, buffer
, size
, stride
, ret_pos
, ret_data
);
1708 if (FAILED(hr
= wined3d_streaming_buffer_prepare(device
, buffer
, size
)))
1710 resource
= &buffer
->buffer
->resource
;
1713 if ((align
= pos
% stride
))
1714 align
= stride
- align
;
1715 if (pos
+ size
+ align
> resource
->size
)
1718 map_flags
|= WINED3D_MAP_DISCARD
;
1723 map_flags
|= WINED3D_MAP_NOOVERWRITE
;
1726 wined3d_box_set(&box
, pos
, 0, pos
+ size
, 1, 0, 1);
1727 if (SUCCEEDED(hr
= wined3d_resource_map(resource
, 0, &map_desc
, &box
, map_flags
)))
1730 *ret_data
= map_desc
.data
;
1731 buffer
->pos
= pos
+ size
;
1736 void CDECL
wined3d_streaming_buffer_unmap(struct wined3d_streaming_buffer
*buffer
)
1738 wined3d_resource_unmap(&buffer
->buffer
->resource
, 0);
1741 HRESULT CDECL
wined3d_streaming_buffer_upload(struct wined3d_device
*device
, struct wined3d_streaming_buffer
*buffer
,
1742 const void *data
, unsigned int size
, unsigned int stride
, unsigned int *ret_pos
)
1747 if (SUCCEEDED(hr
= wined3d_streaming_buffer_map(device
, buffer
, size
, stride
, ret_pos
, &dst_data
)))
1749 memcpy(dst_data
, data
, size
);
1750 wined3d_streaming_buffer_unmap(buffer
);