dlls/wined3d/volume.c

   1 /*
   2  * Copyright 2002-2005 Jason Edmeades
   3  * Copyright 2002-2005 Raphael Junqueira
   4  * Copyright 2005 Oliver Stieber
   5  * Copyright 2009-2011 Henri Verbeet for CodeWeavers
   6  * Copyright 2013 Stefan Dösinger for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25 #include "wined3d_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
  28 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
  29
  30 /* Context activation is done by the caller. */
  31 static void volume_bind_and_dirtify(const struct wined3d_volume *volume,
  32         struct wined3d_context *context, BOOL srgb)
  33 {
  34     struct wined3d_texture *container = volume->container;
  35     DWORD active_sampler;
  36
  37     /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
  38      * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
  39      * gl states. The current texture unit should always be a valid one.
  40      *
  41      * To be more specific, this is tricky because we can implicitly be called
  42      * from sampler() in state.c. This means we can't touch anything other than
  43      * whatever happens to be the currently active texture, or we would risk
  44      * marking already applied sampler states dirty again. */
  45     active_sampler = volume->resource.device->rev_tex_unit_map[context->active_texture];
  46
  47     if (active_sampler != WINED3D_UNMAPPED_STAGE)
  48         device_invalidate_state(volume->resource.device, STATE_SAMPLER(active_sampler));
  49
  50     container->texture_ops->texture_bind(container, context, srgb);
  51 }
  52
  53 void volume_set_container(struct wined3d_volume *volume, struct wined3d_texture *container)
  54 {
  55     TRACE("volume %p, container %p.\n", volume, container);
  56
  57     volume->container = container;
  58 }
  59
  60 /* Context activation is done by the caller. */
  61 static void wined3d_volume_allocate_texture(const struct wined3d_volume *volume,
  62         const struct wined3d_context *context, BOOL srgb)
  63 {
  64     const struct wined3d_gl_info *gl_info = context->gl_info;
  65     const struct wined3d_format *format = volume->resource.format;
  66
  67     GL_EXTCALL(glTexImage3DEXT(GL_TEXTURE_3D, volume->texture_level,
  68             srgb ? format->glGammaInternal : format->glInternal,
  69             volume->resource.width, volume->resource.height, volume->resource.depth,
  70             0, format->glFormat, format->glType, NULL));
  71     checkGLcall("glTexImage3D");
  72 }
  73
  74 /* Context activation is done by the caller. */
  75 void wined3d_volume_upload_data(struct wined3d_volume *volume, const struct wined3d_context *context,
  76         const struct wined3d_bo_address *data)
  77 {
  78     const struct wined3d_gl_info *gl_info = context->gl_info;
  79     const struct wined3d_format *format = volume->resource.format;
  80
  81     TRACE("volume %p, context %p, level %u, format %s (%#x).\n",
  82             volume, context, volume->texture_level, debug_d3dformat(format->id),
  83             format->id);
  84
  85
  86     if (data->buffer_object)
  87     {
  88         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, data->buffer_object));
  89         checkGLcall("glBindBufferARB");
  90     }
  91
  92     GL_EXTCALL(glTexSubImage3DEXT(GL_TEXTURE_3D, volume->texture_level, 0, 0, 0,
  93             volume->resource.width, volume->resource.height, volume->resource.depth,
  94             format->glFormat, format->glType, data->addr));
  95     checkGLcall("glTexSubImage3D");
  96
  97     if (data->buffer_object)
  98     {
  99         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 100         checkGLcall("glBindBufferARB");
 101     }
 102 }
 103
 104 static void wined3d_volume_validate_location(struct wined3d_volume *volume, DWORD location)
 105 {
 106     TRACE("Volume %p, setting %s.\n", volume, wined3d_debug_location(location));
 107     volume->locations |= location;
 108     TRACE("new location flags are %s.\n", wined3d_debug_location(volume->locations));
 109 }
 110
 111 void wined3d_volume_invalidate_location(struct wined3d_volume *volume, DWORD location)
 112 {
 113     TRACE("Volume %p, clearing %s.\n", volume, wined3d_debug_location(location));
 114     volume->locations &= ~location;
 115     TRACE("new location flags are %s.\n", wined3d_debug_location(volume->locations));
 116 }
 117
 118 /* Context activation is done by the caller. */
 119 static void wined3d_volume_download_data(struct wined3d_volume *volume,
 120         const struct wined3d_context *context, const struct wined3d_bo_address *data)
 121 {
 122     const struct wined3d_gl_info *gl_info = context->gl_info;
 123     const struct wined3d_format *format = volume->resource.format;
 124
 125     if (data->buffer_object)
 126     {
 127         GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, data->buffer_object));
 128         checkGLcall("glBindBufferARB");
 129     }
 130
 131     gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_3D, volume->texture_level,
 132             format->glFormat, format->glType, data->addr);
 133     checkGLcall("glGetTexImage");
 134
 135     if (data->buffer_object)
 136     {
 137         GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
 138         checkGLcall("glBindBufferARB");
 139     }
 140
 141 }
 142
 143 static void wined3d_volume_evict_sysmem(struct wined3d_volume *volume)
 144 {
 145     wined3d_resource_free_sysmem(volume->resource.heap_memory);
 146     volume->resource.heap_memory = NULL;
 147     volume->resource.allocatedMemory = NULL;
 148     wined3d_volume_invalidate_location(volume, WINED3D_LOCATION_SYSMEM);
 149 }
 150
 151 static DWORD volume_access_from_location(DWORD location)
 152 {
 153     switch (location)
 154     {
 155         case WINED3D_LOCATION_DISCARDED:
 156             return 0;
 157
 158         case WINED3D_LOCATION_SYSMEM:
 159             return WINED3D_RESOURCE_ACCESS_CPU;
 160
 161         case WINED3D_LOCATION_BUFFER:
 162         case WINED3D_LOCATION_TEXTURE_RGB:
 163         case WINED3D_LOCATION_TEXTURE_SRGB:
 164             return WINED3D_RESOURCE_ACCESS_GPU;
 165
 166         default:
 167             FIXME("Unhandled location %#x.\n", location);
 168             return 0;
 169     }
 170 }
 171
 172 /* Context activation is done by the caller. */
 173 static void wined3d_volume_srgb_transfer(struct wined3d_volume *volume,
 174         struct wined3d_context *context, BOOL dest_is_srgb)
 175 {
 176     struct wined3d_bo_address data;
 177     /* Optimizations are possible, but the effort should be put into either
 178      * implementing EXT_SRGB_DECODE in the driver or finding out why we
 179      * picked the wrong copy for the original upload and fixing that.
 180      *
 181      * Also keep in mind that we want to avoid using resource.allocatedMemory
 182      * for DEFAULT pool surfaces. */
 183
 184     WARN_(d3d_perf)("Performing slow rgb/srgb volume transfer.\n");
 185     data.buffer_object = 0;
 186     data.addr = HeapAlloc(GetProcessHeap(), 0, volume->resource.size);
 187     if (!data.addr)
 188         return;
 189
 190     volume_bind_and_dirtify(volume, context, !dest_is_srgb);
 191     wined3d_volume_download_data(volume, context, &data);
 192     volume_bind_and_dirtify(volume, context, dest_is_srgb);
 193     wined3d_volume_upload_data(volume, context, &data);
 194
 195     HeapFree(GetProcessHeap(), 0, data.addr);
 196 }
 197
 198 /* Context activation is done by the caller. */
 199 static void wined3d_volume_load_location(struct wined3d_volume *volume,
 200         struct wined3d_context *context, DWORD location)
 201 {
 202     DWORD required_access = volume_access_from_location(location);
 203
 204     TRACE("Volume %p, loading %s, have %s.\n", volume, wined3d_debug_location(location),
 205         wined3d_debug_location(volume->locations));
 206
 207     if ((volume->locations & location) == location)
 208     {
 209         TRACE("Location(s) already up to date.\n");
 210         return;
 211     }
 212
 213     if ((volume->resource.access_flags & required_access) != required_access)
 214     {
 215         ERR("Operation requires %#x access, but volume only has %#x.\n",
 216                 required_access, volume->resource.access_flags);
 217         return;
 218     }
 219
 220     switch (location)
 221     {
 222         case WINED3D_LOCATION_TEXTURE_RGB:
 223         case WINED3D_LOCATION_TEXTURE_SRGB:
 224             if ((location == WINED3D_LOCATION_TEXTURE_RGB
 225                     && !(volume->flags & WINED3D_VFLAG_ALLOCATED))
 226                     || (location == WINED3D_LOCATION_TEXTURE_SRGB
 227                     && !(volume->flags & WINED3D_VFLAG_SRGB_ALLOCATED)))
 228                 ERR("Trying to load (s)RGB texture without prior allocation.\n");
 229
 230             if (volume->locations & WINED3D_LOCATION_DISCARDED)
 231             {
 232                 TRACE("Volume previously discarded, nothing to do.\n");
 233                 wined3d_volume_invalidate_location(volume, WINED3D_LOCATION_DISCARDED);
 234             }
 235             else if (volume->locations & WINED3D_LOCATION_SYSMEM)
 236             {
 237                 struct wined3d_bo_address data = {0, volume->resource.allocatedMemory};
 238                 wined3d_volume_upload_data(volume, context, &data);
 239             }
 240             else if (volume->locations & WINED3D_LOCATION_BUFFER)
 241             {
 242                 struct wined3d_bo_address data = {volume->pbo, NULL};
 243                 wined3d_volume_upload_data(volume, context, &data);
 244             }
 245             else if (volume->locations & WINED3D_LOCATION_TEXTURE_RGB)
 246             {
 247                 wined3d_volume_srgb_transfer(volume, context, TRUE);
 248             }
 249             else if (volume->locations & WINED3D_LOCATION_TEXTURE_SRGB)
 250             {
 251                 wined3d_volume_srgb_transfer(volume, context, FALSE);
 252             }
 253             else
 254             {
 255                 FIXME("Implement texture loading from %s.\n", wined3d_debug_location(volume->locations));
 256                 return;
 257             }
 258             wined3d_volume_validate_location(volume, location);
 259
 260             if (volume->resource.pool == WINED3D_POOL_MANAGED && volume->download_count < 10)
 261                 wined3d_volume_evict_sysmem(volume);
 262
 263             break;
 264
 265         case WINED3D_LOCATION_SYSMEM:
 266             if (!volume->resource.allocatedMemory || !volume->resource.heap_memory)
 267             {
 268                 ERR("Trying to load WINED3D_LOCATION_SYSMEM without setting it up first.\n");
 269                 return;
 270             }
 271
 272             if (volume->locations & WINED3D_LOCATION_DISCARDED)
 273             {
 274                 TRACE("Volume previously discarded, nothing to do.\n");
 275                 wined3d_volume_invalidate_location(volume, WINED3D_LOCATION_DISCARDED);
 276             }
 277             else if (volume->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
 278             {
 279                 struct wined3d_bo_address data = {0, volume->resource.allocatedMemory};
 280
 281                 if (volume->locations & WINED3D_LOCATION_TEXTURE_RGB)
 282                     volume_bind_and_dirtify(volume, context, FALSE);
 283                 else
 284                     volume_bind_and_dirtify(volume, context, TRUE);
 285
 286                 volume->download_count++;
 287                 wined3d_volume_download_data(volume, context, &data);
 288             }
 289             else
 290             {
 291                 FIXME("Implement WINED3D_LOCATION_SYSMEM loading from %s.\n",
 292                         wined3d_debug_location(volume->locations));
 293                 return;
 294             }
 295             wined3d_volume_validate_location(volume, WINED3D_LOCATION_SYSMEM);
 296             break;
 297
 298         case WINED3D_LOCATION_BUFFER:
 299             if (!volume->pbo || !(volume->flags & WINED3D_VFLAG_PBO))
 300                 ERR("Trying to load WINED3D_LOCATION_BUFFER without setting it up first.\n");
 301
 302             if (volume->locations & WINED3D_LOCATION_DISCARDED)
 303             {
 304                 TRACE("Volume previously discarded, nothing to do.\n");
 305                 wined3d_volume_invalidate_location(volume, WINED3D_LOCATION_DISCARDED);
 306             }
 307             else if (volume->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
 308             {
 309                 struct wined3d_bo_address data = {volume->pbo, NULL};
 310
 311                 if (volume->locations & WINED3D_LOCATION_TEXTURE_RGB)
 312                     volume_bind_and_dirtify(volume, context, FALSE);
 313                 else
 314                     volume_bind_and_dirtify(volume, context, TRUE);
 315
 316                 wined3d_volume_download_data(volume, context, &data);
 317             }
 318             else
 319             {
 320                 FIXME("Implement WINED3D_LOCATION_BUFFER loading from %s.\n",
 321                         wined3d_debug_location(volume->locations));
 322                 return;
 323             }
 324             wined3d_volume_validate_location(volume, WINED3D_LOCATION_BUFFER);
 325             break;
 326
 327         default:
 328             FIXME("Implement %s loading from %s.\n", wined3d_debug_location(location),
 329                     wined3d_debug_location(volume->locations));
 330     }
 331 }
 332
 333 /* Context activation is done by the caller. */
 334 void wined3d_volume_load(struct wined3d_volume *volume, struct wined3d_context *context, BOOL srgb_mode)
 335 {
 336     volume_bind_and_dirtify(volume, context, srgb_mode);
 337
 338     if (srgb_mode)
 339     {
 340         if (!(volume->flags & WINED3D_VFLAG_SRGB_ALLOCATED))
 341         {
 342             wined3d_volume_allocate_texture(volume, context, TRUE);
 343             volume->flags |= WINED3D_VFLAG_SRGB_ALLOCATED;
 344         }
 345
 346         wined3d_volume_load_location(volume, context, WINED3D_LOCATION_TEXTURE_SRGB);
 347     }
 348     else
 349     {
 350         if (!(volume->flags & WINED3D_VFLAG_ALLOCATED))
 351         {
 352             wined3d_volume_allocate_texture(volume, context, FALSE);
 353             volume->flags |= WINED3D_VFLAG_ALLOCATED;
 354         }
 355
 356         wined3d_volume_load_location(volume, context, WINED3D_LOCATION_TEXTURE_RGB);
 357     }
 358 }
 359
 360 /* Context activation is done by the caller. */
 361 static void wined3d_volume_prepare_pbo(struct wined3d_volume *volume, struct wined3d_context *context)
 362 {
 363     const struct wined3d_gl_info *gl_info = context->gl_info;
 364
 365     if (volume->pbo)
 366         return;
 367
 368     GL_EXTCALL(glGenBuffersARB(1, &volume->pbo));
 369     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, volume->pbo));
 370     GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, volume->resource.size, NULL, GL_STREAM_DRAW_ARB));
 371     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 372     checkGLcall("Create PBO");
 373
 374     TRACE("Created PBO %u for volume %p.\n", volume->pbo, volume);
 375 }
 376
 377 static void wined3d_volume_free_pbo(struct wined3d_volume *volume)
 378 {
 379     struct wined3d_context *context = context_acquire(volume->resource.device, NULL);
 380     const struct wined3d_gl_info *gl_info = context->gl_info;
 381
 382     TRACE("Deleting PBO %u belonging to volume %p.\n", volume->pbo, volume);
 383     GL_EXTCALL(glDeleteBuffersARB(1, &volume->pbo));
 384     checkGLcall("glDeleteBuffersARB");
 385     volume->pbo = 0;
 386     context_release(context);
 387 }
 388
 389 static BOOL volume_prepare_system_memory(struct wined3d_volume *volume)
 390 {
 391     if (volume->resource.allocatedMemory)
 392         return TRUE;
 393
 394     volume->resource.heap_memory = wined3d_resource_allocate_sysmem(volume->resource.size);
 395     if (!volume->resource.heap_memory)
 396         return FALSE;
 397     volume->resource.allocatedMemory = volume->resource.heap_memory;
 398     return TRUE;
 399 }
 400
 401
 402 static void volume_unload(struct wined3d_resource *resource)
 403 {
 404     struct wined3d_volume *volume = volume_from_resource(resource);
 405     struct wined3d_device *device = volume->resource.device;
 406     struct wined3d_context *context;
 407
 408     if (volume->resource.pool == WINED3D_POOL_DEFAULT)
 409         ERR("Unloading DEFAULT pool volume.\n");
 410
 411     TRACE("texture %p.\n", resource);
 412
 413     if (volume_prepare_system_memory(volume))
 414     {
 415         context = context_acquire(device, NULL);
 416         wined3d_volume_load_location(volume, context, WINED3D_LOCATION_SYSMEM);
 417         context_release(context);
 418         wined3d_volume_invalidate_location(volume, ~WINED3D_LOCATION_SYSMEM);
 419     }
 420     else
 421     {
 422         ERR("Out of memory when unloading volume %p.\n", volume);
 423         wined3d_volume_validate_location(volume, WINED3D_LOCATION_DISCARDED);
 424         wined3d_volume_invalidate_location(volume, ~WINED3D_LOCATION_DISCARDED);
 425     }
 426
 427     if (volume->pbo)
 428     {
 429         /* Should not happen because only dynamic default pool volumes
 430          * have a buffer, and those are not evicted by device_evit_managed_resources
 431          * and must be freed before a non-ex device reset. */
 432         ERR("Unloading a volume with a buffer\n");
 433         wined3d_volume_free_pbo(volume);
 434     }
 435
 436     /* The texture name is managed by the container. */
 437     volume->flags &= ~(WINED3D_VFLAG_ALLOCATED | WINED3D_VFLAG_SRGB_ALLOCATED);
 438
 439     resource_unload(resource);
 440 }
 441
 442 ULONG CDECL wined3d_volume_incref(struct wined3d_volume *volume)
 443 {
 444     ULONG refcount;
 445
 446     if (volume->container)
 447     {
 448         TRACE("Forwarding to container %p.\n", volume->container);
 449         return wined3d_texture_incref(volume->container);
 450     }
 451
 452     refcount = InterlockedIncrement(&volume->resource.ref);
 453
 454     TRACE("%p increasing refcount to %u.\n", volume, refcount);
 455
 456     return refcount;
 457 }
 458
 459 ULONG CDECL wined3d_volume_decref(struct wined3d_volume *volume)
 460 {
 461     ULONG refcount;
 462
 463     if (volume->container)
 464     {
 465         TRACE("Forwarding to container %p.\n", volume->container);
 466         return wined3d_texture_decref(volume->container);
 467     }
 468
 469     refcount = InterlockedDecrement(&volume->resource.ref);
 470
 471     TRACE("%p decreasing refcount to %u.\n", volume, refcount);
 472
 473     if (!refcount)
 474     {
 475         if (volume->pbo)
 476             wined3d_volume_free_pbo(volume);
 477
 478         resource_cleanup(&volume->resource);
 479         volume->resource.parent_ops->wined3d_object_destroyed(volume->resource.parent);
 480         HeapFree(GetProcessHeap(), 0, volume);
 481     }
 482
 483     return refcount;
 484 }
 485
 486 void * CDECL wined3d_volume_get_parent(const struct wined3d_volume *volume)
 487 {
 488     TRACE("volume %p.\n", volume);
 489
 490     return volume->resource.parent;
 491 }
 492
 493 DWORD CDECL wined3d_volume_set_priority(struct wined3d_volume *volume, DWORD priority)
 494 {
 495     return resource_set_priority(&volume->resource, priority);
 496 }
 497
 498 DWORD CDECL wined3d_volume_get_priority(const struct wined3d_volume *volume)
 499 {
 500     return resource_get_priority(&volume->resource);
 501 }
 502
 503 void CDECL wined3d_volume_preload(struct wined3d_volume *volume)
 504 {
 505     FIXME("volume %p stub!\n", volume);
 506 }
 507
 508 struct wined3d_resource * CDECL wined3d_volume_get_resource(struct wined3d_volume *volume)
 509 {
 510     TRACE("volume %p.\n", volume);
 511
 512     return &volume->resource;
 513 }
 514
 515 HRESULT CDECL wined3d_volume_map(struct wined3d_volume *volume,
 516         struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags)
 517 {
 518     struct wined3d_device *device = volume->resource.device;
 519     struct wined3d_context *context;
 520     const struct wined3d_gl_info *gl_info;
 521     BYTE *base_memory;
 522
 523     TRACE("volume %p, map_desc %p, box %p, flags %#x.\n",
 524             volume, map_desc, box, flags);
 525
 526     if (!(volume->resource.access_flags & WINED3D_RESOURCE_ACCESS_CPU))
 527     {
 528         WARN("Volume %p is not CPU accessible.\n", volume);
 529         map_desc->data = NULL;
 530         return WINED3DERR_INVALIDCALL;
 531     }
 532     flags = wined3d_resource_sanitize_map_flags(&volume->resource, flags);
 533
 534     if (volume->flags & WINED3D_VFLAG_PBO)
 535     {
 536         context = context_acquire(device, NULL);
 537         gl_info = context->gl_info;
 538
 539         wined3d_volume_prepare_pbo(volume, context);
 540         if (flags & WINED3D_MAP_DISCARD)
 541             wined3d_volume_validate_location(volume, WINED3D_LOCATION_BUFFER);
 542         else
 543             wined3d_volume_load_location(volume, context, WINED3D_LOCATION_BUFFER);
 544
 545         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, volume->pbo));
 546
 547         if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
 548         {
 549             GLbitfield mapflags = wined3d_resource_gl_map_flags(flags);
 550             mapflags &= ~GL_MAP_FLUSH_EXPLICIT_BIT;
 551             base_memory = GL_EXTCALL(glMapBufferRange(GL_PIXEL_UNPACK_BUFFER_ARB,
 552                     0, volume->resource.size, mapflags));
 553         }
 554         else
 555         {
 556             base_memory = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 557         }
 558
 559         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 560         checkGLcall("Map PBO");
 561
 562         context_release(context);
 563     }
 564     else
 565     {
 566         if (!volume_prepare_system_memory(volume))
 567         {
 568             WARN("Out of memory.\n");
 569             map_desc->data = NULL;
 570             return E_OUTOFMEMORY;
 571         }
 572
 573         if (flags & WINED3D_MAP_DISCARD)
 574         {
 575             wined3d_volume_validate_location(volume, WINED3D_LOCATION_SYSMEM);
 576         }
 577         else if (!(volume->locations & WINED3D_LOCATION_SYSMEM))
 578         {
 579             context = context_acquire(device, NULL);
 580             wined3d_volume_load_location(volume, context, WINED3D_LOCATION_SYSMEM);
 581             context_release(context);
 582         }
 583         base_memory = volume->resource.allocatedMemory;
 584     }
 585
 586     TRACE("Base memory pointer %p.\n", base_memory);
 587
 588     map_desc->row_pitch = volume->resource.format->byte_count * volume->resource.width; /* Bytes / row */
 589     map_desc->slice_pitch = volume->resource.format->byte_count
 590             * volume->resource.width * volume->resource.height; /* Bytes / slice */
 591     if (!box)
 592     {
 593         TRACE("No box supplied - all is ok\n");
 594         map_desc->data = base_memory;
 595     }
 596     else
 597     {
 598         TRACE("Lock Box (%p) = l %u, t %u, r %u, b %u, fr %u, ba %u\n",
 599                 box, box->left, box->top, box->right, box->bottom, box->front, box->back);
 600         map_desc->data = base_memory
 601                 + (map_desc->slice_pitch * box->front)     /* FIXME: is front < back or vica versa? */
 602                 + (map_desc->row_pitch * box->top)
 603                 + (box->left * volume->resource.format->byte_count);
 604     }
 605
 606     if (!(flags & (WINED3D_MAP_NO_DIRTY_UPDATE | WINED3D_MAP_READONLY)))
 607     {
 608         wined3d_texture_set_dirty(volume->container, TRUE);
 609
 610         if (volume->flags & WINED3D_VFLAG_PBO)
 611             wined3d_volume_invalidate_location(volume, ~WINED3D_LOCATION_BUFFER);
 612         else
 613             wined3d_volume_invalidate_location(volume, ~WINED3D_LOCATION_SYSMEM);
 614     }
 615
 616     volume->flags |= WINED3D_VFLAG_LOCKED;
 617
 618     TRACE("Returning memory %p, row pitch %d, slice pitch %d.\n",
 619             map_desc->data, map_desc->row_pitch, map_desc->slice_pitch);
 620
 621     return WINED3D_OK;
 622 }
 623
 624 struct wined3d_volume * CDECL wined3d_volume_from_resource(struct wined3d_resource *resource)
 625 {
 626     return volume_from_resource(resource);
 627 }
 628
 629 HRESULT CDECL wined3d_volume_unmap(struct wined3d_volume *volume)
 630 {
 631     TRACE("volume %p.\n", volume);
 632
 633     if (!(volume->flags & WINED3D_VFLAG_LOCKED))
 634     {
 635         WARN("Trying to unlock unlocked volume %p.\n", volume);
 636         return WINED3DERR_INVALIDCALL;
 637     }
 638
 639     if (volume->flags & WINED3D_VFLAG_PBO)
 640     {
 641         struct wined3d_device *device = volume->resource.device;
 642         struct wined3d_context *context = context_acquire(device, NULL);
 643         const struct wined3d_gl_info *gl_info = context->gl_info;
 644
 645         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, volume->pbo));
 646         GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
 647         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 648         checkGLcall("Unmap PBO");
 649
 650         context_release(context);
 651     }
 652
 653     volume->flags &= ~WINED3D_VFLAG_LOCKED;
 654
 655     return WINED3D_OK;
 656 }
 657
 658 static const struct wined3d_resource_ops volume_resource_ops =
 659 {
 660     volume_unload,
 661 };
 662
 663 static HRESULT volume_init(struct wined3d_volume *volume, struct wined3d_device *device, UINT width,
 664         UINT height, UINT depth, UINT level, DWORD usage, enum wined3d_format_id format_id,
 665         enum wined3d_pool pool, void *parent, const struct wined3d_parent_ops *parent_ops)
 666 {
 667     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 668     const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
 669     HRESULT hr;
 670     UINT size;
 671
 672     if (!gl_info->supported[EXT_TEXTURE3D])
 673     {
 674         WARN("Volume cannot be created - no volume texture support.\n");
 675         return WINED3DERR_INVALIDCALL;
 676     }
 677     /* TODO: Write tests for other resources and move this check
 678      * to resource_init, if applicable. */
 679     if (usage & WINED3DUSAGE_DYNAMIC
 680             && (pool == WINED3D_POOL_MANAGED || pool == WINED3D_POOL_SCRATCH))
 681     {
 682         WARN("Attempted to create a DYNAMIC texture in pool %u.\n", pool);
 683         return WINED3DERR_INVALIDCALL;
 684     }
 685
 686     size = wined3d_format_calculate_size(format, device->surface_alignment, width, height, depth);
 687
 688     hr = resource_init(&volume->resource, device, WINED3D_RTYPE_VOLUME, format,
 689             WINED3D_MULTISAMPLE_NONE, 0, usage, pool, width, height, depth,
 690             size, parent, parent_ops, &volume_resource_ops);
 691     if (FAILED(hr))
 692     {
 693         WARN("Failed to initialize resource, returning %#x.\n", hr);
 694         return hr;
 695     }
 696
 697     volume->texture_level = level;
 698     volume->locations = WINED3D_LOCATION_DISCARDED;
 699
 700     if (pool == WINED3D_POOL_DEFAULT && usage & WINED3DUSAGE_DYNAMIC
 701             && gl_info->supported[ARB_PIXEL_BUFFER_OBJECT])
 702     {
 703         wined3d_resource_free_sysmem(volume->resource.heap_memory);
 704         volume->resource.heap_memory = NULL;
 705         volume->resource.allocatedMemory = NULL;
 706         volume->flags |= WINED3D_VFLAG_PBO;
 707     }
 708
 709     return WINED3D_OK;
 710 }
 711
 712 HRESULT CDECL wined3d_volume_create(struct wined3d_device *device, UINT width, UINT height,
 713         UINT depth, UINT level, DWORD usage, enum wined3d_format_id format_id, enum wined3d_pool pool,
 714         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_volume **volume)
 715 {
 716     struct wined3d_volume *object;
 717     HRESULT hr;
 718
 719     TRACE("device %p, width %u, height %u, depth %u, usage %#x, format %s, pool %s\n",
 720             device, width, height, depth, usage, debug_d3dformat(format_id), debug_d3dpool(pool));
 721     TRACE("parent %p, parent_ops %p, volume %p.\n", parent, parent_ops, volume);
 722
 723     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 724     if (!object)
 725     {
 726         *volume = NULL;
 727         return WINED3DERR_OUTOFVIDEOMEMORY;
 728     }
 729
 730     hr = volume_init(object, device, width, height, depth, level,
 731             usage, format_id, pool, parent, parent_ops);
 732     if (FAILED(hr))
 733     {
 734         WARN("Failed to initialize volume, returning %#x.\n", hr);
 735         HeapFree(GetProcessHeap(), 0, object);
 736         return hr;
 737     }
 738
 739     TRACE("Created volume %p.\n", object);
 740     *volume = object;
 741
 742     return WINED3D_OK;
 743 }