Lines Matching refs:This
9 * This library is free software; you can redistribute it and/or
14 * This library is distributed in the hope that it will be useful,
41 #define GLINFO_LOCATION This->resource.device->adapter->gl_info
48 static inline BOOL buffer_add_dirty_area(struct wined3d_buffer *This, UINT offset, UINT size)
50 if (!This->buffer_object) return TRUE;
52 if (This->maps_size <= This->modified_areas)
54 void *new = HeapReAlloc(GetProcessHeap(), 0, This->maps,
55 This->maps_size * 2 * sizeof(*This->maps));
63 This->maps = new;
64 This->maps_size *= 2;
68 if(offset > This->resource.size || offset + size > This->resource.size)
72 size = This->resource.size;
76 size = This->resource.size;
79 This->maps[This->modified_areas].offset = offset;
80 This->maps[This->modified_areas].size = size;
81 This->modified_areas++;
85 static inline void buffer_clear_dirty_areas(struct wined3d_buffer *This)
87 This->modified_areas = 0;
90 static inline BOOL buffer_is_dirty(struct wined3d_buffer *This)
92 return This->modified_areas != 0;
95 static inline BOOL buffer_is_fully_dirty(struct wined3d_buffer *This)
99 for(i = 0; i < This->modified_areas; i++)
101 if(This->maps[i].offset == 0 && This->maps[i].size == This->resource.size)
110 static void delete_gl_buffer(struct wined3d_buffer *This)
112 if(!This->buffer_object) return;
115 GL_EXTCALL(glDeleteBuffersARB(1, &This->buffer_object));
118 This->buffer_object = 0;
120 if(This->query)
122 wined3d_event_query_destroy(This->query);
123 This->query = NULL;
125 This->flags &= ~WINED3D_BUFFER_APPLESYNC;
129 static void buffer_create_buffer_object(struct wined3d_buffer *This)
132 const struct wined3d_gl_info *gl_info = &This->resource.device->adapter->gl_info;
135 This, debug_d3dusage(This->resource.usage));
149 * look like. This means that on each DrawPrimitive call the vertex buffer has to be verified
153 GL_EXTCALL(glGenBuffersARB(1, &This->buffer_object));
155 if (!This->buffer_object || error != GL_NO_ERROR)
162 if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
164 IWineD3DDeviceImpl_MarkStateDirty(This->resource.device, STATE_INDEXBUFFER);
166 GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
178 if(This->resource.usage & WINED3DUSAGE_DYNAMIC)
185 GL_EXTCALL(glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE));
186 checkGLcall("glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE)");
187 This->flags |= WINED3D_BUFFER_FLUSH;
189 GL_EXTCALL(glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE));
190 checkGLcall("glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE)");
191 This->flags |= WINED3D_BUFFER_APPLESYNC;
206 GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, This->resource.size, This->resource.allocatedMemory, gl_usage));
215 This->buffer_object_size = This->resource.size;
216 This->buffer_object_usage = gl_usage;
218 if(This->flags & WINED3D_BUFFER_DOUBLEBUFFER)
220 if(!buffer_add_dirty_area(This, 0, 0))
228 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
229 This->resource.allocatedMemory = NULL;
230 This->resource.heapMemory = NULL;
238 delete_gl_buffer(This);
239 buffer_clear_dirty_areas(This);
242 static BOOL buffer_process_converted_attribute(struct wined3d_buffer *This,
249 DWORD offset = This->resource.device->stateBlock->streamOffset[attrib->stream_idx];
269 if (This->stride != *stride_this_run)
275 This->stride = *stride_this_run;
276 HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, This->conversion_map);
277 This->conversion_map = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
278 sizeof(*This->conversion_map) * This->stride);
283 data = (((DWORD_PTR)attrib->data) + offset) % This->stride;
287 DWORD_PTR idx = (data + i) % This->stride;
288 if (This->conversion_map[idx] != conversion_type)
291 TRACE("It was type %d, is %d now\n", This->conversion_map[idx], conversion_type);
293 This->conversion_map[idx] = conversion_type;
300 static BOOL buffer_check_attribute(struct wined3d_buffer *This, const struct wined3d_stream_info *si,
305 IWineD3DDeviceImpl *device = This->resource.device;
314 || attrib->buffer_object != This->buffer_object)
322 ret = buffer_process_converted_attribute(This, CONV_FLOAT16_2, attrib, stride_this_run);
330 ret = buffer_process_converted_attribute(This, CONV_D3DCOLOR, attrib, stride_this_run);
336 ret = buffer_process_converted_attribute(This, CONV_POSITIONT, attrib, stride_this_run);
338 else if (This->conversion_map)
340 ret = buffer_process_converted_attribute(This, CONV_NONE, attrib, stride_this_run);
346 static UINT *find_conversion_shift(struct wined3d_buffer *This,
357 This->conversion_stride = stride;
363 if (!(strided->use_map & (1 << i)) || strided->elements[i].buffer_object != This->buffer_object) continue;
385 This->conversion_stride += shift;
411 static BOOL buffer_find_decl(struct wined3d_buffer *This)
413 IWineD3DDeviceImpl *device = This->resource.device;
425 if (This->flags & WINED3D_BUFFER_HASDESC)
427 if(This->resource.usage & WINED3DUSAGE_STATICDECL) return FALSE;
432 * opengl. This means D3DCOLOR attributes with fixed function vertex
449 * This code sets up a per-byte array with the size of the detected
484 if (This->conversion_map)
487 HeapFree(GetProcessHeap(), 0, This->conversion_map);
488 HeapFree(GetProcessHeap(), 0, This->conversion_shift);
489 This->conversion_map = NULL;
490 This->stride = 0;
491 This->conversion_shift = NULL;
492 This->conversion_stride = 0;
502 ret = buffer_check_attribute(This, si, i, FALSE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
508 if (ret && (float16_used || This->conversion_map))
510 HeapFree(GetProcessHeap(), 0, This->conversion_shift);
511 This->conversion_shift = find_conversion_shift(This, si, This->stride);
521 ret = buffer_check_attribute(This, si, WINED3D_FFP_POSITION,
523 ret = buffer_check_attribute(This, si, WINED3D_FFP_NORMAL,
525 ret = buffer_check_attribute(This, si, WINED3D_FFP_DIFFUSE,
527 ret = buffer_check_attribute(This, si, WINED3D_FFP_SPECULAR,
529 ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD0,
531 ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD1,
533 ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD2,
535 ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD3,
537 ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD4,
539 ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD5,
541 ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD6,
543 ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD7,
549 if (stride_this_run == 0 && This->conversion_map)
553 HeapFree(GetProcessHeap(), 0, This->conversion_map);
554 This->conversion_map = NULL;
555 This->stride = 0;
564 static void buffer_check_buffer_object_size(struct wined3d_buffer *This)
566 UINT size = This->conversion_stride ?
567 This->conversion_stride * (This->resource.size / This->stride) : This->resource.size;
568 if (This->buffer_object_size != size)
570 TRACE("Old size %u, creating new size %u\n", This->buffer_object_size, size);
572 if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
574 IWineD3DDeviceImpl_MarkStateDirty(This->resource.device, STATE_INDEXBUFFER);
578 if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
580 buffer_get_sysmem(This);
584 GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
586 GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, size, NULL, This->buffer_object_usage));
587 This->buffer_object_size = size;
627 struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
629 *buffer_object = This->buffer_object;
630 if (!This->buffer_object)
632 if (This->flags & WINED3D_BUFFER_CREATEBO)
634 buffer_create_buffer_object(This);
635 This->flags &= ~WINED3D_BUFFER_CREATEBO;
636 if (This->buffer_object)
638 *buffer_object = This->buffer_object;
642 return This->resource.allocatedMemory;
676 struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
677 ULONG refcount = InterlockedIncrement(&This->resource.ref);
679 TRACE("%p increasing refcount to %u\n", This, refcount);
685 BYTE *buffer_get_sysmem(struct wined3d_buffer *This)
688 if(This->resource.allocatedMemory) return This->resource.allocatedMemory;
690 This->resource.heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->resource.size + RESOURCE_ALIGNMENT);
691 This->resource.allocatedMemory = (BYTE *)(((ULONG_PTR)This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
693 GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
694 GL_EXTCALL(glGetBufferSubDataARB(This->buffer_type_hint, 0, This->resource.size, This->resource.allocatedMemory));
696 This->flags |= WINED3D_BUFFER_DOUBLEBUFFER;
698 return This->resource.allocatedMemory;
703 struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
707 if (This->buffer_object)
709 IWineD3DDeviceImpl *device = This->resource.device;
715 if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
717 buffer_get_sysmem(This);
718 This->flags &= ~WINED3D_BUFFER_DOUBLEBUFFER;
721 delete_gl_buffer(This);
722 This->flags |= WINED3D_BUFFER_CREATEBO; /* Recreate the buffer object next load */
723 buffer_clear_dirty_areas(This);
727 HeapFree(GetProcessHeap(), 0, This->conversion_shift);
728 This->conversion_shift = NULL;
729 HeapFree(GetProcessHeap(), 0, This->conversion_map);
730 This->conversion_map = NULL;
731 This->stride = 0;
732 This->conversion_stride = 0;
733 This->flags &= ~WINED3D_BUFFER_HASDESC;
739 struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
740 ULONG refcount = InterlockedDecrement(&This->resource.ref);
742 TRACE("%p decreasing refcount to %u\n", This, refcount);
748 This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent);
749 HeapFree(GetProcessHeap(), 0, This->maps);
750 HeapFree(GetProcessHeap(), 0, This);
793 static void buffer_sync_apple(struct wined3d_buffer *This, DWORD flags, const struct wined3d_gl_info *gl_info)
803 GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, This->resource.size, NULL, This->buffer_object_usage));
809 if(!This->query)
811 TRACE("Creating event query for buffer %p\n", This);
819 This->query = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This->query));
820 if (!This->query)
830 TRACE("Synchronizing buffer %p\n", This);
831 ret = wined3d_event_query_finish(This->query, This->resource.device);
849 if(This->query)
851 wined3d_event_query_destroy(This->query);
852 This->query = NULL;
857 GL_EXTCALL(glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE));
858 checkGLcall("glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE)");
860 This->flags &= ~WINED3D_BUFFER_APPLESYNC;
864 static void buffer_direct_upload(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info, DWORD flags)
870 GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
884 map = GL_EXTCALL(glMapBufferRange(This->buffer_type_hint, 0,
885 This->resource.size, mapflags));
890 if (This->flags & WINED3D_BUFFER_APPLESYNC)
896 buffer_sync_apple(This, syncflags, gl_info);
899 map = GL_EXTCALL(glMapBufferARB(This->buffer_type_hint, GL_WRITE_ONLY_ARB));
909 while(This->modified_areas)
911 This->modified_areas--;
912 start = This->maps[This->modified_areas].offset;
913 len = This->maps[This->modified_areas].size;
915 memcpy(map + start, This->resource.allocatedMemory + start, len);
919 GL_EXTCALL(glFlushMappedBufferRange(This->buffer_type_hint, start, len));
922 else if (This->flags & WINED3D_BUFFER_FLUSH)
924 GL_EXTCALL(glFlushMappedBufferRangeAPPLE(This->buffer_type_hint, start, len));
928 GL_EXTCALL(glUnmapBufferARB(This->buffer_type_hint));
935 struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
936 IWineD3DDeviceImpl *device = This->resource.device;
942 DWORD flags = This->flags & (WINED3D_BUFFER_NOSYNC | WINED3D_BUFFER_DISCARD);
945 This->flags &= ~(WINED3D_BUFFER_NOSYNC | WINED3D_BUFFER_DISCARD);
949 if (!This->buffer_object)
952 if (This->flags & WINED3D_BUFFER_CREATEBO)
954 buffer_create_buffer_object(This);
955 This->flags &= ~WINED3D_BUFFER_CREATEBO;
965 if (device->isInDraw && This->bind_count > 0)
967 decl_changed = buffer_find_decl(This);
968 This->flags |= WINED3D_BUFFER_HASDESC;
971 if (!decl_changed && !(This->flags & WINED3D_BUFFER_HASDESC && buffer_is_dirty(This)))
974 ++This->draw_count;
975 if (This->draw_count > VB_RESETDECLCHANGE) This->decl_change_count = 0;
976 if (This->draw_count > VB_RESETFULLCONVS) This->full_conversion_count = 0;
986 ++This->decl_change_count;
987 This->draw_count = 0;
989 if (This->decl_change_count > VB_MAXDECLCHANGES ||
990 (This->conversion_map && (This->resource.usage & WINED3DUSAGE_DYNAMIC)))
995 This->flags &= ~WINED3D_BUFFER_CREATEBO;
999 * to force a reload. This happens only once per changed vertexbuffer and should occur rather
1005 buffer_check_buffer_object_size(This);
1009 buffer_clear_dirty_areas(This);
1010 if(!buffer_add_dirty_area(This, 0, 0))
1026 if(buffer_is_fully_dirty(This))
1028 ++This->full_conversion_count;
1029 if(This->full_conversion_count > VB_MAXFULLCONVERSIONS)
1033 This->flags &= ~WINED3D_BUFFER_CREATEBO;
1040 ++This->draw_count;
1041 if (This->draw_count > VB_RESETDECLCHANGE) This->decl_change_count = 0;
1042 if (This->draw_count > VB_RESETFULLCONVS) This->full_conversion_count = 0;
1046 if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
1048 IWineD3DDeviceImpl_MarkStateDirty(This->resource.device, STATE_INDEXBUFFER);
1051 if (!This->conversion_map)
1053 /* That means that there is nothing to fixup. Just upload from This->resource.allocatedMemory
1060 if (!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
1066 buffer_direct_upload(This, context->gl_info, flags);
1072 if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
1074 buffer_get_sysmem(This);
1078 vertices = This->resource.size / This->stride;
1080 if (This->conversion_shift)
1083 data = HeapAlloc(GetProcessHeap(), 0, vertices * This->conversion_stride);
1086 len = This->resource.size;
1089 if (This->maps[0].offset || This->maps[0].size != This->resource.size)
1094 for (i = start / This->stride; i < min((end / This->stride) + 1, vertices); ++i)
1096 for (j = 0; j < This->stride; ++j)
1098 switch(This->conversion_map[j])
1101 data[This->conversion_stride * i + j + This->conversion_shift[j]]
1102 = This->resource.allocatedMemory[This->stride * i + j];
1107 float *out = (float *)(&data[This->conversion_stride * i + j + This->conversion_shift[j]]);
1108 const WORD *in = (WORD *)(&This->resource.allocatedMemory[i * This->stride + j]);
1117 FIXME("Unimplemented conversion %d in shifted conversion\n", This->conversion_map[j]);
1124 GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
1126 GL_EXTCALL(glBufferSubDataARB(This->buffer_type_hint, 0, vertices * This->conversion_stride, data));
1132 data = HeapAlloc(GetProcessHeap(), 0, This->resource.size);
1134 while(This->modified_areas)
1136 This->modified_areas--;
1137 start = This->maps[This->modified_areas].offset;
1138 len = This->maps[This->modified_areas].size;
1141 memcpy(data + start, This->resource.allocatedMemory + start, end - start);
1142 for (i = start / This->stride; i < min((end / This->stride) + 1, vertices); ++i)
1144 for (j = 0; j < This->stride; ++j)
1146 switch(This->conversion_map[j])
1153 fixup_d3dcolor((DWORD *) (data + i * This->stride + j));
1158 fixup_transformed_pos((float *) (data + i * This->stride + j));
1165 FIXME("Unimplemented conversion %d in shifted conversion\n", This->conversion_map[j]);
1171 GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
1173 GL_EXTCALL(glBufferSubDataARB(This->buffer_type_hint, start, len, data + start));
1244 struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
1246 BOOL dirty = buffer_is_dirty(This);
1250 flags = buffer_sanitize_flags(This, flags);
1253 if (!buffer_add_dirty_area(This, offset, size)) return E_OUTOFMEMORY;
1256 count = InterlockedIncrement(&This->lock_count);
1258 if (This->buffer_object)
1260 if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
1264 IWineD3DDeviceImpl *device = This->resource.device;
1268 if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
1270 IWineD3DDeviceImpl_MarkStateDirty(This->resource.device, STATE_INDEXBUFFER);
1276 GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
1281 This->resource.allocatedMemory = GL_EXTCALL(glMapBufferRange(This->buffer_type_hint, 0,
1282 This->resource.size, mapflags));
1287 if(This->flags & WINED3D_BUFFER_APPLESYNC)
1290 buffer_sync_apple(This, flags, gl_info);
1293 This->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(This->buffer_type_hint, GL_READ_WRITE_ARB));
1298 if (((DWORD_PTR) This->resource.allocatedMemory) & (RESOURCE_ALIGNMENT - 1))
1301 This->resource.allocatedMemory, RESOURCE_ALIGNMENT);
1304 GL_EXTCALL(glUnmapBufferARB(This->buffer_type_hint));
1307 This->resource.allocatedMemory = NULL;
1309 buffer_get_sysmem(This);
1310 TRACE("New pointer is %p\n", This->resource.allocatedMemory);
1319 if (This->flags & WINED3D_BUFFER_NOSYNC && !(flags & WINED3DLOCK_NOOVERWRITE))
1321 This->flags &= ~WINED3D_BUFFER_NOSYNC;
1326 This->flags |= WINED3D_BUFFER_NOSYNC;
1331 This->flags |= WINED3D_BUFFER_DISCARD;
1336 *data = This->resource.allocatedMemory + offset;
1338 TRACE("Returning memory at %p (base %p, offset %u)\n", *data, This->resource.allocatedMemory, offset);
1339 /* TODO: check Flags compatibility with This->currentDesc.Usage (see MSDN) */
1346 struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
1349 TRACE("(%p)\n", This);
1353 * This is also needed to prevent Map from returning garbage on
1355 if(This->lock_count == 0)
1361 if (InterlockedDecrement(&This->lock_count))
1368 if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER) && This->buffer_object)
1370 IWineD3DDeviceImpl *device = This->resource.device;
1374 if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
1376 IWineD3DDeviceImpl_MarkStateDirty(This->resource.device, STATE_INDEXBUFFER);
1382 GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
1386 for(i = 0; i < This->modified_areas; i++)
1388 GL_EXTCALL(glFlushMappedBufferRange(This->buffer_type_hint,
1389 This->maps[i].offset,
1390 This->maps[i].size));
1394 else if (This->flags & WINED3D_BUFFER_FLUSH)
1396 for(i = 0; i < This->modified_areas; i++)
1398 GL_EXTCALL(glFlushMappedBufferRangeAPPLE(This->buffer_type_hint,
1399 This->maps[i].offset,
1400 This->maps[i].size));
1405 GL_EXTCALL(glUnmapBufferARB(This->buffer_type_hint));
1409 This->resource.allocatedMemory = NULL;
1410 buffer_clear_dirty_areas(This);
1412 else if (This->flags & WINED3D_BUFFER_HASDESC)
1422 struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
1424 TRACE("(%p)\n", This);
1426 desc->Type = This->resource.resourceType;
1427 desc->Usage = This->resource.usage;
1428 desc->Pool = This->resource.pool;
1429 desc->Size = This->resource.size;