1 /* 2 * Copyright 2002-2004 Jason Edmeades 3 * Copyright 2003-2004 Raphael Junqueira 4 * Copyright 2004 Christian Costa 5 * Copyright 2005 Oliver Stieber 6 * Copyright 2009-2010 Henri Verbeet for CodeWeavers 7 * Copyright 2006-2008, 2013 Stefan Dösinger for CodeWeavers 8 * 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. 13 * 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. 18 * 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 22 */ 23 24 #include "config.h" 25 #include "wine/port.h" 26 #include "wined3d_private.h" 27 28 WINE_DEFAULT_DEBUG_CHANNEL(d3d); 29 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf); 30 31 static void resource_check_usage(DWORD usage) 32 { 33 static DWORD handled = WINED3DUSAGE_RENDERTARGET 34 | WINED3DUSAGE_DEPTHSTENCIL 35 | WINED3DUSAGE_WRITEONLY 36 | WINED3DUSAGE_DYNAMIC 37 | WINED3DUSAGE_STATICDECL 38 | WINED3DUSAGE_OVERLAY 39 | WINED3DUSAGE_SCRATCH 40 | WINED3DUSAGE_PRIVATE 41 | WINED3DUSAGE_LEGACY_CUBEMAP 42 | WINED3DUSAGE_TEXTURE; 43 44 /* WINED3DUSAGE_WRITEONLY is supposed to result in write-combined mappings 45 * being returned. OpenGL doesn't give us explicit control over that, but 46 * the hints and access flags we set for typical access patterns on 47 * dynamic resources should in theory have the same effect on the OpenGL 48 * driver. */ 49 50 if (usage & ~handled) 51 { 52 FIXME("Unhandled usage flags %#x.\n", usage & ~handled); 53 handled |= usage; 54 } 55 if ((usage & (WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY)) == WINED3DUSAGE_DYNAMIC) 56 WARN_(d3d_perf)("WINED3DUSAGE_DYNAMIC used without WINED3DUSAGE_WRITEONLY.\n"); 57 } 58 59 HRESULT resource_init(struct wined3d_resource *resource, struct wined3d_device *device, 60 enum wined3d_resource_type type, const struct wined3d_format *format, 61 enum wined3d_multisample_type multisample_type, unsigned int multisample_quality, 62 unsigned int usage, unsigned int access, unsigned int width, unsigned int height, unsigned int depth, 63 unsigned int size, void *parent, const struct wined3d_parent_ops *parent_ops, 64 const struct wined3d_resource_ops *resource_ops) 65 { 66 enum wined3d_gl_resource_type base_type = WINED3D_GL_RES_TYPE_COUNT; 67 enum wined3d_gl_resource_type gl_type = WINED3D_GL_RES_TYPE_COUNT; 68 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; 69 BOOL tex_2d_ok = FALSE; 70 unsigned int i; 71 72 static const struct 73 { 74 enum wined3d_resource_type type; 75 DWORD cube_usage; 76 enum wined3d_gl_resource_type gl_type; 77 } 78 resource_types[] = 79 { 80 {WINED3D_RTYPE_BUFFER, 0, WINED3D_GL_RES_TYPE_BUFFER}, 81 {WINED3D_RTYPE_TEXTURE_1D, 0, WINED3D_GL_RES_TYPE_TEX_1D}, 82 {WINED3D_RTYPE_TEXTURE_2D, 0, WINED3D_GL_RES_TYPE_TEX_2D}, 83 {WINED3D_RTYPE_TEXTURE_2D, 0, WINED3D_GL_RES_TYPE_TEX_RECT}, 84 {WINED3D_RTYPE_TEXTURE_2D, 0, WINED3D_GL_RES_TYPE_RB}, 85 {WINED3D_RTYPE_TEXTURE_2D, WINED3DUSAGE_LEGACY_CUBEMAP, WINED3D_GL_RES_TYPE_TEX_CUBE}, 86 {WINED3D_RTYPE_TEXTURE_3D, 0, WINED3D_GL_RES_TYPE_TEX_3D}, 87 }; 88 89 resource_check_usage(usage); 90 91 if (usage & WINED3DUSAGE_SCRATCH && access & WINED3D_RESOURCE_ACCESS_GPU) 92 { 93 ERR("Trying to create a scratch resource with access flags %s.\n", 94 wined3d_debug_resource_access(access)); 95 return WINED3DERR_INVALIDCALL; 96 } 97 98 for (i = 0; i < ARRAY_SIZE(resource_types); ++i) 99 { 100 if (resource_types[i].type != type 101 || resource_types[i].cube_usage != (usage & WINED3DUSAGE_LEGACY_CUBEMAP)) 102 continue; 103 104 gl_type = resource_types[i].gl_type; 105 if (base_type == WINED3D_GL_RES_TYPE_COUNT) 106 base_type = gl_type; 107 108 if ((usage & WINED3DUSAGE_RENDERTARGET) && !(format->flags[gl_type] & WINED3DFMT_FLAG_RENDERTARGET)) 109 { 110 WARN("Format %s cannot be used for render targets.\n", debug_d3dformat(format->id)); 111 continue; 112 } 113 if ((usage & WINED3DUSAGE_DEPTHSTENCIL) 114 && !(format->flags[gl_type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))) 115 { 116 WARN("Format %s cannot be used for depth/stencil buffers.\n", debug_d3dformat(format->id)); 117 continue; 118 } 119 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO 120 && usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL) 121 && !(format->flags[gl_type] & WINED3DFMT_FLAG_FBO_ATTACHABLE)) 122 { 123 WARN("Render target or depth stencil is not FBO attachable.\n"); 124 continue; 125 } 126 if ((usage & WINED3DUSAGE_TEXTURE) && !(format->flags[gl_type] & WINED3DFMT_FLAG_TEXTURE)) 127 { 128 WARN("Format %s cannot be used for texturing.\n", debug_d3dformat(format->id)); 129 continue; 130 } 131 if (((width & (width - 1)) || (height & (height - 1))) 132 && !gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] 133 && !gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] 134 && gl_type == WINED3D_GL_RES_TYPE_TEX_2D) 135 { 136 TRACE("Skipping 2D texture type to try texture rectangle.\n"); 137 tex_2d_ok = TRUE; 138 continue; 139 } 140 break; 141 } 142 143 if (base_type != WINED3D_GL_RES_TYPE_COUNT && i == ARRAY_SIZE(resource_types)) 144 { 145 if (tex_2d_ok) 146 { 147 /* Non power of 2 texture and rectangle textures or renderbuffers do not work. 148 * Use 2D textures, the texture code will pad to a power of 2 size. */ 149 gl_type = WINED3D_GL_RES_TYPE_TEX_2D; 150 } 151 else if (usage & WINED3DUSAGE_SCRATCH) 152 { 153 /* Needed for proper format information. */ 154 gl_type = base_type; 155 } 156 else 157 { 158 WARN("Did not find a suitable GL resource type for resource type %s.\n", 159 debug_d3dresourcetype(type)); 160 return WINED3DERR_INVALIDCALL; 161 } 162 } 163 164 if (base_type != WINED3D_GL_RES_TYPE_COUNT 165 && (format->flags[base_type] & (WINED3DFMT_FLAG_BLOCKS | WINED3DFMT_FLAG_BLOCKS_NO_VERIFY)) 166 == WINED3DFMT_FLAG_BLOCKS) 167 { 168 UINT width_mask = format->block_width - 1; 169 UINT height_mask = format->block_height - 1; 170 if (width & width_mask || height & height_mask) 171 return WINED3DERR_INVALIDCALL; 172 } 173 174 resource->ref = 1; 175 resource->device = device; 176 resource->type = type; 177 resource->gl_type = gl_type; 178 resource->format = format; 179 if (gl_type < WINED3D_GL_RES_TYPE_COUNT) 180 resource->format_flags = format->flags[gl_type]; 181 resource->multisample_type = multisample_type; 182 resource->multisample_quality = multisample_quality; 183 resource->usage = usage; 184 resource->access = access; 185 resource->width = width; 186 resource->height = height; 187 resource->depth = depth; 188 resource->size = size; 189 resource->priority = 0; 190 resource->parent = parent; 191 resource->parent_ops = parent_ops; 192 resource->resource_ops = resource_ops; 193 resource->map_binding = WINED3D_LOCATION_SYSMEM; 194 195 if (size) 196 { 197 if (!wined3d_resource_allocate_sysmem(resource)) 198 { 199 ERR("Failed to allocate system memory.\n"); 200 return E_OUTOFMEMORY; 201 } 202 } 203 else 204 { 205 resource->heap_memory = NULL; 206 } 207 208 if (!(usage & WINED3DUSAGE_PRIVATE)) 209 { 210 /* Check that we have enough video ram left */ 211 if (!(access & WINED3D_RESOURCE_ACCESS_CPU) && device->wined3d->flags & WINED3D_VIDMEM_ACCOUNTING) 212 { 213 if (size > wined3d_device_get_available_texture_mem(device)) 214 { 215 ERR("Out of adapter memory\n"); 216 wined3d_resource_free_sysmem(resource); 217 return WINED3DERR_OUTOFVIDEOMEMORY; 218 } 219 adapter_adjust_memory(device->adapter, size); 220 } 221 222 device_resource_add(device, resource); 223 } 224 225 return WINED3D_OK; 226 } 227 228 static void wined3d_resource_destroy_object(void *object) 229 { 230 struct wined3d_resource *resource = object; 231 232 wined3d_resource_free_sysmem(resource); 233 context_resource_released(resource->device, resource, resource->type); 234 wined3d_resource_release(resource); 235 } 236 237 void resource_cleanup(struct wined3d_resource *resource) 238 { 239 const struct wined3d *d3d = resource->device->wined3d; 240 241 TRACE("Cleaning up resource %p.\n", resource); 242 243 if (!(resource->usage & WINED3DUSAGE_PRIVATE)) 244 { 245 if (!(resource->access & WINED3D_RESOURCE_ACCESS_CPU) && d3d->flags & WINED3D_VIDMEM_ACCOUNTING) 246 { 247 TRACE("Decrementing device memory pool by %u.\n", resource->size); 248 adapter_adjust_memory(resource->device->adapter, (INT64)0 - resource->size); 249 } 250 251 device_resource_released(resource->device, resource); 252 } 253 wined3d_resource_acquire(resource); 254 wined3d_cs_destroy_object(resource->device->cs, wined3d_resource_destroy_object, resource); 255 } 256 257 void resource_unload(struct wined3d_resource *resource) 258 { 259 if (resource->map_count) 260 ERR("Resource %p is being unloaded while mapped.\n", resource); 261 } 262 263 DWORD CDECL wined3d_resource_set_priority(struct wined3d_resource *resource, DWORD priority) 264 { 265 DWORD prev; 266 267 if (!wined3d_resource_access_is_managed(resource->access)) 268 { 269 WARN("Called on non-managed resource %p, ignoring.\n", resource); 270 return 0; 271 } 272 273 prev = resource->priority; 274 resource->priority = priority; 275 TRACE("resource %p, new priority %u, returning old priority %u.\n", resource, priority, prev); 276 return prev; 277 } 278 279 DWORD CDECL wined3d_resource_get_priority(const struct wined3d_resource *resource) 280 { 281 TRACE("resource %p, returning %u.\n", resource, resource->priority); 282 return resource->priority; 283 } 284 285 void * CDECL wined3d_resource_get_parent(const struct wined3d_resource *resource) 286 { 287 return resource->parent; 288 } 289 290 void CDECL wined3d_resource_set_parent(struct wined3d_resource *resource, void *parent) 291 { 292 resource->parent = parent; 293 } 294 295 void CDECL wined3d_resource_get_desc(const struct wined3d_resource *resource, struct wined3d_resource_desc *desc) 296 { 297 desc->resource_type = resource->type; 298 desc->format = resource->format->id; 299 desc->multisample_type = resource->multisample_type; 300 desc->multisample_quality = resource->multisample_quality; 301 desc->usage = resource->usage; 302 desc->access = resource->access; 303 desc->width = resource->width; 304 desc->height = resource->height; 305 desc->depth = resource->depth; 306 desc->size = resource->size; 307 } 308 309 static DWORD wined3d_resource_sanitise_map_flags(const struct wined3d_resource *resource, DWORD flags) 310 { 311 /* Not all flags make sense together, but Windows never returns an error. 312 * Catch the cases that could cause issues. */ 313 if (flags & WINED3D_MAP_READ) 314 { 315 if (flags & WINED3D_MAP_DISCARD) 316 { 317 WARN("WINED3D_MAP_READ combined with WINED3D_MAP_DISCARD, ignoring flags.\n"); 318 return flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE); 319 } 320 if (flags & WINED3D_MAP_NOOVERWRITE) 321 { 322 WARN("WINED3D_MAP_READ combined with WINED3D_MAP_NOOVERWRITE, ignoring flags.\n"); 323 return flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE); 324 } 325 } 326 else if (flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE)) 327 { 328 if (!(resource->usage & WINED3DUSAGE_DYNAMIC)) 329 { 330 WARN("DISCARD or NOOVERWRITE map on non-dynamic buffer, ignoring.\n"); 331 return flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE); 332 } 333 if ((flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE)) 334 == (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE)) 335 { 336 WARN("WINED3D_MAP_NOOVERWRITE used with WINED3D_MAP_DISCARD, ignoring WINED3D_MAP_DISCARD.\n"); 337 flags &= ~WINED3D_MAP_DISCARD; 338 } 339 } 340 341 return flags; 342 } 343 344 HRESULT CDECL wined3d_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx, 345 struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags) 346 { 347 TRACE("resource %p, sub_resource_idx %u, map_desc %p, box %s, flags %#x.\n", 348 resource, sub_resource_idx, map_desc, debug_box(box), flags); 349 350 if (!(flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE))) 351 { 352 WARN("No read/write flags specified.\n"); 353 return E_INVALIDARG; 354 } 355 356 if ((flags & WINED3D_MAP_READ) && !(resource->access & WINED3D_RESOURCE_ACCESS_MAP_R)) 357 { 358 WARN("Resource does not have MAP_R access.\n"); 359 return E_INVALIDARG; 360 } 361 362 if ((flags & WINED3D_MAP_WRITE) && !(resource->access & WINED3D_RESOURCE_ACCESS_MAP_W)) 363 { 364 WARN("Resource does not have MAP_W access.\n"); 365 return E_INVALIDARG; 366 } 367 368 flags = wined3d_resource_sanitise_map_flags(resource, flags); 369 wined3d_resource_wait_idle(resource); 370 371 return wined3d_cs_map(resource->device->cs, resource, sub_resource_idx, map_desc, box, flags); 372 } 373 374 HRESULT CDECL wined3d_resource_map_info(struct wined3d_resource *resource, unsigned int sub_resource_idx, 375 struct wined3d_map_info *info, DWORD flags) 376 { 377 TRACE("resource %p, sub_resource_idx %u.\n", resource, sub_resource_idx); 378 379 return resource->resource_ops->resource_map_info(resource, sub_resource_idx, info, flags); 380 } 381 382 HRESULT CDECL wined3d_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx) 383 { 384 TRACE("resource %p, sub_resource_idx %u.\n", resource, sub_resource_idx); 385 386 return wined3d_cs_unmap(resource->device->cs, resource, sub_resource_idx); 387 } 388 389 UINT CDECL wined3d_resource_update_info(struct wined3d_resource *resource, unsigned int sub_resource_idx, 390 const struct wined3d_box *box, unsigned int row_pitch, unsigned int depth_pitch) 391 { 392 unsigned int width, height, depth; 393 struct wined3d_box b; 394 UINT data_size; 395 396 TRACE("resource %p, sub_resource_idx %u, box %s, row_pitch %u, depth_pitch %u.\n", 397 resource, sub_resource_idx, debug_box(box), row_pitch, depth_pitch); 398 399 if (resource->type == WINED3D_RTYPE_BUFFER) 400 { 401 if (sub_resource_idx > 0) 402 { 403 WARN("Invalid sub_resource_idx %u.\n", sub_resource_idx); 404 return 0; 405 } 406 407 width = resource->size; 408 height = 1; 409 depth = 1; 410 } 411 else if (resource->type == WINED3D_RTYPE_TEXTURE_1D || 412 resource->type == WINED3D_RTYPE_TEXTURE_2D || resource->type == WINED3D_RTYPE_TEXTURE_3D) 413 { 414 struct wined3d_texture *texture = texture_from_resource(resource); 415 unsigned int level; 416 417 if (sub_resource_idx >= texture->level_count * texture->layer_count) 418 { 419 WARN("Invalid sub_resource_idx %u.\n", sub_resource_idx); 420 return 0; 421 } 422 423 level = sub_resource_idx % texture->level_count; 424 width = wined3d_texture_get_level_width(texture, level); 425 height = wined3d_texture_get_level_height(texture, level); 426 depth = wined3d_texture_get_level_depth(texture, level); 427 } 428 else 429 { 430 FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type)); 431 return 0; 432 } 433 434 if (!box) 435 { 436 wined3d_box_set(&b, 0, 0, width, height, 0, depth); 437 box = &b; 438 } 439 else if (box->left >= box->right || box->right > width 440 || box->top >= box->bottom || box->bottom > height 441 || box->front >= box->back || box->back > depth) 442 { 443 WARN("Invalid box %s specified.\n", debug_box(box)); 444 return 0; 445 } 446 447 if (resource->format_flags & WINED3DFMT_FLAG_BLOCKS) 448 { 449 if (resource->type != WINED3D_RTYPE_TEXTURE_2D) 450 { 451 FIXME("Calculation of block formats not implemented for %s resources.\n", debug_d3dresourcetype(resource->type)); 452 return 0; 453 } 454 455 height = (box->bottom - box->top + resource->format->block_height - 1) / resource->format->block_height; 456 width = (box->right - box->left + resource->format->block_width - 1) / resource->format->block_width; 457 return (height - 1) * row_pitch + width * resource->format->block_byte_count; 458 } 459 460 data_size = 0; 461 switch (resource->type) 462 { 463 case WINED3D_RTYPE_TEXTURE_3D: 464 data_size += (box->back - box->front - 1) * depth_pitch; 465 /* fall-through */ 466 case WINED3D_RTYPE_TEXTURE_2D: 467 data_size += (box->bottom - box->top - 1) * row_pitch; 468 /* fall-through */ 469 case WINED3D_RTYPE_TEXTURE_1D: 470 data_size += (box->right - box->left) * resource->format->byte_count; 471 break; 472 case WINED3D_RTYPE_BUFFER: 473 data_size = box->right - box->left; 474 break; 475 case WINED3D_RTYPE_NONE: 476 break; 477 } 478 479 return data_size; 480 } 481 482 void CDECL wined3d_resource_preload(struct wined3d_resource *resource) 483 { 484 wined3d_cs_emit_preload_resource(resource->device->cs, resource); 485 } 486 487 BOOL wined3d_resource_allocate_sysmem(struct wined3d_resource *resource) 488 { 489 void **p; 490 SIZE_T align = RESOURCE_ALIGNMENT - 1 + sizeof(*p); 491 void *mem; 492 493 if (!(mem = heap_alloc_zero(resource->size + align))) 494 return FALSE; 495 496 p = (void **)(((ULONG_PTR)mem + align) & ~(RESOURCE_ALIGNMENT - 1)) - 1; 497 *p = mem; 498 499 resource->heap_memory = ++p; 500 501 return TRUE; 502 } 503 504 void wined3d_resource_free_sysmem(struct wined3d_resource *resource) 505 { 506 void **p = resource->heap_memory; 507 508 if (!p) 509 return; 510 511 heap_free(*(--p)); 512 resource->heap_memory = NULL; 513 } 514 515 GLbitfield wined3d_resource_gl_map_flags(DWORD d3d_flags) 516 { 517 GLbitfield ret = 0; 518 519 if (d3d_flags & WINED3D_MAP_WRITE) 520 ret |= GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT; 521 if (d3d_flags & WINED3D_MAP_READ) 522 ret |= GL_MAP_READ_BIT; 523 524 if (d3d_flags & WINED3D_MAP_DISCARD) 525 ret |= GL_MAP_INVALIDATE_BUFFER_BIT; 526 if (d3d_flags & WINED3D_MAP_NOOVERWRITE) 527 ret |= GL_MAP_UNSYNCHRONIZED_BIT; 528 529 return ret; 530 } 531 532 GLenum wined3d_resource_gl_legacy_map_flags(DWORD d3d_flags) 533 { 534 switch (d3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE)) 535 { 536 case WINED3D_MAP_READ: 537 return GL_READ_ONLY_ARB; 538 539 case WINED3D_MAP_WRITE: 540 return GL_WRITE_ONLY_ARB; 541 542 default: 543 return GL_READ_WRITE_ARB; 544 } 545 } 546 547 BOOL wined3d_resource_is_offscreen(struct wined3d_resource *resource) 548 { 549 struct wined3d_swapchain *swapchain; 550 551 /* Only 2D texture resources can be onscreen. */ 552 if (resource->type != WINED3D_RTYPE_TEXTURE_2D) 553 return TRUE; 554 555 /* Not on a swapchain - must be offscreen */ 556 if (!(swapchain = texture_from_resource(resource)->swapchain)) 557 return TRUE; 558 559 /* The front buffer is always onscreen */ 560 if (resource == &swapchain->front_buffer->resource) 561 return FALSE; 562 563 /* If the swapchain is rendered to an FBO, the backbuffer is 564 * offscreen, otherwise onscreen */ 565 return swapchain->render_to_fbo; 566 } 567 568 void wined3d_resource_update_draw_binding(struct wined3d_resource *resource) 569 { 570 if (!wined3d_resource_is_offscreen(resource) || wined3d_settings.offscreen_rendering_mode != ORM_FBO) 571 { 572 resource->draw_binding = WINED3D_LOCATION_DRAWABLE; 573 } 574 else if (resource->multisample_type) 575 { 576 const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info; 577 if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE]) 578 resource->draw_binding = WINED3D_LOCATION_TEXTURE_RGB; 579 else 580 resource->draw_binding = WINED3D_LOCATION_RB_MULTISAMPLE; 581 } 582 else if (resource->gl_type == WINED3D_GL_RES_TYPE_RB) 583 { 584 resource->draw_binding = WINED3D_LOCATION_RB_RESOLVED; 585 } 586 else 587 { 588 resource->draw_binding = WINED3D_LOCATION_TEXTURE_RGB; 589 } 590 } 591