dlls/wined3d/texture.c

   1 /*
   2  * Copyright 2002-2005 Jason Edmeades
   3  * Copyright 2002-2005 Raphael Junqueira
   4  * Copyright 2005 Oliver Stieber
   5  * Copyright 2007-2009, 2013 Stefan Dösinger for CodeWeavers
   6  * Copyright 2009-2011 Henri Verbeet 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_texture);
  28 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
  29 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  30
  31 static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struct wined3d_texture_ops *texture_ops,
  32         UINT layer_count, UINT level_count, const struct wined3d_resource_desc *desc, DWORD flags,
  33         struct wined3d_device *device, void *parent, const struct wined3d_parent_ops *parent_ops,
  34         const struct wined3d_resource_ops *resource_ops)
  35 {
  36     const struct wined3d_format *format = wined3d_get_format(&device->adapter->gl_info, desc->format);
  37     HRESULT hr;
  38
  39     TRACE("texture %p, texture_ops %p, layer_count %u, level_count %u, resource_type %s, format %s, "
  40             "multisample_type %#x, multisample_quality %#x, usage %s, pool %s, width %u, height %u, depth %u, "
  41             "flags %#x, device %p, parent %p, parent_ops %p, resource_ops %p.\n",
  42             texture, texture_ops, layer_count, level_count, debug_d3dresourcetype(desc->resource_type),
  43             debug_d3dformat(desc->format), desc->multisample_type, desc->multisample_quality,
  44             debug_d3dusage(desc->usage), debug_d3dpool(desc->pool), desc->width, desc->height, desc->depth,
  45             flags, device, parent, parent_ops, resource_ops);
  46
  47     if (FAILED(hr = resource_init(&texture->resource, device, desc->resource_type, format,
  48             desc->multisample_type, desc->multisample_quality, desc->usage, desc->pool,
  49             desc->width, desc->height, desc->depth, 0, parent, parent_ops, resource_ops)))
  50     {
  51         static unsigned int once;
  52
  53         /* DXTn 3D textures are not supported. Do not write the ERR for them. */
  54         if ((desc->format == WINED3DFMT_DXT1 || desc->format == WINED3DFMT_DXT2 || desc->format == WINED3DFMT_DXT3
  55                 || desc->format == WINED3DFMT_DXT4 || desc->format == WINED3DFMT_DXT5)
  56                 && !(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_TEXTURE)
  57                 && desc->resource_type != WINED3D_RTYPE_TEXTURE_3D && !once++)
  58             ERR_(winediag)("The application tried to create a DXTn texture, but the driver does not support them.\n");
  59
  60         WARN("Failed to initialize resource, returning %#x\n", hr);
  61         return hr;
  62     }
  63     wined3d_resource_update_draw_binding(&texture->resource);
  64
  65     texture->texture_ops = texture_ops;
  66
  67     texture->layer_count = layer_count;
  68     texture->level_count = level_count;
  69     texture->filter_type = (desc->usage & WINED3DUSAGE_AUTOGENMIPMAP) ? WINED3D_TEXF_LINEAR : WINED3D_TEXF_NONE;
  70     texture->lod = 0;
  71     texture->flags = WINED3D_TEXTURE_POW2_MAT_IDENT | WINED3D_TEXTURE_NORMALIZED_COORDS;
  72     if (flags & WINED3D_TEXTURE_CREATE_PIN_SYSMEM)
  73         texture->flags |= WINED3D_TEXTURE_PIN_SYSMEM;
  74
  75     return WINED3D_OK;
  76 }
  77
  78 /* Context activation is done by the caller. */
  79 void wined3d_texture_remove_buffer_object(struct wined3d_texture *texture,
  80         unsigned int sub_resource_idx, const struct wined3d_gl_info *gl_info)
  81 {
  82     GLuint *buffer_object;
  83
  84     buffer_object = &texture->sub_resources[sub_resource_idx].buffer_object;
  85     GL_EXTCALL(glDeleteBuffers(1, buffer_object));
  86     checkGLcall("glDeleteBuffers");
  87     texture->texture_ops->texture_sub_resource_invalidate_location(
  88             texture->sub_resources[sub_resource_idx].resource, WINED3D_LOCATION_BUFFER);
  89     *buffer_object = 0;
  90
  91     TRACE("Deleted buffer object %u for texture %p, sub-resource %u.\n",
  92             *buffer_object, texture, sub_resource_idx);
  93 }
  94
  95 /* A GL context is provided by the caller */
  96 static void gltexture_delete(struct wined3d_device *device, const struct wined3d_gl_info *gl_info,
  97         struct gl_texture *tex)
  98 {
  99     context_gl_resource_released(device, tex->name, FALSE);
 100     gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex->name);
 101     tex->name = 0;
 102 }
 103
 104 static void wined3d_texture_unload_gl_texture(struct wined3d_texture *texture)
 105 {
 106     struct wined3d_device *device = texture->resource.device;
 107     struct wined3d_context *context = NULL;
 108
 109     if (texture->texture_rgb.name || texture->texture_srgb.name)
 110     {
 111         context = context_acquire(device, NULL);
 112     }
 113
 114     if (texture->texture_rgb.name)
 115         gltexture_delete(device, context->gl_info, &texture->texture_rgb);
 116
 117     if (texture->texture_srgb.name)
 118         gltexture_delete(device, context->gl_info, &texture->texture_srgb);
 119
 120     if (context) context_release(context);
 121
 122     wined3d_texture_set_dirty(texture);
 123
 124     resource_unload(&texture->resource);
 125 }
 126
 127 static void wined3d_texture_cleanup(struct wined3d_texture *texture)
 128 {
 129     unsigned int sub_count = texture->level_count * texture->layer_count;
 130     struct wined3d_device *device = texture->resource.device;
 131     struct wined3d_context *context = NULL;
 132     const struct wined3d_gl_info *gl_info;
 133     GLuint buffer_object;
 134     unsigned int i;
 135
 136     TRACE("texture %p.\n", texture);
 137
 138     for (i = 0; i < sub_count; ++i)
 139     {
 140         if (!(buffer_object = texture->sub_resources[i].buffer_object))
 141             continue;
 142
 143         TRACE("Deleting buffer object %u.\n", buffer_object);
 144
 145         /* We may not be able to get a context in wined3d_texture_cleanup() in
 146          * general, but if a buffer object was previously created we can. */
 147         if (!context)
 148         {
 149             context = context_acquire(device, NULL);
 150             gl_info = context->gl_info;
 151         }
 152
 153         GL_EXTCALL(glDeleteBuffers(1, &buffer_object));
 154     }
 155     if (context)
 156         context_release(context);
 157
 158     texture->texture_ops->texture_cleanup_sub_resources(texture);
 159     wined3d_texture_unload_gl_texture(texture);
 160     resource_cleanup(&texture->resource);
 161 }
 162
 163 void wined3d_texture_set_swapchain(struct wined3d_texture *texture, struct wined3d_swapchain *swapchain)
 164 {
 165     texture->swapchain = swapchain;
 166     wined3d_resource_update_draw_binding(&texture->resource);
 167 }
 168
 169 void wined3d_texture_set_dirty(struct wined3d_texture *texture)
 170 {
 171     texture->flags &= ~(WINED3D_TEXTURE_RGB_VALID | WINED3D_TEXTURE_SRGB_VALID);
 172 }
 173
 174 /* Context activation is done by the caller. */
 175 void wined3d_texture_bind(struct wined3d_texture *texture,
 176         struct wined3d_context *context, BOOL srgb)
 177 {
 178     const struct wined3d_gl_info *gl_info = context->gl_info;
 179     struct gl_texture *gl_tex;
 180     GLenum target;
 181
 182     TRACE("texture %p, context %p, srgb %#x.\n", texture, context, srgb);
 183
 184     if (!needs_separate_srgb_gl_texture(context))
 185         srgb = FALSE;
 186
 187     /* sRGB mode cache for preload() calls outside drawprim. */
 188     if (srgb)
 189         texture->flags |= WINED3D_TEXTURE_IS_SRGB;
 190     else
 191         texture->flags &= ~WINED3D_TEXTURE_IS_SRGB;
 192
 193     gl_tex = wined3d_texture_get_gl_texture(texture, srgb);
 194     target = texture->target;
 195
 196     if (gl_tex->name)
 197     {
 198         context_bind_texture(context, target, gl_tex->name);
 199         return;
 200     }
 201
 202     gl_info->gl_ops.gl.p_glGenTextures(1, &gl_tex->name);
 203     checkGLcall("glGenTextures");
 204     TRACE("Generated texture %d.\n", gl_tex->name);
 205
 206     if (!gl_tex->name)
 207     {
 208         ERR("Failed to generate a texture name.\n");
 209         return;
 210     }
 211
 212     /* Initialise the state of the texture object to the OpenGL defaults, not
 213      * the wined3d defaults. */
 214     gl_tex->sampler_desc.address_u = WINED3D_TADDRESS_WRAP;
 215     gl_tex->sampler_desc.address_v = WINED3D_TADDRESS_WRAP;
 216     gl_tex->sampler_desc.address_w = WINED3D_TADDRESS_WRAP;
 217     memset(gl_tex->sampler_desc.border_color, 0, sizeof(gl_tex->sampler_desc.border_color));
 218     gl_tex->sampler_desc.mag_filter = WINED3D_TEXF_LINEAR;
 219     gl_tex->sampler_desc.min_filter = WINED3D_TEXF_POINT; /* GL_NEAREST_MIPMAP_LINEAR */
 220     gl_tex->sampler_desc.mip_filter = WINED3D_TEXF_LINEAR; /* GL_NEAREST_MIPMAP_LINEAR */
 221     gl_tex->sampler_desc.lod_bias = 0.0f;
 222     gl_tex->sampler_desc.min_lod = -1000.0f;
 223     gl_tex->sampler_desc.max_lod = 1000.0f;
 224     gl_tex->sampler_desc.max_anisotropy = 1;
 225     gl_tex->sampler_desc.compare = FALSE;
 226     gl_tex->sampler_desc.comparison_func = WINED3D_CMP_LESSEQUAL;
 227     if (context->gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
 228         gl_tex->sampler_desc.srgb_decode = TRUE;
 229     else
 230         gl_tex->sampler_desc.srgb_decode = srgb;
 231     gl_tex->base_level = 0;
 232     wined3d_texture_set_dirty(texture);
 233
 234     context_bind_texture(context, target, gl_tex->name);
 235
 236     if (texture->resource.usage & WINED3DUSAGE_AUTOGENMIPMAP)
 237     {
 238         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
 239         checkGLcall("glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE)");
 240     }
 241
 242     /* For a new texture we have to set the texture levels after binding the
 243      * texture. Beware that texture rectangles do not support mipmapping, but
 244      * set the maxmiplevel if we're relying on the partial
 245      * GL_ARB_texture_non_power_of_two emulation with texture rectangles.
 246      * (I.e., do not care about cond_np2 here, just look for
 247      * GL_TEXTURE_RECTANGLE_ARB.) */
 248     if (target != GL_TEXTURE_RECTANGLE_ARB)
 249     {
 250         TRACE("Setting GL_TEXTURE_MAX_LEVEL to %u.\n", texture->level_count - 1);
 251         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, texture->level_count - 1);
 252         checkGLcall("glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, texture->level_count)");
 253     }
 254
 255     if (target == GL_TEXTURE_CUBE_MAP_ARB)
 256     {
 257         /* Cubemaps are always set to clamp, regardless of the sampler state. */
 258         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 259         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 260         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
 261     }
 262
 263     if (texture->flags & WINED3D_TEXTURE_COND_NP2)
 264     {
 265         /* Conditinal non power of two textures use a different clamping
 266          * default. If we're using the GL_WINE_normalized_texrect partial
 267          * driver emulation, we're dealing with a GL_TEXTURE_2D texture which
 268          * has the address mode set to repeat - something that prevents us
 269          * from hitting the accelerated codepath. Thus manually set the GL
 270          * state. The same applies to filtering. Even if the texture has only
 271          * one mip level, the default LINEAR_MIPMAP_LINEAR filter causes a SW
 272          * fallback on macos. */
 273         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 274         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 275         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 276         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 277         checkGLcall("glTexParameteri");
 278         gl_tex->sampler_desc.address_u = WINED3D_TADDRESS_CLAMP;
 279         gl_tex->sampler_desc.address_v = WINED3D_TADDRESS_CLAMP;
 280         gl_tex->sampler_desc.mag_filter = WINED3D_TEXF_POINT;
 281         gl_tex->sampler_desc.min_filter = WINED3D_TEXF_POINT;
 282         gl_tex->sampler_desc.mip_filter = WINED3D_TEXF_NONE;
 283     }
 284
 285     if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] && gl_info->supported[ARB_DEPTH_TEXTURE])
 286     {
 287         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);
 288         checkGLcall("glTexParameteri(GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY)");
 289     }
 290 }
 291
 292 /* Context activation is done by the caller. */
 293 void wined3d_texture_bind_and_dirtify(struct wined3d_texture *texture,
 294         struct wined3d_context *context, BOOL srgb)
 295 {
 296     DWORD active_sampler;
 297
 298     /* We don't need a specific texture unit, but after binding the texture
 299      * the current unit is dirty. Read the unit back instead of switching to
 300      * 0, this avoids messing around with the state manager's GL states. The
 301      * current texture unit should always be a valid one.
 302      *
 303      * To be more specific, this is tricky because we can implicitly be
 304      * called from sampler() in state.c. This means we can't touch anything
 305      * other than whatever happens to be the currently active texture, or we
 306      * would risk marking already applied sampler states dirty again. */
 307     active_sampler = context->rev_tex_unit_map[context->active_texture];
 308     if (active_sampler != WINED3D_UNMAPPED_STAGE)
 309         context_invalidate_state(context, STATE_SAMPLER(active_sampler));
 310     /* FIXME: Ideally we'd only do this when touching a binding that's used by
 311      * a shader. */
 312     context_invalidate_state(context, STATE_SHADER_RESOURCE_BINDING);
 313
 314     wined3d_texture_bind(texture, context, srgb);
 315 }
 316
 317 /* Context activation is done by the caller (state handler). */
 318 /* This function relies on the correct texture being bound and loaded. */
 319 void wined3d_texture_apply_sampler_desc(struct wined3d_texture *texture,
 320         const struct wined3d_sampler_desc *sampler_desc, const struct wined3d_context *context)
 321 {
 322     const struct wined3d_gl_info *gl_info = context->gl_info;
 323     GLenum target = texture->target;
 324     struct gl_texture *gl_tex;
 325     DWORD state;
 326
 327     TRACE("texture %p, sampler_desc %p, context %p.\n", texture, sampler_desc, context);
 328
 329     gl_tex = wined3d_texture_get_gl_texture(texture, texture->flags & WINED3D_TEXTURE_IS_SRGB);
 330
 331     state = sampler_desc->address_u;
 332     if (state != gl_tex->sampler_desc.address_u)
 333     {
 334         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_S,
 335                 gl_info->wrap_lookup[state - WINED3D_TADDRESS_WRAP]);
 336         gl_tex->sampler_desc.address_u = state;
 337     }
 338
 339     state = sampler_desc->address_v;
 340     if (state != gl_tex->sampler_desc.address_v)
 341     {
 342         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_T,
 343                 gl_info->wrap_lookup[state - WINED3D_TADDRESS_WRAP]);
 344         gl_tex->sampler_desc.address_v = state;
 345     }
 346
 347     state = sampler_desc->address_w;
 348     if (state != gl_tex->sampler_desc.address_w)
 349     {
 350         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_R,
 351                 gl_info->wrap_lookup[state - WINED3D_TADDRESS_WRAP]);
 352         gl_tex->sampler_desc.address_w = state;
 353     }
 354
 355     if (memcmp(gl_tex->sampler_desc.border_color, sampler_desc->border_color,
 356             sizeof(gl_tex->sampler_desc.border_color)))
 357     {
 358         gl_info->gl_ops.gl.p_glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, &sampler_desc->border_color[0]);
 359         memcpy(gl_tex->sampler_desc.border_color, sampler_desc->border_color,
 360                 sizeof(gl_tex->sampler_desc.border_color));
 361     }
 362
 363     state = sampler_desc->mag_filter;
 364     if (state != gl_tex->sampler_desc.mag_filter)
 365     {
 366         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAG_FILTER, wined3d_gl_mag_filter(state));
 367         gl_tex->sampler_desc.mag_filter = state;
 368     }
 369
 370     if (sampler_desc->min_filter != gl_tex->sampler_desc.min_filter
 371             || sampler_desc->mip_filter != gl_tex->sampler_desc.mip_filter)
 372     {
 373         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
 374                 wined3d_gl_min_mip_filter(sampler_desc->min_filter, sampler_desc->mip_filter));
 375         gl_tex->sampler_desc.min_filter = sampler_desc->min_filter;
 376         gl_tex->sampler_desc.mip_filter = sampler_desc->mip_filter;
 377     }
 378
 379     state = sampler_desc->max_anisotropy;
 380     if (state != gl_tex->sampler_desc.max_anisotropy)
 381     {
 382         if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC])
 383             gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, state);
 384         else
 385             WARN("Anisotropic filtering not supported.\n");
 386         gl_tex->sampler_desc.max_anisotropy = state;
 387     }
 388
 389     if (!sampler_desc->srgb_decode != !gl_tex->sampler_desc.srgb_decode
 390             && (context->d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
 391             && gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
 392     {
 393         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT,
 394                 sampler_desc->srgb_decode ? GL_DECODE_EXT : GL_SKIP_DECODE_EXT);
 395         gl_tex->sampler_desc.srgb_decode = sampler_desc->srgb_decode;
 396     }
 397
 398     if (!sampler_desc->compare != !gl_tex->sampler_desc.compare)
 399     {
 400         if (sampler_desc->compare)
 401             gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
 402         else
 403             gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE);
 404         gl_tex->sampler_desc.compare = sampler_desc->compare;
 405     }
 406
 407     checkGLcall("Texture parameter application");
 408
 409     if (gl_info->supported[EXT_TEXTURE_LOD_BIAS])
 410     {
 411         gl_info->gl_ops.gl.p_glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
 412                 GL_TEXTURE_LOD_BIAS_EXT, sampler_desc->lod_bias);
 413         checkGLcall("glTexEnvf(GL_TEXTURE_LOD_BIAS_EXT, ...)");
 414     }
 415 }
 416
 417 ULONG CDECL wined3d_texture_incref(struct wined3d_texture *texture)
 418 {
 419     ULONG refcount;
 420
 421     TRACE("texture %p, swapchain %p.\n", texture, texture->swapchain);
 422
 423     if (texture->swapchain)
 424         return wined3d_swapchain_incref(texture->swapchain);
 425
 426     refcount = InterlockedIncrement(&texture->resource.ref);
 427     TRACE("%p increasing refcount to %u.\n", texture, refcount);
 428
 429     return refcount;
 430 }
 431
 432 ULONG CDECL wined3d_texture_decref(struct wined3d_texture *texture)
 433 {
 434     ULONG refcount;
 435
 436     TRACE("texture %p, swapchain %p.\n", texture, texture->swapchain);
 437
 438     if (texture->swapchain)
 439         return wined3d_swapchain_decref(texture->swapchain);
 440
 441     refcount = InterlockedDecrement(&texture->resource.ref);
 442     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
 443
 444     if (!refcount)
 445     {
 446         wined3d_texture_cleanup(texture);
 447         texture->resource.parent_ops->wined3d_object_destroyed(texture->resource.parent);
 448         HeapFree(GetProcessHeap(), 0, texture);
 449     }
 450
 451     return refcount;
 452 }
 453
 454 struct wined3d_resource * CDECL wined3d_texture_get_resource(struct wined3d_texture *texture)
 455 {
 456     TRACE("texture %p.\n", texture);
 457
 458     return &texture->resource;
 459 }
 460
 461 static BOOL color_key_equal(const struct wined3d_color_key *c1, struct wined3d_color_key *c2)
 462 {
 463     return c1->color_space_low_value == c2->color_space_low_value
 464             && c1->color_space_high_value == c2->color_space_high_value;
 465 }
 466
 467 /* Context activation is done by the caller */
 468 void wined3d_texture_load(struct wined3d_texture *texture,
 469         struct wined3d_context *context, BOOL srgb)
 470 {
 471     UINT sub_count = texture->level_count * texture->layer_count;
 472     const struct wined3d_d3d_info *d3d_info = context->d3d_info;
 473     DWORD flag;
 474     UINT i;
 475
 476     TRACE("texture %p, context %p, srgb %#x.\n", texture, context, srgb);
 477
 478     if (!needs_separate_srgb_gl_texture(context))
 479         srgb = FALSE;
 480
 481     if (srgb)
 482         flag = WINED3D_TEXTURE_SRGB_VALID;
 483     else
 484         flag = WINED3D_TEXTURE_RGB_VALID;
 485
 486     if (!d3d_info->shader_color_key
 487             && (!(texture->async.flags & WINED3D_TEXTURE_ASYNC_COLOR_KEY)
 488             != !(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
 489             || (texture->async.flags & WINED3D_TEXTURE_ASYNC_COLOR_KEY
 490             && !color_key_equal(&texture->async.gl_color_key, &texture->async.src_blt_color_key))))
 491     {
 492         unsigned int sub_count = texture->level_count * texture->layer_count;
 493         unsigned int i;
 494
 495         TRACE("Reloading because of color key value change.\n");
 496         for (i = 0; i < sub_count; i++)
 497             texture->texture_ops->texture_sub_resource_add_dirty_region(texture->sub_resources[i].resource, NULL);
 498         wined3d_texture_set_dirty(texture);
 499
 500         texture->async.gl_color_key = texture->async.src_blt_color_key;
 501     }
 502
 503     if (texture->flags & flag)
 504     {
 505         TRACE("Texture %p not dirty, nothing to do.\n", texture);
 506         return;
 507     }
 508
 509     /* Reload the surfaces if the texture is marked dirty. */
 510     for (i = 0; i < sub_count; ++i)
 511     {
 512         texture->texture_ops->texture_sub_resource_load(texture->sub_resources[i].resource, context, srgb);
 513     }
 514     texture->flags |= flag;
 515 }
 516
 517 void CDECL wined3d_texture_preload(struct wined3d_texture *texture)
 518 {
 519     struct wined3d_context *context;
 520     context = context_acquire(texture->resource.device, NULL);
 521     wined3d_texture_load(texture, context, texture->flags & WINED3D_TEXTURE_IS_SRGB);
 522     context_release(context);
 523 }
 524
 525 void * CDECL wined3d_texture_get_parent(const struct wined3d_texture *texture)
 526 {
 527     TRACE("texture %p.\n", texture);
 528
 529     return texture->resource.parent;
 530 }
 531
 532 static BOOL wined3d_texture_check_box_dimensions(const struct wined3d_texture *texture,
 533         unsigned int level, const struct wined3d_box *box)
 534 {
 535     if (box->left >= box->right
 536             || box->top >= box->bottom
 537             || box->front >= box->back)
 538         return FALSE;
 539
 540     if (box->right > wined3d_texture_get_level_width(texture, level)
 541             || box->bottom > wined3d_texture_get_level_height(texture, level)
 542             || box->back > wined3d_texture_get_level_depth(texture, level))
 543         return FALSE;
 544
 545     return TRUE;
 546 }
 547
 548 void CDECL wined3d_texture_get_pitch(const struct wined3d_texture *texture,
 549         unsigned int level, unsigned int *row_pitch, unsigned int *slice_pitch)
 550 {
 551     const struct wined3d_resource *resource = &texture->resource;
 552     unsigned int width = wined3d_texture_get_level_width(texture, level);
 553     unsigned int height = wined3d_texture_get_level_height(texture, level);
 554
 555     if (texture->row_pitch)
 556     {
 557         *row_pitch = texture->row_pitch;
 558         *slice_pitch = texture->slice_pitch;
 559         return;
 560     }
 561
 562     wined3d_format_calculate_pitch(resource->format, resource->device->surface_alignment,
 563             width, height, row_pitch, slice_pitch);
 564 }
 565
 566 DWORD CDECL wined3d_texture_set_lod(struct wined3d_texture *texture, DWORD lod)
 567 {
 568     DWORD old = texture->lod;
 569
 570     TRACE("texture %p, lod %u.\n", texture, lod);
 571
 572     /* The d3d9:texture test shows that SetLOD is ignored on non-managed
 573      * textures. The call always returns 0, and GetLOD always returns 0. */
 574     if (texture->resource.pool != WINED3D_POOL_MANAGED)
 575     {
 576         TRACE("Ignoring SetLOD on %s texture, returning 0.\n", debug_d3dpool(texture->resource.pool));
 577         return 0;
 578     }
 579
 580     if (lod >= texture->level_count)
 581         lod = texture->level_count - 1;
 582
 583     if (texture->lod != lod)
 584     {
 585         texture->lod = lod;
 586
 587         texture->texture_rgb.base_level = ~0u;
 588         texture->texture_srgb.base_level = ~0u;
 589         if (texture->resource.bind_count)
 590             device_invalidate_state(texture->resource.device, STATE_SAMPLER(texture->sampler));
 591     }
 592
 593     return old;
 594 }
 595
 596 DWORD CDECL wined3d_texture_get_lod(const struct wined3d_texture *texture)
 597 {
 598     TRACE("texture %p, returning %u.\n", texture, texture->lod);
 599
 600     return texture->lod;
 601 }
 602
 603 DWORD CDECL wined3d_texture_get_level_count(const struct wined3d_texture *texture)
 604 {
 605     TRACE("texture %p, returning %u.\n", texture, texture->level_count);
 606
 607     return texture->level_count;
 608 }
 609
 610 HRESULT CDECL wined3d_texture_set_autogen_filter_type(struct wined3d_texture *texture,
 611         enum wined3d_texture_filter_type filter_type)
 612 {
 613     FIXME("texture %p, filter_type %s stub!\n", texture, debug_d3dtexturefiltertype(filter_type));
 614
 615     if (!(texture->resource.usage & WINED3DUSAGE_AUTOGENMIPMAP))
 616     {
 617         WARN("Texture doesn't have AUTOGENMIPMAP usage.\n");
 618         return WINED3DERR_INVALIDCALL;
 619     }
 620
 621     texture->filter_type = filter_type;
 622
 623     return WINED3D_OK;
 624 }
 625
 626 enum wined3d_texture_filter_type CDECL wined3d_texture_get_autogen_filter_type(const struct wined3d_texture *texture)
 627 {
 628     TRACE("texture %p.\n", texture);
 629
 630     return texture->filter_type;
 631 }
 632
 633 HRESULT CDECL wined3d_texture_set_color_key(struct wined3d_texture *texture,
 634         DWORD flags, const struct wined3d_color_key *color_key)
 635 {
 636     struct wined3d_device *device = texture->resource.device;
 637     static const DWORD all_flags = WINED3D_CKEY_DST_BLT | WINED3D_CKEY_DST_OVERLAY
 638             | WINED3D_CKEY_SRC_BLT | WINED3D_CKEY_SRC_OVERLAY;
 639
 640     TRACE("texture %p, flags %#x, color_key %p.\n", texture, flags, color_key);
 641
 642     if (flags & ~all_flags)
 643     {
 644         WARN("Invalid flags passed, returning WINED3DERR_INVALIDCALL.\n");
 645         return WINED3DERR_INVALIDCALL;
 646     }
 647
 648     wined3d_cs_emit_set_color_key(device->cs, texture, flags, color_key);
 649
 650     return WINED3D_OK;
 651 }
 652
 653 HRESULT CDECL wined3d_texture_update_desc(struct wined3d_texture *texture, UINT width, UINT height,
 654         enum wined3d_format_id format_id, enum wined3d_multisample_type multisample_type,
 655         UINT multisample_quality, void *mem, UINT pitch)
 656 {
 657     struct wined3d_device *device = texture->resource.device;
 658     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 659     const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
 660     UINT resource_size = wined3d_format_calculate_size(format, device->surface_alignment, width, height, 1);
 661     struct wined3d_surface *surface;
 662
 663     TRACE("texture %p, width %u, height %u, format %s, multisample_type %#x, multisample_quality %u, "
 664             "mem %p, pitch %u.\n",
 665             texture, width, height, debug_d3dformat(format_id), multisample_type, multisample_quality, mem, pitch);
 666
 667     if (!resource_size)
 668         return WINED3DERR_INVALIDCALL;
 669
 670     if (texture->level_count * texture->layer_count > 1)
 671     {
 672         WARN("Texture has multiple sub-resources, not supported.\n");
 673         return WINED3DERR_INVALIDCALL;
 674     }
 675
 676     if (texture->resource.type == WINED3D_RTYPE_TEXTURE_3D)
 677     {
 678         WARN("Not supported on 3D textures.\n");
 679         return WINED3DERR_INVALIDCALL;
 680     }
 681
 682     /* We have no way of supporting a pitch that is not a multiple of the pixel
 683      * byte width short of uploading the texture row-by-row.
 684      * Fortunately that's not an issue since D3D9Ex doesn't allow a custom pitch
 685      * for user-memory textures (it always expects packed data) while DirectDraw
 686      * requires a 4-byte aligned pitch and doesn't support texture formats
 687      * larger than 4 bytes per pixel nor any format using 3 bytes per pixel.
 688      * This check is here to verify that the assumption holds. */
 689     if (pitch % texture->resource.format->byte_count)
 690     {
 691         WARN("Pitch unsupported, not a multiple of the texture format byte width.\n");
 692         return WINED3DERR_INVALIDCALL;
 693     }
 694
 695     surface = texture->sub_resources[0].u.surface;
 696     if (surface->resource.map_count || (surface->flags & SFLAG_DCINUSE))
 697     {
 698         WARN("Surface is mapped or the DC is in use.\n");
 699         return WINED3DERR_INVALIDCALL;
 700     }
 701
 702     if (device->d3d_initialized)
 703         texture->resource.resource_ops->resource_unload(&texture->resource);
 704
 705     texture->resource.format = format;
 706     texture->resource.multisample_type = multisample_type;
 707     texture->resource.multisample_quality = multisample_quality;
 708     texture->resource.width = width;
 709     texture->resource.height = height;
 710
 711     texture->user_memory = mem;
 712     if ((texture->row_pitch = pitch))
 713         texture->slice_pitch = height * pitch;
 714     else
 715         /* User memory surfaces don't have the regular surface alignment. */
 716         wined3d_format_calculate_pitch(format, 1, width, height,
 717                 &texture->row_pitch, &texture->slice_pitch);
 718
 719     texture->flags &= ~WINED3D_TEXTURE_COND_NP2_EMULATED;
 720     if (((width & (width - 1)) || (height & (height - 1))) && !gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]
 721             && !gl_info->supported[ARB_TEXTURE_RECTANGLE] && !gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT])
 722         texture->flags |= WINED3D_TEXTURE_COND_NP2_EMULATED;
 723
 724     return wined3d_surface_update_desc(surface, gl_info);
 725 }
 726
 727 /* Context activation is done by the caller. */
 728 void wined3d_texture_prepare_buffer_object(struct wined3d_texture *texture,
 729         unsigned int sub_resource_idx, const struct wined3d_gl_info *gl_info)
 730 {
 731     GLuint *buffer_object;
 732
 733     buffer_object = &texture->sub_resources[sub_resource_idx].buffer_object;
 734     if (*buffer_object)
 735         return;
 736
 737     GL_EXTCALL(glGenBuffers(1, buffer_object));
 738     GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, *buffer_object));
 739     GL_EXTCALL(glBufferData(GL_PIXEL_UNPACK_BUFFER,
 740             texture->sub_resources[sub_resource_idx].resource->size, NULL, GL_STREAM_DRAW));
 741     GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
 742     checkGLcall("Create buffer object");
 743
 744     TRACE("Created buffer object %u for texture %p, sub-resource %u.\n",
 745             *buffer_object, texture, sub_resource_idx);
 746 }
 747
 748 void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
 749 {
 750     DWORD alloc_flag = srgb ? WINED3D_TEXTURE_SRGB_ALLOCATED : WINED3D_TEXTURE_RGB_ALLOCATED;
 751     const struct wined3d_d3d_info *d3d_info = context->d3d_info;
 752
 753     if (!d3d_info->shader_color_key
 754             && !(texture->async.flags & WINED3D_TEXTURE_ASYNC_COLOR_KEY)
 755             != !(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
 756     {
 757         wined3d_texture_force_reload(texture);
 758
 759         if (texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
 760             texture->async.flags |= WINED3D_TEXTURE_ASYNC_COLOR_KEY;
 761     }
 762
 763     if (texture->flags & alloc_flag)
 764         return;
 765
 766     texture->texture_ops->texture_prepare_texture(texture, context, srgb);
 767     texture->flags |= alloc_flag;
 768 }
 769
 770 void wined3d_texture_force_reload(struct wined3d_texture *texture)
 771 {
 772     unsigned int sub_count = texture->level_count * texture->layer_count;
 773     unsigned int i;
 774
 775     texture->flags &= ~(WINED3D_TEXTURE_RGB_ALLOCATED | WINED3D_TEXTURE_SRGB_ALLOCATED
 776             | WINED3D_TEXTURE_CONVERTED);
 777     texture->async.flags &= ~WINED3D_TEXTURE_ASYNC_COLOR_KEY;
 778     for (i = 0; i < sub_count; ++i)
 779     {
 780         texture->texture_ops->texture_sub_resource_invalidate_location(texture->sub_resources[i].resource,
 781                 WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB);
 782     }
 783 }
 784
 785 void CDECL wined3d_texture_generate_mipmaps(struct wined3d_texture *texture)
 786 {
 787     /* TODO: Implement filters using GL_SGI_generate_mipmaps. */
 788     FIXME("texture %p stub!\n", texture);
 789 }
 790
 791 struct wined3d_resource *wined3d_texture_get_sub_resource(const struct wined3d_texture *texture,
 792         UINT sub_resource_idx)
 793 {
 794     UINT sub_count = texture->level_count * texture->layer_count;
 795
 796     TRACE("texture %p, sub_resource_idx %u.\n", texture, sub_resource_idx);
 797
 798     if (sub_resource_idx >= sub_count)
 799     {
 800         WARN("sub_resource_idx %u >= sub_count %u.\n", sub_resource_idx, sub_count);
 801         return NULL;
 802     }
 803
 804     return texture->sub_resources[sub_resource_idx].resource;
 805 }
 806
 807 HRESULT CDECL wined3d_texture_add_dirty_region(struct wined3d_texture *texture,
 808         UINT layer, const struct wined3d_box *dirty_region)
 809 {
 810     struct wined3d_resource *sub_resource;
 811
 812     TRACE("texture %p, layer %u, dirty_region %s.\n", texture, layer, debug_box(dirty_region));
 813
 814     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, layer * texture->level_count)))
 815     {
 816         WARN("Failed to get sub-resource.\n");
 817         return WINED3DERR_INVALIDCALL;
 818     }
 819
 820     texture->texture_ops->texture_sub_resource_add_dirty_region(sub_resource, dirty_region);
 821
 822     return WINED3D_OK;
 823 }
 824
 825 static HRESULT wined3d_texture_upload_data(struct wined3d_texture *texture,
 826         const struct wined3d_sub_resource_data *data)
 827 {
 828     unsigned int sub_count = texture->level_count * texture->layer_count;
 829     struct wined3d_context *context;
 830     unsigned int i;
 831
 832     for (i = 0; i < sub_count; ++i)
 833     {
 834         if (!data[i].data)
 835         {
 836             WARN("Invalid sub-resource data specified for sub-resource %u.\n", i);
 837             return E_INVALIDARG;
 838         }
 839     }
 840
 841     context = context_acquire(texture->resource.device, NULL);
 842
 843     wined3d_texture_prepare_texture(texture, context, FALSE);
 844     wined3d_texture_bind_and_dirtify(texture, context, FALSE);
 845
 846     for (i = 0; i < sub_count; ++i)
 847     {
 848         struct wined3d_resource *sub_resource = texture->sub_resources[i].resource;
 849
 850         texture->texture_ops->texture_sub_resource_upload_data(sub_resource, context, &data[i]);
 851         texture->texture_ops->texture_sub_resource_validate_location(sub_resource, WINED3D_LOCATION_TEXTURE_RGB);
 852         texture->texture_ops->texture_sub_resource_invalidate_location(sub_resource, ~WINED3D_LOCATION_TEXTURE_RGB);
 853     }
 854
 855     context_release(context);
 856
 857     return WINED3D_OK;
 858 }
 859
 860 static void texture2d_sub_resource_load(struct wined3d_resource *sub_resource,
 861         struct wined3d_context *context, BOOL srgb)
 862 {
 863     surface_load(surface_from_resource(sub_resource), context, srgb);
 864 }
 865
 866 static void texture2d_sub_resource_add_dirty_region(struct wined3d_resource *sub_resource,
 867         const struct wined3d_box *dirty_region)
 868 {
 869     struct wined3d_surface *surface = surface_from_resource(sub_resource);
 870     struct wined3d_context *context;
 871
 872     context = context_acquire(surface->container->resource.device, NULL);
 873     surface_load_location(surface, context, sub_resource->map_binding);
 874     context_release(context);
 875     surface_invalidate_location(surface, ~sub_resource->map_binding);
 876 }
 877
 878 static void texture2d_sub_resource_invalidate_location(struct wined3d_resource *sub_resource, DWORD location)
 879 {
 880     struct wined3d_surface *surface = surface_from_resource(sub_resource);
 881
 882     surface_invalidate_location(surface, location);
 883 }
 884
 885 static void texture2d_sub_resource_validate_location(struct wined3d_resource *sub_resource, DWORD location)
 886 {
 887     struct wined3d_surface *surface = surface_from_resource(sub_resource);
 888
 889     surface_validate_location(surface, location);
 890 }
 891
 892 static void texture2d_sub_resource_upload_data(struct wined3d_resource *sub_resource,
 893         const struct wined3d_context *context, const struct wined3d_sub_resource_data *data)
 894 {
 895     struct wined3d_surface *surface = surface_from_resource(sub_resource);
 896     static const POINT dst_point = {0, 0};
 897     struct wined3d_const_bo_address addr;
 898     RECT src_rect;
 899
 900     SetRect(&src_rect, 0, 0, surface->resource.width, surface->resource.height);
 901
 902     addr.buffer_object = 0;
 903     addr.addr = data->data;
 904
 905     wined3d_surface_upload_data(surface, context->gl_info, surface->container->resource.format,
 906             &src_rect, data->row_pitch, &dst_point, FALSE, &addr);
 907 }
 908
 909 static BOOL texture2d_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx,
 910         struct wined3d_context *context, DWORD location)
 911 {
 912     return SUCCEEDED(surface_load_location(texture->sub_resources[sub_resource_idx].u.surface, context, location));
 913 }
 914
 915 static BOOL texture2d_prepare_location(struct wined3d_texture *texture, unsigned int sub_resource_idx,
 916         struct wined3d_context *context, DWORD location)
 917 {
 918     wined3d_surface_prepare(texture->sub_resources[sub_resource_idx].u.surface, context, location);
 919     return TRUE;
 920 }
 921
 922 /* Context activation is done by the caller. */
 923 static void texture2d_prepare_texture(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
 924 {
 925     UINT sub_count = texture->level_count * texture->layer_count;
 926     const struct wined3d_format *format = texture->resource.format;
 927     const struct wined3d_gl_info *gl_info = context->gl_info;
 928     const struct wined3d_color_key_conversion *conversion;
 929     GLenum internal;
 930     UINT i;
 931
 932     TRACE("texture %p, context %p, format %s.\n", texture, context, debug_d3dformat(format->id));
 933
 934     if (format->convert)
 935     {
 936         texture->flags |= WINED3D_TEXTURE_CONVERTED;
 937     }
 938     else if ((conversion = wined3d_format_get_color_key_conversion(texture, TRUE)))
 939     {
 940         texture->flags |= WINED3D_TEXTURE_CONVERTED;
 941         format = wined3d_get_format(gl_info, conversion->dst_format);
 942         TRACE("Using format %s for color key conversion.\n", debug_d3dformat(format->id));
 943     }
 944
 945     wined3d_texture_bind_and_dirtify(texture, context, srgb);
 946
 947     if (srgb)
 948         internal = format->glGammaInternal;
 949     else if (texture->resource.usage & WINED3DUSAGE_RENDERTARGET
 950             && wined3d_resource_is_offscreen(&texture->resource))
 951         internal = format->rtInternal;
 952     else
 953         internal = format->glInternal;
 954
 955     if (!internal)
 956         FIXME("No GL internal format for format %s.\n", debug_d3dformat(format->id));
 957
 958     TRACE("internal %#x, format %#x, type %#x.\n", internal, format->glFormat, format->glType);
 959
 960     for (i = 0; i < sub_count; ++i)
 961     {
 962         struct wined3d_surface *surface = texture->sub_resources[i].u.surface;
 963         GLsizei height = surface->pow2Height;
 964         GLsizei width = surface->pow2Width;
 965
 966         if (texture->resource.format_flags & WINED3DFMT_FLAG_HEIGHT_SCALE)
 967         {
 968             height *= format->height_scale.numerator;
 969             height /= format->height_scale.denominator;
 970         }
 971
 972         TRACE("surface %p, target %#x, level %d, width %d, height %d.\n",
 973                 surface, surface->texture_target, surface->texture_level, width, height);
 974
 975         gl_info->gl_ops.gl.p_glTexImage2D(surface->texture_target, surface->texture_level,
 976                 internal, width, height, 0, format->glFormat, format->glType, NULL);
 977         checkGLcall("glTexImage2D");
 978     }
 979 }
 980
 981 static void texture2d_cleanup_sub_resources(struct wined3d_texture *texture)
 982 {
 983     unsigned int sub_count = texture->level_count * texture->layer_count;
 984     struct wined3d_surface *surface;
 985     unsigned int i;
 986
 987     for (i = 0; i < sub_count; ++i)
 988     {
 989         if ((surface = texture->sub_resources[i].u.surface))
 990         {
 991             TRACE("surface %p.\n", surface);
 992
 993             wined3d_surface_cleanup(surface);
 994             surface->resource.parent_ops->wined3d_object_destroyed(surface->resource.parent);
 995         }
 996     }
 997     HeapFree(GetProcessHeap(), 0, texture->sub_resources[0].u.surface);
 998 }
 999
1000 static const struct wined3d_texture_ops texture2d_ops =
1001 {
1002     texture2d_sub_resource_load,
1003     texture2d_sub_resource_add_dirty_region,
1004     texture2d_sub_resource_invalidate_location,
1005     texture2d_sub_resource_validate_location,
1006     texture2d_sub_resource_upload_data,
1007     texture2d_load_location,
1008     texture2d_prepare_location,
1009     texture2d_prepare_texture,
1010     texture2d_cleanup_sub_resources,
1011 };
1012
1013 static ULONG texture_resource_incref(struct wined3d_resource *resource)
1014 {
1015     return wined3d_texture_incref(wined3d_texture_from_resource(resource));
1016 }
1017
1018 static ULONG texture_resource_decref(struct wined3d_resource *resource)
1019 {
1020     return wined3d_texture_decref(wined3d_texture_from_resource(resource));
1021 }
1022
1023 static void wined3d_texture_unload(struct wined3d_resource *resource)
1024 {
1025     struct wined3d_texture *texture = wined3d_texture_from_resource(resource);
1026     UINT sub_count = texture->level_count * texture->layer_count;
1027     struct wined3d_context *context = NULL;
1028     UINT i;
1029
1030     TRACE("texture %p.\n", texture);
1031
1032     for (i = 0; i < sub_count; ++i)
1033     {
1034         struct wined3d_resource *sub_resource = texture->sub_resources[i].resource;
1035
1036         sub_resource->resource_ops->resource_unload(sub_resource);
1037
1038         if (texture->sub_resources[i].buffer_object)
1039         {
1040             if (!context)
1041                 context = context_acquire(texture->resource.device, NULL);
1042             wined3d_texture_remove_buffer_object(texture, i, context->gl_info);
1043         }
1044     }
1045     if (context)
1046         context_release(context);
1047
1048     wined3d_texture_force_reload(texture);
1049     wined3d_texture_unload_gl_texture(texture);
1050 }
1051
1052 static HRESULT texture_resource_sub_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx,
1053         struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags)
1054 {
1055     const struct wined3d_format *format = resource->format;
1056     struct wined3d_device *device = resource->device;
1057     unsigned int fmt_flags = resource->format_flags;
1058     const struct wined3d_gl_info *gl_info = NULL;
1059     struct wined3d_context *context = NULL;
1060     struct wined3d_resource *sub_resource;
1061     struct wined3d_texture *texture;
1062     unsigned int texture_level;
1063     BYTE *base_memory;
1064     BOOL ret;
1065
1066     TRACE("resource %p, sub_resource_idx %u, map_desc %p, box %s, flags %#x.\n",
1067             resource, sub_resource_idx, map_desc, debug_box(box), flags);
1068
1069     texture = wined3d_texture_from_resource(resource);
1070     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
1071         return E_INVALIDARG;
1072
1073     texture_level = sub_resource_idx % texture->level_count;
1074     if (box && !wined3d_texture_check_box_dimensions(texture, texture_level, box))
1075     {
1076         WARN("Map box is invalid.\n");
1077         if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
1078             return WINED3DERR_INVALIDCALL;
1079     }
1080
1081     if ((fmt_flags & WINED3DFMT_FLAG_BLOCKS) && box
1082             && !wined3d_texture_check_block_align(texture, texture_level, box))
1083     {
1084         WARN("Map box %s is misaligned for %ux%u blocks.\n",
1085                 debug_box(box), format->block_width, format->block_height);
1086         if (resource->type != WINED3D_RTYPE_TEXTURE_2D || resource->pool == WINED3D_POOL_DEFAULT)
1087             return WINED3DERR_INVALIDCALL;
1088     }
1089
1090     if (!(resource->access_flags & WINED3D_RESOURCE_ACCESS_CPU))
1091     {
1092         WARN("Trying to map unmappable texture.\n");
1093         if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
1094             return WINED3DERR_INVALIDCALL;
1095     }
1096
1097     if (sub_resource->map_count)
1098     {
1099         WARN("Sub-resource is already mapped.\n");
1100         return WINED3DERR_INVALIDCALL;
1101     }
1102
1103     flags = wined3d_resource_sanitize_map_flags(resource, flags);
1104
1105     if (device->d3d_initialized)
1106     {
1107         context = context_acquire(device, NULL);
1108         gl_info = context->gl_info;
1109     }
1110
1111     if (flags & WINED3D_MAP_DISCARD)
1112     {
1113         TRACE("WINED3D_MAP_DISCARD flag passed, marking %s as up to date.\n",
1114                 wined3d_debug_location(sub_resource->map_binding));
1115         if ((ret = texture->texture_ops->texture_prepare_location(texture,
1116                 sub_resource_idx, context, sub_resource->map_binding)))
1117             texture->texture_ops->texture_sub_resource_validate_location(sub_resource, sub_resource->map_binding);
1118     }
1119     else
1120     {
1121         if (resource->usage & WINED3DUSAGE_DYNAMIC)
1122             WARN_(d3d_perf)("Mapping a dynamic texture without WINED3D_MAP_DISCARD.\n");
1123         ret = texture->texture_ops->texture_load_location(texture,
1124                 sub_resource_idx, context, sub_resource->map_binding);
1125     }
1126
1127     if (!ret)
1128     {
1129         ERR("Failed to prepare location.\n");
1130         context_release(context);
1131         return E_OUTOFMEMORY;
1132     }
1133
1134     if (!(flags & (WINED3D_MAP_NO_DIRTY_UPDATE | WINED3D_MAP_READONLY)))
1135         texture->texture_ops->texture_sub_resource_invalidate_location(sub_resource, ~sub_resource->map_binding);
1136
1137     switch (sub_resource->map_binding)
1138     {
1139         case WINED3D_LOCATION_SYSMEM:
1140             base_memory = sub_resource->heap_memory;
1141             break;
1142
1143         case WINED3D_LOCATION_USER_MEMORY:
1144             base_memory = texture->user_memory;
1145             break;
1146
1147         case WINED3D_LOCATION_DIB:
1148             if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
1149                 ERR("Invalid map binding %#x for resource type %#x.\n",
1150                         sub_resource->map_binding, resource->type);
1151             base_memory = texture->sub_resources[sub_resource_idx].u.surface->dib.bitmap_data;
1152             break;
1153
1154         case WINED3D_LOCATION_BUFFER:
1155             GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER,
1156                     texture->sub_resources[sub_resource_idx].buffer_object));
1157
1158             if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
1159             {
1160                 GLbitfield map_flags = wined3d_resource_gl_map_flags(flags);
1161                 map_flags &= ~GL_MAP_FLUSH_EXPLICIT_BIT;
1162                 base_memory = GL_EXTCALL(glMapBufferRange(GL_PIXEL_UNPACK_BUFFER,
1163                         0, sub_resource->size, map_flags));
1164             }
1165             else
1166             {
1167                 GLenum access = wined3d_resource_gl_legacy_map_flags(flags);
1168                 base_memory = GL_EXTCALL(glMapBuffer(GL_PIXEL_UNPACK_BUFFER, access));
1169             }
1170
1171             GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
1172             checkGLcall("Map PBO");
1173             break;
1174
1175         default:
1176             ERR("Unexpected map binding %s.\n", wined3d_debug_location(sub_resource->map_binding));
1177             base_memory = NULL;
1178             break;
1179     }
1180
1181     if (context)
1182         context_release(context);
1183
1184     TRACE("Base memory pointer %p.\n", base_memory);
1185
1186     if (fmt_flags & WINED3DFMT_FLAG_BROKEN_PITCH)
1187     {
1188         map_desc->row_pitch = wined3d_texture_get_level_width(texture, texture_level) * format->byte_count;
1189         map_desc->slice_pitch = wined3d_texture_get_level_height(texture, texture_level) * map_desc->row_pitch;
1190     }
1191     else
1192     {
1193         wined3d_texture_get_pitch(texture, texture_level, &map_desc->row_pitch, &map_desc->slice_pitch);
1194     }
1195
1196     if (!box)
1197     {
1198         map_desc->data = base_memory;
1199     }
1200     else
1201     {
1202         if ((fmt_flags & (WINED3DFMT_FLAG_BLOCKS | WINED3DFMT_FLAG_BROKEN_PITCH)) == WINED3DFMT_FLAG_BLOCKS)
1203         {
1204             /* Compressed textures are block based, so calculate the offset of
1205              * the block that contains the top-left pixel of the mapped box. */
1206             map_desc->data = base_memory
1207                     + (box->front * map_desc->slice_pitch)
1208                     + ((box->top / format->block_height) * map_desc->row_pitch)
1209                     + ((box->left / format->block_width) * format->block_byte_count);
1210         }
1211         else
1212         {
1213             map_desc->data = base_memory
1214                     + (box->front * map_desc->slice_pitch)
1215                     + (box->top * map_desc->row_pitch)
1216                     + (box->left * format->byte_count);
1217         }
1218     }
1219
1220     if (texture->swapchain && texture->swapchain->front_buffer == texture)
1221     {
1222         RECT *r = &texture->swapchain->front_buffer_update;
1223
1224         if (!box)
1225             SetRect(r, 0, 0, resource->width, resource->height);
1226         else
1227             SetRect(r, box->left, box->top, box->right, box->bottom);
1228         TRACE("Mapped front buffer %s.\n", wine_dbgstr_rect(r));
1229     }
1230
1231     ++sub_resource->map_count;
1232
1233     TRACE("Returning memory %p, row pitch %u, slice pitch %u.\n",
1234             map_desc->data, map_desc->row_pitch, map_desc->slice_pitch);
1235
1236     return WINED3D_OK;
1237 }
1238
1239 static HRESULT texture_resource_sub_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx)
1240 {
1241     const struct wined3d_gl_info *gl_info;
1242     struct wined3d_resource *sub_resource;
1243     struct wined3d_texture *texture;
1244     struct wined3d_context *context;
1245
1246     TRACE("resource %p, sub_resource_idx %u.\n", resource, sub_resource_idx);
1247
1248     texture = wined3d_texture_from_resource(resource);
1249     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
1250         return E_INVALIDARG;
1251
1252     if (!sub_resource->map_count)
1253     {
1254         WARN("Trying to unmap unmapped sub-resource.\n");
1255         return WINEDDERR_NOTLOCKED;
1256     }
1257
1258     switch (sub_resource->map_binding)
1259     {
1260         case WINED3D_LOCATION_SYSMEM:
1261         case WINED3D_LOCATION_USER_MEMORY:
1262         case WINED3D_LOCATION_DIB:
1263             break;
1264
1265         case WINED3D_LOCATION_BUFFER:
1266             context = context_acquire(resource->device, NULL);
1267             gl_info = context->gl_info;
1268
1269             GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER,
1270                     texture->sub_resources[sub_resource_idx].buffer_object));
1271             GL_EXTCALL(glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER));
1272             GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
1273             checkGLcall("glUnmapBuffer");
1274             context_release(context);
1275             break;
1276
1277         default:
1278             ERR("Unexpected map binding %s.\n", wined3d_debug_location(sub_resource->map_binding));
1279             break;
1280     }
1281
1282     if (texture->swapchain && texture->swapchain->front_buffer == texture)
1283     {
1284         struct wined3d_surface *surface = texture->sub_resources[sub_resource_idx].u.surface;
1285
1286         if (!(surface->locations & (WINED3D_LOCATION_DRAWABLE | WINED3D_LOCATION_TEXTURE_RGB)))
1287             texture->swapchain->swapchain_ops->swapchain_frontbuffer_updated(texture->swapchain);
1288     }
1289     else if (resource->format_flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
1290     {
1291         FIXME("Depth / stencil buffer locking is not implemented.\n");
1292     }
1293
1294     --sub_resource->map_count;
1295
1296     return WINED3D_OK;
1297 }
1298
1299 static const struct wined3d_resource_ops texture_resource_ops =
1300 {
1301     texture_resource_incref,
1302     texture_resource_decref,
1303     wined3d_texture_unload,
1304     texture_resource_sub_resource_map,
1305     texture_resource_sub_resource_unmap,
1306 };
1307
1308 static HRESULT texture_init(struct wined3d_texture *texture, const struct wined3d_resource_desc *desc,
1309         unsigned int layer_count, unsigned int level_count, DWORD flags, struct wined3d_device *device,
1310         void *parent, const struct wined3d_parent_ops *parent_ops)
1311 {
1312     struct wined3d_device_parent *device_parent = device->device_parent;
1313     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1314     struct wined3d_resource_desc surface_desc;
1315     struct wined3d_surface *surfaces;
1316     UINT pow2_width, pow2_height;
1317     unsigned int i, j;
1318     HRESULT hr;
1319
1320     /* TODO: It should only be possible to create textures for formats
1321      * that are reported as supported. */
1322     if (WINED3DFMT_UNKNOWN >= desc->format)
1323     {
1324         WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN.\n", texture);
1325         return WINED3DERR_INVALIDCALL;
1326     }
1327
1328     /* Non-power2 support. */
1329     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
1330     {
1331         pow2_width = desc->width;
1332         pow2_height = desc->height;
1333     }
1334     else
1335     {
1336         /* Find the nearest pow2 match. */
1337         pow2_width = pow2_height = 1;
1338         while (pow2_width < desc->width)
1339             pow2_width <<= 1;
1340         while (pow2_height < desc->height)
1341             pow2_height <<= 1;
1342
1343         if (pow2_width != desc->width || pow2_height != desc->height)
1344         {
1345             /* level_count == 0 returns an error as well */
1346             if (level_count != 1 || desc->usage & WINED3DUSAGE_LEGACY_CUBEMAP)
1347             {
1348                 if (desc->pool == WINED3D_POOL_SCRATCH)
1349                 {
1350                     WARN("Creating a scratch mipmapped/cube NPOT texture despite lack of HW support.\n");
1351                 }
1352                 else
1353                 {
1354                     WARN("Attempted to create a mipmapped/cube NPOT texture without unconditional NPOT support.\n");
1355                     return WINED3DERR_INVALIDCALL;
1356                 }
1357             }
1358         }
1359     }
1360
1361     /* Calculate levels for mip mapping. */
1362     if (desc->usage & WINED3DUSAGE_AUTOGENMIPMAP)
1363     {
1364         if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
1365         {
1366             WARN("No mipmap generation support, returning WINED3DERR_INVALIDCALL.\n");
1367             return WINED3DERR_INVALIDCALL;
1368         }
1369
1370         if (level_count != 1)
1371         {
1372             WARN("WINED3DUSAGE_AUTOGENMIPMAP is set, and level count != 1, returning WINED3DERR_INVALIDCALL.\n");
1373             return WINED3DERR_INVALIDCALL;
1374         }
1375     }
1376
1377     if (FAILED(hr = wined3d_texture_init(texture, &texture2d_ops, layer_count, level_count, desc,
1378             flags, device, parent, parent_ops, &texture_resource_ops)))
1379     {
1380         WARN("Failed to initialize texture, returning %#x.\n", hr);
1381         return hr;
1382     }
1383
1384     /* Precalculated scaling for 'faked' non power of two texture coords. */
1385     if (texture->resource.gl_type == WINED3D_GL_RES_TYPE_TEX_RECT)
1386     {
1387         texture->pow2_matrix[0] = (float)desc->width;
1388         texture->pow2_matrix[5] = (float)desc->height;
1389         texture->pow2_matrix[10] = 1.0f;
1390         texture->pow2_matrix[15] = 1.0f;
1391         texture->target = GL_TEXTURE_RECTANGLE_ARB;
1392         texture->flags |= WINED3D_TEXTURE_COND_NP2;
1393         texture->flags &= ~(WINED3D_TEXTURE_POW2_MAT_IDENT | WINED3D_TEXTURE_NORMALIZED_COORDS);
1394     }
1395     else
1396     {
1397         if (desc->usage & WINED3DUSAGE_LEGACY_CUBEMAP)
1398             texture->target = GL_TEXTURE_CUBE_MAP_ARB;
1399         else
1400             texture->target = GL_TEXTURE_2D;
1401         if (desc->width == pow2_width && desc->height == pow2_height)
1402         {
1403             texture->pow2_matrix[0] = 1.0f;
1404             texture->pow2_matrix[5] = 1.0f;
1405         }
1406         else if (gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT])
1407         {
1408             texture->pow2_matrix[0] = 1.0f;
1409             texture->pow2_matrix[5] = 1.0f;
1410             texture->flags |= WINED3D_TEXTURE_COND_NP2;
1411         }
1412         else
1413         {
1414             texture->pow2_matrix[0] = (((float)desc->width) / ((float)pow2_width));
1415             texture->pow2_matrix[5] = (((float)desc->height) / ((float)pow2_height));
1416             texture->flags &= ~WINED3D_TEXTURE_POW2_MAT_IDENT;
1417             texture->flags |= WINED3D_TEXTURE_COND_NP2_EMULATED;
1418         }
1419         texture->pow2_matrix[10] = 1.0f;
1420         texture->pow2_matrix[15] = 1.0f;
1421     }
1422     TRACE("xf(%f) yf(%f)\n", texture->pow2_matrix[0], texture->pow2_matrix[5]);
1423
1424     if (!(surfaces = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*surfaces) * level_count * layer_count)))
1425     {
1426         wined3d_texture_cleanup(texture);
1427         return E_OUTOFMEMORY;
1428     }
1429
1430     /* Generate all the surfaces. */
1431     surface_desc = *desc;
1432     surface_desc.resource_type = WINED3D_RTYPE_SURFACE;
1433     for (i = 0; i < texture->level_count; ++i)
1434     {
1435         for (j = 0; j < texture->layer_count; ++j)
1436         {
1437             static const GLenum cube_targets[6] =
1438             {
1439                 GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
1440                 GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB,
1441                 GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
1442                 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
1443                 GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
1444                 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB,
1445             };
1446             GLenum target = desc->usage & WINED3DUSAGE_LEGACY_CUBEMAP ? cube_targets[j] : texture->target;
1447             unsigned int idx = j * texture->level_count + i;
1448             struct wined3d_surface *surface;
1449
1450             surface = &surfaces[idx];
1451             if (FAILED(hr = wined3d_surface_init(surface, texture, &surface_desc, target, i, j, flags)))
1452             {
1453                 WARN("Failed to initialize surface, returning %#x.\n", hr);
1454                 wined3d_texture_cleanup(texture);
1455                 if (!idx)
1456                     HeapFree(GetProcessHeap(), 0, surfaces);
1457                 return hr;
1458             }
1459
1460             if (FAILED(hr = device_parent->ops->surface_created(device_parent,
1461                     texture, idx, &parent, &parent_ops)))
1462             {
1463                 WARN("Failed to create surface parent, hr %#x.\n", hr);
1464                 wined3d_surface_cleanup(surface);
1465                 wined3d_texture_cleanup(texture);
1466                 return hr;
1467             }
1468
1469             TRACE("parent %p, parent_ops %p.\n", parent, parent_ops);
1470
1471             surface->resource.parent = parent;
1472             surface->resource.parent_ops = parent_ops;
1473             texture->sub_resources[idx].resource = &surface->resource;
1474             texture->sub_resources[idx].u.surface = surface;
1475             TRACE("Created surface level %u, layer %u @ %p.\n", i, j, surface);
1476         }
1477         /* Calculate the next mipmap level. */
1478         surface_desc.width = max(1, surface_desc.width >> 1);
1479         surface_desc.height = max(1, surface_desc.height >> 1);
1480     }
1481
1482     return WINED3D_OK;
1483 }
1484
1485 static void texture3d_sub_resource_load(struct wined3d_resource *sub_resource,
1486         struct wined3d_context *context, BOOL srgb)
1487 {
1488     wined3d_volume_load(volume_from_resource(sub_resource), context, srgb);
1489 }
1490
1491 static void texture3d_sub_resource_add_dirty_region(struct wined3d_resource *sub_resource,
1492         const struct wined3d_box *dirty_region)
1493 {
1494     wined3d_texture_set_dirty(volume_from_resource(sub_resource)->container);
1495 }
1496
1497 static void texture3d_sub_resource_invalidate_location(struct wined3d_resource *sub_resource, DWORD location)
1498 {
1499     struct wined3d_volume *volume = volume_from_resource(sub_resource);
1500
1501     wined3d_volume_invalidate_location(volume, location);
1502 }
1503
1504 static void texture3d_sub_resource_validate_location(struct wined3d_resource *sub_resource, DWORD location)
1505 {
1506     struct wined3d_volume *volume = volume_from_resource(sub_resource);
1507
1508     wined3d_volume_validate_location(volume, location);
1509 }
1510
1511 static void texture3d_sub_resource_upload_data(struct wined3d_resource *sub_resource,
1512         const struct wined3d_context *context, const struct wined3d_sub_resource_data *data)
1513 {
1514     struct wined3d_volume *volume = volume_from_resource(sub_resource);
1515     struct wined3d_const_bo_address addr;
1516     unsigned int row_pitch, slice_pitch;
1517
1518     wined3d_texture_get_pitch(volume->container, volume->texture_level, &row_pitch, &slice_pitch);
1519     if (row_pitch != data->row_pitch || slice_pitch != data->slice_pitch)
1520         FIXME("Ignoring row/slice pitch (%u/%u).\n", data->row_pitch, data->slice_pitch);
1521
1522     addr.buffer_object = 0;
1523     addr.addr = data->data;
1524
1525     wined3d_volume_upload_data(volume, context, &addr);
1526 }
1527
1528 static BOOL texture3d_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx,
1529         struct wined3d_context *context, DWORD location)
1530 {
1531     return wined3d_volume_load_location(texture->sub_resources[sub_resource_idx].u.volume, context, location);
1532 }
1533
1534 static BOOL texture3d_prepare_location(struct wined3d_texture *texture, unsigned int sub_resource_idx,
1535         struct wined3d_context *context, DWORD location)
1536 {
1537     return wined3d_volume_prepare_location(texture->sub_resources[sub_resource_idx].u.volume, context, location);
1538 }
1539
1540 static void texture3d_prepare_texture(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
1541 {
1542     unsigned int sub_count = texture->level_count * texture->layer_count;
1543     const struct wined3d_format *format = texture->resource.format;
1544     const struct wined3d_gl_info *gl_info = context->gl_info;
1545     unsigned int i;
1546
1547     wined3d_texture_bind_and_dirtify(texture, context, srgb);
1548
1549     for (i = 0; i < sub_count; ++i)
1550     {
1551         struct wined3d_volume *volume = texture->sub_resources[i].u.volume;
1552
1553         GL_EXTCALL(glTexImage3D(GL_TEXTURE_3D, volume->texture_level,
1554                 srgb ? format->glGammaInternal : format->glInternal,
1555                 volume->resource.width, volume->resource.height, volume->resource.depth,
1556                 0, format->glFormat, format->glType, NULL));
1557         checkGLcall("glTexImage3D");
1558     }
1559 }
1560
1561 static void texture3d_cleanup_sub_resources(struct wined3d_texture *texture)
1562 {
1563     unsigned int sub_count = texture->level_count * texture->layer_count;
1564     struct wined3d_volume *volume;
1565     unsigned int i;
1566
1567     for (i = 0; i < sub_count; ++i)
1568     {
1569         if ((volume = texture->sub_resources[i].u.volume))
1570         {
1571             TRACE("volume %p.\n", volume);
1572
1573             wined3d_volume_cleanup(volume);
1574             volume->resource.parent_ops->wined3d_object_destroyed(volume->resource.parent);
1575         }
1576     }
1577     HeapFree(GetProcessHeap(), 0, texture->sub_resources[0].u.volume);
1578 }
1579
1580 static const struct wined3d_texture_ops texture3d_ops =
1581 {
1582     texture3d_sub_resource_load,
1583     texture3d_sub_resource_add_dirty_region,
1584     texture3d_sub_resource_invalidate_location,
1585     texture3d_sub_resource_validate_location,
1586     texture3d_sub_resource_upload_data,
1587     texture3d_load_location,
1588     texture3d_prepare_location,
1589     texture3d_prepare_texture,
1590     texture3d_cleanup_sub_resources,
1591 };
1592
1593 BOOL wined3d_texture_check_block_align(const struct wined3d_texture *texture,
1594         unsigned int level, const struct wined3d_box *box)
1595 {
1596     const struct wined3d_format *format = texture->resource.format;
1597     unsigned int height = wined3d_texture_get_level_height(texture, level);
1598     unsigned int width = wined3d_texture_get_level_width(texture, level);
1599     unsigned int width_mask, height_mask;
1600
1601     if ((box->left >= box->right)
1602             || (box->top >= box->bottom)
1603             || (box->right > width)
1604             || (box->bottom > height))
1605         return FALSE;
1606
1607     /* This assumes power of two block sizes, but NPOT block sizes would be
1608      * silly anyway.
1609      *
1610      * This also assumes that the format's block depth is 1. */
1611     width_mask = format->block_width - 1;
1612     height_mask = format->block_height - 1;
1613
1614     if ((box->left & width_mask) || (box->top & height_mask)
1615             || (box->right & width_mask && box->right != width)
1616             || (box->bottom & height_mask && box->bottom != height))
1617         return FALSE;
1618
1619     return TRUE;
1620 }
1621
1622 static HRESULT volumetexture_init(struct wined3d_texture *texture, const struct wined3d_resource_desc *desc,
1623         UINT levels, struct wined3d_device *device, void *parent, const struct wined3d_parent_ops *parent_ops)
1624 {
1625     struct wined3d_device_parent *device_parent = device->device_parent;
1626     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1627     struct wined3d_resource_desc volume_desc;
1628     struct wined3d_volume *volumes;
1629     unsigned int i;
1630     HRESULT hr;
1631
1632     /* TODO: It should only be possible to create textures for formats
1633      * that are reported as supported. */
1634     if (WINED3DFMT_UNKNOWN >= desc->format)
1635     {
1636         WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN.\n", texture);
1637         return WINED3DERR_INVALIDCALL;
1638     }
1639
1640     if (!gl_info->supported[EXT_TEXTURE3D])
1641     {
1642         WARN("(%p) : Texture cannot be created - no volume texture support.\n", texture);
1643         return WINED3DERR_INVALIDCALL;
1644     }
1645
1646     /* Calculate levels for mip mapping. */
1647     if (desc->usage & WINED3DUSAGE_AUTOGENMIPMAP)
1648     {
1649         if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
1650         {
1651             WARN("No mipmap generation support, returning D3DERR_INVALIDCALL.\n");
1652             return WINED3DERR_INVALIDCALL;
1653         }
1654
1655         if (levels != 1)
1656         {
1657             WARN("WINED3DUSAGE_AUTOGENMIPMAP is set, and level count != 1, returning D3DERR_INVALIDCALL.\n");
1658             return WINED3DERR_INVALIDCALL;
1659         }
1660     }
1661
1662     if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
1663     {
1664         UINT pow2_w, pow2_h, pow2_d;
1665         pow2_w = 1;
1666         while (pow2_w < desc->width)
1667             pow2_w <<= 1;
1668         pow2_h = 1;
1669         while (pow2_h < desc->height)
1670             pow2_h <<= 1;
1671         pow2_d = 1;
1672         while (pow2_d < desc->depth)
1673             pow2_d <<= 1;
1674
1675         if (pow2_w != desc->width || pow2_h != desc->height || pow2_d != desc->depth)
1676         {
1677             if (desc->pool == WINED3D_POOL_SCRATCH)
1678             {
1679                 WARN("Creating a scratch NPOT volume texture despite lack of HW support.\n");
1680             }
1681             else
1682             {
1683                 WARN("Attempted to create a NPOT volume texture (%u, %u, %u) without GL support.\n",
1684                         desc->width, desc->height, desc->depth);
1685                 return WINED3DERR_INVALIDCALL;
1686             }
1687         }
1688     }
1689
1690     if (FAILED(hr = wined3d_texture_init(texture, &texture3d_ops, 1, levels, desc,
1691             0, device, parent, parent_ops, &texture_resource_ops)))
1692     {
1693         WARN("Failed to initialize texture, returning %#x.\n", hr);
1694         return hr;
1695     }
1696
1697     texture->pow2_matrix[0] = 1.0f;
1698     texture->pow2_matrix[5] = 1.0f;
1699     texture->pow2_matrix[10] = 1.0f;
1700     texture->pow2_matrix[15] = 1.0f;
1701     texture->target = GL_TEXTURE_3D;
1702
1703     if (!(volumes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*volumes) * levels)))
1704     {
1705         wined3d_texture_cleanup(texture);
1706         return E_OUTOFMEMORY;
1707     }
1708
1709     /* Generate all the surfaces. */
1710     volume_desc = *desc;
1711     volume_desc.resource_type = WINED3D_RTYPE_VOLUME;
1712     for (i = 0; i < texture->level_count; ++i)
1713     {
1714         struct wined3d_volume *volume;
1715
1716         volume = &volumes[i];
1717         if (FAILED(hr = wined3d_volume_init(volume, texture, &volume_desc, i)))
1718         {
1719             WARN("Failed to initialize volume, returning %#x.\n", hr);
1720             wined3d_texture_cleanup(texture);
1721             if (!i)
1722                 HeapFree(GetProcessHeap(), 0, volumes);
1723             return hr;
1724         }
1725
1726         if (FAILED(hr = device_parent->ops->volume_created(device_parent,
1727                 texture, i, &parent, &parent_ops)))
1728         {
1729             WARN("Failed to create volume parent, hr %#x.\n", hr);
1730             wined3d_volume_cleanup(volume);
1731             wined3d_texture_cleanup(texture);
1732             return hr;
1733         }
1734
1735         TRACE("parent %p, parent_ops %p.\n", parent, parent_ops);
1736
1737         volume->resource.parent = parent;
1738         volume->resource.parent_ops = parent_ops;
1739         texture->sub_resources[i].resource = &volume->resource;
1740         texture->sub_resources[i].u.volume = volume;
1741         TRACE("Created volume level %u @ %p.\n", i, volume);
1742
1743         /* Calculate the next mipmap level. */
1744         volume_desc.width = max(1, volume_desc.width >> 1);
1745         volume_desc.height = max(1, volume_desc.height >> 1);
1746         volume_desc.depth = max(1, volume_desc.depth >> 1);
1747     }
1748
1749     return WINED3D_OK;
1750 }
1751
1752 HRESULT CDECL wined3d_texture_blt(struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx,
1753         const RECT *dst_rect, struct wined3d_texture *src_texture, unsigned int src_sub_resource_idx,
1754         const RECT *src_rect, DWORD flags, const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
1755 {
1756     struct wined3d_resource *dst_resource, *src_resource = NULL;
1757
1758     TRACE("dst_texture %p, dst_sub_resource_idx %u, dst_rect %s, src_texture %p, "
1759             "src_sub_resource_idx %u, src_rect %s, flags %#x, fx %p, filter %s.\n",
1760             dst_texture, dst_sub_resource_idx, wine_dbgstr_rect(dst_rect), src_texture,
1761             src_sub_resource_idx, wine_dbgstr_rect(src_rect), flags, fx, debug_d3dtexturefiltertype(filter));
1762
1763     if (!(dst_resource = wined3d_texture_get_sub_resource(dst_texture, dst_sub_resource_idx))
1764             || dst_resource->type != WINED3D_RTYPE_SURFACE)
1765         return WINED3DERR_INVALIDCALL;
1766
1767     if (src_texture)
1768     {
1769         if (!(src_resource = wined3d_texture_get_sub_resource(src_texture, src_sub_resource_idx))
1770                 || src_resource->type != WINED3D_RTYPE_SURFACE)
1771             return WINED3DERR_INVALIDCALL;
1772     }
1773
1774     return wined3d_surface_blt(surface_from_resource(dst_resource), dst_rect,
1775             src_resource ? surface_from_resource(src_resource) : NULL, src_rect, flags, fx, filter);
1776 }
1777
1778 HRESULT CDECL wined3d_texture_get_overlay_position(const struct wined3d_texture *texture,
1779         unsigned int sub_resource_idx, LONG *x, LONG *y)
1780 {
1781     struct wined3d_resource *sub_resource;
1782     struct wined3d_surface *surface;
1783
1784     TRACE("texture %p, sub_resource_idx %u, x %p, y %p.\n", texture, sub_resource_idx, x, y);
1785
1786     if (!(texture->resource.usage & WINED3DUSAGE_OVERLAY) || texture->resource.type != WINED3D_RTYPE_TEXTURE_2D
1787             || !(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
1788     {
1789         WARN("Invalid sub-resource specified.\n");
1790         return WINEDDERR_NOTAOVERLAYSURFACE;
1791     }
1792
1793     surface = surface_from_resource(sub_resource);
1794     if (!surface->overlay_dest)
1795     {
1796         TRACE("Overlay not visible.\n");
1797         *x = 0;
1798         *y = 0;
1799         return WINEDDERR_OVERLAYNOTVISIBLE;
1800     }
1801
1802     *x = surface->overlay_destrect.left;
1803     *y = surface->overlay_destrect.top;
1804
1805     TRACE("Returning position %d, %d.\n", *x, *y);
1806
1807     return WINED3D_OK;
1808 }
1809
1810 HRESULT CDECL wined3d_texture_set_overlay_position(struct wined3d_texture *texture,
1811         unsigned int sub_resource_idx, LONG x, LONG y)
1812 {
1813     struct wined3d_resource *sub_resource;
1814     struct wined3d_surface *surface;
1815     LONG w, h;
1816
1817     TRACE("texture %p, sub_resource_idx %u, x %d, y %d.\n", texture, sub_resource_idx, x, y);
1818
1819     if (!(texture->resource.usage & WINED3DUSAGE_OVERLAY) || texture->resource.type != WINED3D_RTYPE_TEXTURE_2D
1820             || !(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
1821     {
1822         WARN("Invalid sub-resource specified.\n");
1823         return WINEDDERR_NOTAOVERLAYSURFACE;
1824     }
1825
1826     surface = surface_from_resource(sub_resource);
1827     w = surface->overlay_destrect.right - surface->overlay_destrect.left;
1828     h = surface->overlay_destrect.bottom - surface->overlay_destrect.top;
1829     surface->overlay_destrect.left = x;
1830     surface->overlay_destrect.top = y;
1831     surface->overlay_destrect.right = x + w;
1832     surface->overlay_destrect.bottom = y + h;
1833
1834     return WINED3D_OK;
1835 }
1836
1837 HRESULT CDECL wined3d_texture_update_overlay(struct wined3d_texture *texture, unsigned int sub_resource_idx,
1838         const RECT *src_rect, struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx,
1839         const RECT *dst_rect, DWORD flags)
1840 {
1841     struct wined3d_resource *sub_resource, *dst_sub_resource;
1842     struct wined3d_surface *surface, *dst_surface;
1843
1844     TRACE("texture %p, sub_resource_idx %u, src_rect %s, dst_texture %p, "
1845             "dst_sub_resource_idx %u, dst_rect %s, flags %#x.\n",
1846             texture, sub_resource_idx, wine_dbgstr_rect(src_rect), dst_texture,
1847             dst_sub_resource_idx, wine_dbgstr_rect(dst_rect), flags);
1848
1849     if (!(texture->resource.usage & WINED3DUSAGE_OVERLAY) || texture->resource.type != WINED3D_RTYPE_TEXTURE_2D
1850             || !(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
1851     {
1852         WARN("Invalid sub-resource specified.\n");
1853         return WINEDDERR_NOTAOVERLAYSURFACE;
1854     }
1855
1856     if (!dst_texture || dst_texture->resource.type != WINED3D_RTYPE_TEXTURE_2D
1857             || !(dst_sub_resource = wined3d_texture_get_sub_resource(dst_texture, dst_sub_resource_idx)))
1858     {
1859         WARN("Invalid destination sub-resource specified.\n");
1860         return WINED3DERR_INVALIDCALL;
1861     }
1862
1863     surface = surface_from_resource(sub_resource);
1864     if (src_rect)
1865         surface->overlay_srcrect = *src_rect;
1866     else
1867         SetRect(&surface->overlay_srcrect, 0, 0, surface->resource.width, surface->resource.height);
1868
1869     dst_surface = surface_from_resource(dst_sub_resource);
1870     if (dst_rect)
1871         surface->overlay_destrect = *dst_rect;
1872     else
1873         SetRect(&surface->overlay_destrect, 0, 0, dst_surface->resource.width, dst_surface->resource.height);
1874
1875     if (surface->overlay_dest && (surface->overlay_dest != dst_surface || flags & WINEDDOVER_HIDE))
1876     {
1877         surface->overlay_dest = NULL;
1878         list_remove(&surface->overlay_entry);
1879     }
1880
1881     if (flags & WINEDDOVER_SHOW)
1882     {
1883         if (surface->overlay_dest != dst_surface)
1884         {
1885             surface->overlay_dest = dst_surface;
1886             list_add_tail(&dst_surface->overlays, &surface->overlay_entry);
1887         }
1888     }
1889     else if (flags & WINEDDOVER_HIDE)
1890     {
1891         /* Tests show that the rectangles are erased on hide. */
1892         SetRectEmpty(&surface->overlay_srcrect);
1893         SetRectEmpty(&surface->overlay_destrect);
1894         surface->overlay_dest = NULL;
1895     }
1896
1897     return WINED3D_OK;
1898 }
1899
1900 void * CDECL wined3d_texture_get_sub_resource_parent(struct wined3d_texture *texture, unsigned int sub_resource_idx)
1901 {
1902     unsigned int sub_count = texture->level_count * texture->layer_count;
1903
1904     TRACE("texture %p, sub_resource_idx %u.\n", texture, sub_resource_idx);
1905
1906     if (sub_resource_idx >= sub_count)
1907     {
1908         WARN("sub_resource_idx %u >= sub_count %u.\n", sub_resource_idx, sub_count);
1909         return NULL;
1910     }
1911
1912     return texture->sub_resources[sub_resource_idx].resource->parent;
1913 }
1914
1915 void CDECL wined3d_texture_set_sub_resource_parent(struct wined3d_texture *texture,
1916         unsigned int sub_resource_idx, void *parent)
1917 {
1918     unsigned int sub_count = texture->level_count * texture->layer_count;
1919
1920     TRACE("texture %p, sub_resource_idx %u, parent %p.\n", texture, sub_resource_idx, parent);
1921
1922     if (sub_resource_idx >= sub_count)
1923     {
1924         WARN("sub_resource_idx %u >= sub_count %u.\n", sub_resource_idx, sub_count);
1925         return;
1926     }
1927
1928     texture->sub_resources[sub_resource_idx].resource->parent = parent;
1929 }
1930
1931 HRESULT CDECL wined3d_texture_get_sub_resource_desc(const struct wined3d_texture *texture,
1932         unsigned int sub_resource_idx, struct wined3d_sub_resource_desc *desc)
1933 {
1934     unsigned int sub_count = texture->level_count * texture->layer_count;
1935     const struct wined3d_resource *resource;
1936     unsigned int level_idx;
1937
1938     TRACE("texture %p, sub_resource_idx %u, desc %p.\n", texture, sub_resource_idx, desc);
1939
1940     if (sub_resource_idx >= sub_count)
1941     {
1942         WARN("sub_resource_idx %u >= sub_count %u.\n", sub_resource_idx, sub_count);
1943         return WINED3DERR_INVALIDCALL;
1944     }
1945
1946     resource = &texture->resource;
1947     desc->format = resource->format->id;
1948     desc->multisample_type = resource->multisample_type;
1949     desc->multisample_quality = resource->multisample_quality;
1950     desc->usage = resource->usage;
1951     desc->pool = resource->pool;
1952
1953     level_idx = sub_resource_idx % texture->level_count;
1954     desc->width = wined3d_texture_get_level_width(texture, level_idx);
1955     desc->height = wined3d_texture_get_level_height(texture, level_idx);
1956     desc->depth = wined3d_texture_get_level_depth(texture, level_idx);
1957     desc->size = texture->sub_resources[sub_resource_idx].resource->size;
1958
1959     return WINED3D_OK;
1960 }
1961
1962 HRESULT CDECL wined3d_texture_create(struct wined3d_device *device, const struct wined3d_resource_desc *desc,
1963         UINT level_count, DWORD flags, const struct wined3d_sub_resource_data *data, void *parent,
1964         const struct wined3d_parent_ops *parent_ops, struct wined3d_texture **texture)
1965 {
1966     unsigned int layer_count = desc->usage & WINED3DUSAGE_LEGACY_CUBEMAP ? 6 : 1;
1967     struct wined3d_texture *object;
1968     HRESULT hr;
1969
1970     TRACE("device %p, desc %p, level_count %u, flags %#x, data %p, parent %p, parent_ops %p, texture %p.\n",
1971             device, desc, level_count, flags, data, parent, parent_ops, texture);
1972
1973     if (!level_count)
1974     {
1975         WARN("Invalid level count.\n");
1976         return WINED3DERR_INVALIDCALL;
1977     }
1978
1979     if (desc->multisample_type != WINED3D_MULTISAMPLE_NONE)
1980     {
1981         const struct wined3d_format *format = wined3d_get_format(&device->adapter->gl_info, desc->format);
1982
1983         if (desc->multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE
1984                 && desc->multisample_quality >= wined3d_popcount(format->multisample_types))
1985         {
1986             WARN("Unsupported quality level %u requested for WINED3D_MULTISAMPLE_NON_MASKABLE.\n",
1987                     desc->multisample_quality);
1988             return WINED3DERR_NOTAVAILABLE;
1989         }
1990         if (desc->multisample_type != WINED3D_MULTISAMPLE_NON_MASKABLE
1991                 && (!(format->multisample_types & 1u << (desc->multisample_type - 1))
1992                 || desc->multisample_quality))
1993         {
1994             WARN("Unsupported multisample type %u quality %u requested.\n", desc->multisample_type,
1995                     desc->multisample_quality);
1996             return WINED3DERR_NOTAVAILABLE;
1997         }
1998     }
1999
2000     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2001             FIELD_OFFSET(struct wined3d_texture, sub_resources[level_count * layer_count]))))
2002         return E_OUTOFMEMORY;
2003
2004     switch (desc->resource_type)
2005     {
2006         case WINED3D_RTYPE_TEXTURE_2D:
2007             hr = texture_init(object, desc, layer_count, level_count, flags, device, parent, parent_ops);
2008             break;
2009
2010         case WINED3D_RTYPE_TEXTURE_3D:
2011             hr = volumetexture_init(object, desc, level_count, device, parent, parent_ops);
2012             break;
2013
2014         default:
2015             ERR("Invalid resource type %s.\n", debug_d3dresourcetype(desc->resource_type));
2016             hr = WINED3DERR_INVALIDCALL;
2017             break;
2018     }
2019
2020     if (FAILED(hr))
2021     {
2022         WARN("Failed to initialize texture, returning %#x.\n", hr);
2023         HeapFree(GetProcessHeap(), 0, object);
2024         return hr;
2025     }
2026
2027     /* FIXME: We'd like to avoid ever allocating system memory for the texture
2028      * in this case. */
2029     if (data && FAILED(hr = wined3d_texture_upload_data(object, data)))
2030     {
2031         wined3d_texture_cleanup(object);
2032         HeapFree(GetProcessHeap(), 0, object);
2033         return hr;
2034     }
2035
2036     TRACE("Created texture %p.\n", object);
2037     *texture = object;
2038
2039     return WINED3D_OK;
2040 }
2041
2042 HRESULT CDECL wined3d_texture_get_dc(struct wined3d_texture *texture, unsigned int sub_resource_idx, HDC *dc)
2043 {
2044     struct wined3d_device *device = texture->resource.device;
2045     struct wined3d_context *context = NULL;
2046     struct wined3d_resource *sub_resource;
2047     struct wined3d_surface *surface;
2048     HRESULT hr;
2049
2050     TRACE("texture %p, sub_resource_idx %u, dc %p.\n", texture, sub_resource_idx, dc);
2051
2052     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
2053         return WINED3DERR_INVALIDCALL;
2054
2055     if (sub_resource->type != WINED3D_RTYPE_SURFACE)
2056     {
2057         WARN("Not supported on %s resources.\n", debug_d3dresourcetype(texture->resource.type));
2058         return WINED3DERR_INVALIDCALL;
2059     }
2060
2061     surface = surface_from_resource(sub_resource);
2062
2063     /* Give more detailed info for ddraw. */
2064     if (surface->flags & SFLAG_DCINUSE)
2065         return WINEDDERR_DCALREADYCREATED;
2066
2067     /* Can't GetDC if the surface is locked. */
2068     if (surface->resource.map_count)
2069         return WINED3DERR_INVALIDCALL;
2070
2071     if (device->d3d_initialized)
2072         context = context_acquire(device, NULL);
2073
2074     /* Create a DIB section if there isn't a dc yet. */
2075     if (!surface->hDC)
2076     {
2077         if (FAILED(hr = surface_create_dib_section(surface)))
2078         {
2079             if (context)
2080                 context_release(context);
2081              return WINED3DERR_INVALIDCALL;
2082         }
2083         if (!(surface->resource.map_binding == WINED3D_LOCATION_USER_MEMORY
2084                 || texture->flags & WINED3D_TEXTURE_PIN_SYSMEM
2085                 || texture->sub_resources[sub_resource_idx].buffer_object))
2086             surface->resource.map_binding = WINED3D_LOCATION_DIB;
2087     }
2088
2089     surface_load_location(surface, context, WINED3D_LOCATION_DIB);
2090     surface_invalidate_location(surface, ~WINED3D_LOCATION_DIB);
2091
2092     if (context)
2093         context_release(context);
2094
2095     surface->flags |= SFLAG_DCINUSE;
2096     surface->resource.map_count++;
2097
2098     *dc = surface->hDC;
2099     TRACE("Returning dc %p.\n", *dc);
2100
2101     return WINED3D_OK;
2102 }
2103
2104 HRESULT CDECL wined3d_texture_release_dc(struct wined3d_texture *texture, unsigned int sub_resource_idx, HDC dc)
2105 {
2106     struct wined3d_device *device = texture->resource.device;
2107     struct wined3d_context *context = NULL;
2108     struct wined3d_resource *sub_resource;
2109     struct wined3d_surface *surface;
2110
2111     TRACE("texture %p, sub_resource_idx %u, dc %p.\n", texture, sub_resource_idx, dc);
2112
2113     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
2114         return WINED3DERR_INVALIDCALL;
2115
2116     if (sub_resource->type != WINED3D_RTYPE_SURFACE)
2117     {
2118         WARN("Not supported on %s resources.\n", debug_d3dresourcetype(texture->resource.type));
2119         return WINED3DERR_INVALIDCALL;
2120     }
2121
2122     surface = surface_from_resource(sub_resource);
2123
2124     if (!(surface->flags & SFLAG_DCINUSE))
2125         return WINEDDERR_NODC;
2126
2127     if (surface->hDC != dc)
2128     {
2129         WARN("Application tries to release invalid DC %p, surface DC is %p.\n",
2130                 dc, surface->hDC);
2131         return WINEDDERR_NODC;
2132     }
2133
2134     surface->resource.map_count--;
2135     surface->flags &= ~SFLAG_DCINUSE;
2136
2137     if (surface->resource.map_binding == WINED3D_LOCATION_USER_MEMORY
2138             || (surface->container->flags & WINED3D_TEXTURE_PIN_SYSMEM
2139             && surface->resource.map_binding != WINED3D_LOCATION_DIB))
2140     {
2141         /* The game Salammbo modifies the surface contents without mapping the surface between
2142          * a GetDC/ReleaseDC operation and flipping the surface. If the DIB remains the active
2143          * copy and is copied to the screen, this update, which draws the mouse pointer, is lost.
2144          * Do not only copy the DIB to the map location, but also make sure the map location is
2145          * copied back to the DIB in the next getdc call.
2146          *
2147          * The same consideration applies to user memory surfaces. */
2148
2149         if (device->d3d_initialized)
2150             context = context_acquire(device, NULL);
2151
2152         surface_load_location(surface, context, surface->resource.map_binding);
2153         surface_invalidate_location(surface, WINED3D_LOCATION_DIB);
2154         if (context)
2155             context_release(context);
2156     }
2157
2158     return WINED3D_OK;
2159 }