wined3d: Add argument check for Type to Get/SetTextureStageState().
[wine] / dlls / wined3d / texture.c
1 /*
2  * IWineD3DTexture implementation
3  *
4  * Copyright 2002-2005 Jason Edmeades
5  * Copyright 2002-2005 Raphael Junqueira
6  * Copyright 2005 Oliver Stieber
7  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
8  * Copyright 2009 Henri Verbeet for CodeWeavers
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23  */
24
25 #include "config.h"
26 #include "wined3d_private.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d_texture);
29
30 /* Do not call while under the GL lock. */
31 static void texture_internal_preload(IWineD3DBaseTexture *iface, enum WINED3DSRGB srgb)
32 {
33     /* Override the IWineD3DResource PreLoad method. */
34     IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
35     IWineD3DDeviceImpl *device = This->resource.device;
36     struct wined3d_context *context = NULL;
37     unsigned int i;
38     BOOL srgb_mode;
39     BOOL *dirty;
40
41     TRACE("(%p) : About to load texture.\n", This);
42
43     switch (srgb)
44     {
45         case SRGB_RGB:
46             srgb_mode = FALSE;
47             break;
48
49         case SRGB_BOTH:
50             texture_internal_preload(iface, SRGB_RGB);
51             /* Fallthrough */
52
53         case SRGB_SRGB:
54             srgb_mode = TRUE;
55             break;
56
57         default:
58             srgb_mode = This->baseTexture.is_srgb;
59             break;
60     }
61     dirty = srgb_mode ? &This->baseTexture.texture_srgb.dirty : &This->baseTexture.texture_rgb.dirty;
62
63     if (!device->isInDraw)
64     {
65         /* context_acquire() sets isInDraw to TRUE when loading a pbuffer into a texture,
66          * thus no danger of recursive calls. */
67         context = context_acquire(device, NULL);
68     }
69
70     if (This->resource.format->id == WINED3DFMT_P8_UINT
71             || This->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
72     {
73         for (i = 0; i < This->baseTexture.level_count; ++i)
74         {
75             IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)This->baseTexture.sub_resources[i];
76             if (palette9_changed(surface))
77             {
78                 TRACE("Reloading surface because the d3d8/9 palette was changed.\n");
79                 /* TODO: This is not necessarily needed with hw palettized texture support. */
80                 surface_load_location(surface, SFLAG_INSYSMEM, NULL);
81                 /* Make sure the texture is reloaded because of the palette change, this kills performance though :( */
82                 surface_modify_location(surface, SFLAG_INTEXTURE, FALSE);
83             }
84         }
85     }
86
87     /* If the texture is marked dirty or the srgb sampler setting has changed
88      * since the last load then reload the surfaces. */
89     if (*dirty)
90     {
91         for (i = 0; i < This->baseTexture.level_count; ++i)
92         {
93             IWineD3DSurface_LoadTexture((IWineD3DSurface *)This->baseTexture.sub_resources[i], srgb_mode);
94         }
95     }
96     else
97     {
98         TRACE("(%p) Texture not dirty, nothing to do.\n", iface);
99     }
100
101     if (context) context_release(context);
102
103     /* No longer dirty. */
104     *dirty = FALSE;
105 }
106
107 static void texture_cleanup(IWineD3DTextureImpl *This)
108 {
109     unsigned int i;
110
111     TRACE("(%p) : Cleaning up\n", This);
112
113     for (i = 0; i < This->baseTexture.level_count; ++i)
114     {
115         IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)This->baseTexture.sub_resources[i];
116         if (surface)
117         {
118             /* Clean out the texture name we gave to the surface so that the
119              * surface doesn't try and release it */
120             surface_set_texture_name(surface, 0, TRUE);
121             surface_set_texture_name(surface, 0, FALSE);
122             surface_set_texture_target(surface, 0);
123             surface_set_container(surface, WINED3D_CONTAINER_NONE, NULL);
124             IWineD3DSurface_Release((IWineD3DSurface *)surface);
125         }
126     }
127
128     TRACE("(%p) : Cleaning up base texture\n", This);
129     basetexture_cleanup((IWineD3DBaseTexture *)This);
130 }
131
132 /* *******************************************
133    IWineD3DTexture IUnknown parts follow
134    ******************************************* */
135
136 static HRESULT WINAPI IWineD3DTextureImpl_QueryInterface(IWineD3DTexture *iface, REFIID riid, LPVOID *ppobj)
137 {
138     IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
139     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
140     if (IsEqualGUID(riid, &IID_IUnknown)
141         || IsEqualGUID(riid, &IID_IWineD3DBase)
142         || IsEqualGUID(riid, &IID_IWineD3DResource)
143         || IsEqualGUID(riid, &IID_IWineD3DBaseTexture)
144         || IsEqualGUID(riid, &IID_IWineD3DTexture)){
145         IUnknown_AddRef(iface);
146         *ppobj = This;
147         return WINED3D_OK;
148     }
149     *ppobj = NULL;
150     return E_NOINTERFACE;
151 }
152
153 static ULONG WINAPI IWineD3DTextureImpl_AddRef(IWineD3DTexture *iface) {
154     IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
155     TRACE("(%p) : AddRef increasing from %d\n", This, This->resource.ref);
156     return InterlockedIncrement(&This->resource.ref);
157 }
158
159 /* Do not call while under the GL lock. */
160 static ULONG WINAPI IWineD3DTextureImpl_Release(IWineD3DTexture *iface) {
161     IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
162     ULONG ref;
163     TRACE("(%p) : Releasing from %d\n", This, This->resource.ref);
164     ref = InterlockedDecrement(&This->resource.ref);
165     if (!ref)
166     {
167         texture_cleanup(This);
168         This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent);
169         HeapFree(GetProcessHeap(), 0, This);
170     }
171     return ref;
172 }
173
174
175 /* ****************************************************
176    IWineD3DTexture IWineD3DResource parts follow
177    **************************************************** */
178 static HRESULT WINAPI IWineD3DTextureImpl_SetPrivateData(IWineD3DTexture *iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) {
179     return resource_set_private_data((IWineD3DResource *)iface, refguid, pData, SizeOfData, Flags);
180 }
181
182 static HRESULT WINAPI IWineD3DTextureImpl_GetPrivateData(IWineD3DTexture *iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) {
183     return resource_get_private_data((IWineD3DResource *)iface, refguid, pData, pSizeOfData);
184 }
185
186 static HRESULT WINAPI IWineD3DTextureImpl_FreePrivateData(IWineD3DTexture *iface, REFGUID refguid) {
187     return resource_free_private_data((IWineD3DResource *)iface, refguid);
188 }
189
190 static DWORD WINAPI IWineD3DTextureImpl_SetPriority(IWineD3DTexture *iface, DWORD PriorityNew) {
191     return resource_set_priority((IWineD3DResource *)iface, PriorityNew);
192 }
193
194 static DWORD WINAPI IWineD3DTextureImpl_GetPriority(IWineD3DTexture *iface) {
195     return resource_get_priority((IWineD3DResource *)iface);
196 }
197
198 /* Do not call while under the GL lock. */
199 static void WINAPI IWineD3DTextureImpl_PreLoad(IWineD3DTexture *iface) {
200     texture_internal_preload((IWineD3DBaseTexture *) iface, SRGB_ANY);
201 }
202
203 /* Do not call while under the GL lock. */
204 static void WINAPI IWineD3DTextureImpl_UnLoad(IWineD3DTexture *iface) {
205     unsigned int i;
206     IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
207     TRACE("(%p)\n", This);
208
209     /* Unload all the surfaces and reset the texture name. If UnLoad was called on the
210      * surface before, this one will be a NOP and vice versa. Unloading an unloaded
211      * surface is fine
212      */
213     for (i = 0; i < This->baseTexture.level_count; ++i)
214     {
215         IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)This->baseTexture.sub_resources[i];
216         IWineD3DSurface_UnLoad((IWineD3DSurface *)surface);
217         surface_set_texture_name(surface, 0, FALSE); /* Delete rgb name */
218         surface_set_texture_name(surface, 0, TRUE); /* delete srgb name */
219     }
220
221     basetexture_unload((IWineD3DBaseTexture *)iface);
222 }
223
224 static WINED3DRESOURCETYPE WINAPI IWineD3DTextureImpl_GetType(IWineD3DTexture *iface) {
225     return resource_get_type((IWineD3DResource *)iface);
226 }
227
228 static void * WINAPI IWineD3DTextureImpl_GetParent(IWineD3DTexture *iface)
229 {
230     TRACE("iface %p.\n", iface);
231
232     return ((IWineD3DTextureImpl *)iface)->resource.parent;
233 }
234
235 /* ******************************************************
236    IWineD3DTexture IWineD3DBaseTexture parts follow
237    ****************************************************** */
238 static DWORD WINAPI IWineD3DTextureImpl_SetLOD(IWineD3DTexture *iface, DWORD LODNew) {
239     return basetexture_set_lod((IWineD3DBaseTexture *)iface, LODNew);
240 }
241
242 static DWORD WINAPI IWineD3DTextureImpl_GetLOD(IWineD3DTexture *iface) {
243     return basetexture_get_lod((IWineD3DBaseTexture *)iface);
244 }
245
246 static DWORD WINAPI IWineD3DTextureImpl_GetLevelCount(IWineD3DTexture *iface) {
247     return basetexture_get_level_count((IWineD3DBaseTexture *)iface);
248 }
249
250 static HRESULT WINAPI IWineD3DTextureImpl_SetAutoGenFilterType(IWineD3DTexture *iface, WINED3DTEXTUREFILTERTYPE FilterType) {
251   return basetexture_set_autogen_filter_type((IWineD3DBaseTexture *)iface, FilterType);
252 }
253
254 static WINED3DTEXTUREFILTERTYPE WINAPI IWineD3DTextureImpl_GetAutoGenFilterType(IWineD3DTexture *iface) {
255   return basetexture_get_autogen_filter_type((IWineD3DBaseTexture *)iface);
256 }
257
258 static void WINAPI IWineD3DTextureImpl_GenerateMipSubLevels(IWineD3DTexture *iface) {
259     basetexture_generate_mipmaps((IWineD3DBaseTexture *)iface);
260 }
261
262 /* Internal function, No d3d mapping */
263 static BOOL WINAPI IWineD3DTextureImpl_SetDirty(IWineD3DTexture *iface, BOOL dirty) {
264     return basetexture_set_dirty((IWineD3DBaseTexture *)iface, dirty);
265 }
266
267 static BOOL WINAPI IWineD3DTextureImpl_GetDirty(IWineD3DTexture *iface) {
268     return basetexture_get_dirty((IWineD3DBaseTexture *)iface);
269 }
270
271 /* Context activation is done by the caller. */
272 static HRESULT WINAPI IWineD3DTextureImpl_BindTexture(IWineD3DTexture *iface, BOOL srgb) {
273     IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
274     BOOL set_gl_texture_desc;
275     HRESULT hr;
276
277     TRACE("(%p) : relay to BaseTexture\n", This);
278
279     hr = basetexture_bind((IWineD3DBaseTexture *)iface, srgb, &set_gl_texture_desc);
280     if (set_gl_texture_desc && SUCCEEDED(hr)) {
281         UINT i;
282         struct gl_texture *gl_tex;
283
284         if(This->baseTexture.is_srgb) {
285             gl_tex = &This->baseTexture.texture_srgb;
286         } else {
287             gl_tex = &This->baseTexture.texture_rgb;
288         }
289
290         for (i = 0; i < This->baseTexture.level_count; ++i)
291         {
292             IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)This->baseTexture.sub_resources[i];
293             surface_set_texture_name(surface, gl_tex->name, This->baseTexture.is_srgb);
294         }
295
296         /* Conditinal non power of two textures use a different clamping
297          * default. If we're using the GL_WINE_normalized_texrect partial
298          * driver emulation, we're dealing with a GL_TEXTURE_2D texture which
299          * has the address mode set to repeat - something that prevents us
300          * from hitting the accelerated codepath. Thus manually set the GL
301          * state. The same applies to filtering. Even if the texture has only
302          * one mip level, the default LINEAR_MIPMAP_LINEAR filter causes a SW
303          * fallback on macos. */
304         if(IWineD3DBaseTexture_IsCondNP2(iface)) {
305             ENTER_GL();
306             glTexParameteri(IWineD3DTexture_GetTextureDimensions(iface), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
307             checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)");
308             glTexParameteri(IWineD3DTexture_GetTextureDimensions(iface), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
309             checkGLcall("glTexParameteri(dimension, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)");
310             glTexParameteri(IWineD3DTexture_GetTextureDimensions(iface), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
311             checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MIN_FILTER, GL_NEAREST)");
312             glTexParameteri(IWineD3DTexture_GetTextureDimensions(iface), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
313             checkGLcall("glTexParameteri(dimension, GL_TEXTURE_MAG_FILTER, GL_NEAREST)");
314             LEAVE_GL();
315             gl_tex->states[WINED3DTEXSTA_ADDRESSU]      = WINED3DTADDRESS_CLAMP;
316             gl_tex->states[WINED3DTEXSTA_ADDRESSV]      = WINED3DTADDRESS_CLAMP;
317             gl_tex->states[WINED3DTEXSTA_MAGFILTER]     = WINED3DTEXF_POINT;
318             gl_tex->states[WINED3DTEXSTA_MINFILTER]     = WINED3DTEXF_POINT;
319             gl_tex->states[WINED3DTEXSTA_MIPFILTER]     = WINED3DTEXF_NONE;
320         }
321     }
322
323     return hr;
324 }
325
326 static UINT WINAPI IWineD3DTextureImpl_GetTextureDimensions(IWineD3DTexture *iface) {
327     IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
328     TRACE("(%p)\n", This);
329
330     return This->target;
331 }
332
333 static BOOL WINAPI IWineD3DTextureImpl_IsCondNP2(IWineD3DTexture *iface) {
334     IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
335     TRACE("(%p)\n", This);
336
337     return This->cond_np2;
338 }
339
340 /* *******************************************
341    IWineD3DTexture IWineD3DTexture parts follow
342    ******************************************* */
343 static HRESULT WINAPI IWineD3DTextureImpl_GetLevelDesc(IWineD3DTexture *iface, UINT level, WINED3DSURFACE_DESC *desc)
344 {
345     IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
346     IWineD3DSurface *surface;
347
348     TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
349
350     if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, 0, level)))
351     {
352         WARN("Failed to get sub-resource.\n");
353         return WINED3DERR_INVALIDCALL;
354     }
355
356     IWineD3DSurface_GetDesc(surface, desc);
357
358     return WINED3D_OK;
359 }
360
361 static HRESULT WINAPI IWineD3DTextureImpl_GetSurfaceLevel(IWineD3DTexture *iface,
362         UINT level, IWineD3DSurface **surface)
363 {
364     IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
365     IWineD3DSurface *s;
366
367     TRACE("iface %p, level %u, surface %p.\n", iface, level, surface);
368
369     if (!(s = (IWineD3DSurface *)basetexture_get_sub_resource(texture, 0, level)))
370     {
371         WARN("Failed to get sub-resource.\n");
372         return WINED3DERR_INVALIDCALL;
373     }
374
375     IWineD3DSurface_AddRef(s);
376     *surface = s;
377
378     TRACE("Returning surface %p.\n", *surface);
379
380     return WINED3D_OK;
381 }
382
383 static HRESULT WINAPI IWineD3DTextureImpl_LockRect(IWineD3DTexture *iface,
384         UINT level, WINED3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
385 {
386     IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
387     IWineD3DSurface *surface;
388
389     TRACE("iface %p, level %u, locked_rect %p, rect %s, flags %#x.\n",
390             iface, level, locked_rect, wine_dbgstr_rect(rect), flags);
391
392     if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, 0, level)))
393     {
394         WARN("Failed to get sub-resource.\n");
395         return WINED3DERR_INVALIDCALL;
396     }
397
398     return IWineD3DSurface_LockRect(surface, locked_rect, rect, flags);
399 }
400
401 static HRESULT WINAPI IWineD3DTextureImpl_UnlockRect(IWineD3DTexture *iface, UINT level)
402 {
403     IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
404     IWineD3DSurface *surface;
405
406     TRACE("iface %p, level %u.\n", iface, level);
407
408     if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, 0, level)))
409     {
410         WARN("Failed to get sub-resource.\n");
411         return WINED3DERR_INVALIDCALL;
412     }
413
414     return IWineD3DSurface_UnlockRect(surface);
415 }
416
417 static HRESULT WINAPI IWineD3DTextureImpl_AddDirtyRect(IWineD3DTexture *iface, const RECT *dirty_rect)
418 {
419     IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
420     IWineD3DSurfaceImpl *surface;
421
422     TRACE("iface %p, dirty_rect %s.\n", iface, wine_dbgstr_rect(dirty_rect));
423
424     if (!(surface = (IWineD3DSurfaceImpl *)basetexture_get_sub_resource(texture, 0, 0)))
425     {
426         WARN("Failed to get sub-resource.\n");
427         return WINED3DERR_INVALIDCALL;
428     }
429
430     texture->baseTexture.texture_rgb.dirty = TRUE;
431     texture->baseTexture.texture_srgb.dirty = TRUE;
432     surface_add_dirty_rect(surface, dirty_rect);
433
434     return WINED3D_OK;
435 }
436
437 static const IWineD3DTextureVtbl IWineD3DTexture_Vtbl =
438 {
439     /* IUnknown */
440     IWineD3DTextureImpl_QueryInterface,
441     IWineD3DTextureImpl_AddRef,
442     IWineD3DTextureImpl_Release,
443     /* IWineD3DResource */
444     IWineD3DTextureImpl_GetParent,
445     IWineD3DTextureImpl_SetPrivateData,
446     IWineD3DTextureImpl_GetPrivateData,
447     IWineD3DTextureImpl_FreePrivateData,
448     IWineD3DTextureImpl_SetPriority,
449     IWineD3DTextureImpl_GetPriority,
450     IWineD3DTextureImpl_PreLoad,
451     IWineD3DTextureImpl_UnLoad,
452     IWineD3DTextureImpl_GetType,
453     /* IWineD3DBaseTexture */
454     IWineD3DTextureImpl_SetLOD,
455     IWineD3DTextureImpl_GetLOD,
456     IWineD3DTextureImpl_GetLevelCount,
457     IWineD3DTextureImpl_SetAutoGenFilterType,
458     IWineD3DTextureImpl_GetAutoGenFilterType,
459     IWineD3DTextureImpl_GenerateMipSubLevels,
460     IWineD3DTextureImpl_SetDirty,
461     IWineD3DTextureImpl_GetDirty,
462     IWineD3DTextureImpl_BindTexture,
463     IWineD3DTextureImpl_GetTextureDimensions,
464     IWineD3DTextureImpl_IsCondNP2,
465     /* IWineD3DTexture */
466     IWineD3DTextureImpl_GetLevelDesc,
467     IWineD3DTextureImpl_GetSurfaceLevel,
468     IWineD3DTextureImpl_LockRect,
469     IWineD3DTextureImpl_UnlockRect,
470     IWineD3DTextureImpl_AddDirtyRect
471 };
472
473 HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT levels,
474         IWineD3DDeviceImpl *device, DWORD usage, enum wined3d_format_id format_id, WINED3DPOOL pool,
475         void *parent, const struct wined3d_parent_ops *parent_ops)
476 {
477     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
478     const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
479     UINT pow2_width, pow2_height;
480     UINT tmp_w, tmp_h;
481     unsigned int i;
482     HRESULT hr;
483
484     /* TODO: It should only be possible to create textures for formats
485      * that are reported as supported. */
486     if (WINED3DFMT_UNKNOWN >= format_id)
487     {
488         WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN.\n", texture);
489         return WINED3DERR_INVALIDCALL;
490     }
491
492     /* Non-power2 support. */
493     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
494     {
495         pow2_width = width;
496         pow2_height = height;
497     }
498     else
499     {
500         /* Find the nearest pow2 match. */
501         pow2_width = pow2_height = 1;
502         while (pow2_width < width) pow2_width <<= 1;
503         while (pow2_height < height) pow2_height <<= 1;
504
505         if (pow2_width != width || pow2_height != height)
506         {
507             if (levels > 1)
508             {
509                 WARN("Attempted to create a mipmapped np2 texture without unconditional np2 support.\n");
510                 return WINED3DERR_INVALIDCALL;
511             }
512             levels = 1;
513         }
514     }
515
516     /* Calculate levels for mip mapping. */
517     if (usage & WINED3DUSAGE_AUTOGENMIPMAP)
518     {
519         if (!gl_info->supported[SGIS_GENERATE_MIPMAP])
520         {
521             WARN("No mipmap generation support, returning WINED3DERR_INVALIDCALL.\n");
522             return WINED3DERR_INVALIDCALL;
523         }
524
525         if (levels > 1)
526         {
527             WARN("D3DUSAGE_AUTOGENMIPMAP is set, and level count > 1, returning WINED3DERR_INVALIDCALL.\n");
528             return WINED3DERR_INVALIDCALL;
529         }
530
531         levels = 1;
532     }
533     else if (!levels)
534     {
535         levels = wined3d_log2i(max(width, height)) + 1;
536         TRACE("Calculated levels = %u.\n", levels);
537     }
538
539     texture->lpVtbl = &IWineD3DTexture_Vtbl;
540
541     hr = basetexture_init((IWineD3DBaseTextureImpl *)texture, 1, levels,
542             WINED3DRTYPE_TEXTURE, device, 0, usage, format, pool, parent, parent_ops);
543     if (FAILED(hr))
544     {
545         WARN("Failed to initialize basetexture, returning %#x.\n", hr);
546         return hr;
547     }
548
549     /* Precalculated scaling for 'faked' non power of two texture coords.
550      * Second also don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
551      * is used in combination with texture uploads (RTL_READTEX). The reason is that EXT_PALETTED_TEXTURE
552      * doesn't work in combination with ARB_TEXTURE_RECTANGLE. */
553     if (gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] && (width != pow2_width || height != pow2_height))
554     {
555         texture->baseTexture.pow2Matrix[0] = 1.0f;
556         texture->baseTexture.pow2Matrix[5] = 1.0f;
557         texture->baseTexture.pow2Matrix[10] = 1.0f;
558         texture->baseTexture.pow2Matrix[15] = 1.0f;
559         texture->target = GL_TEXTURE_2D;
560         texture->cond_np2 = TRUE;
561         texture->baseTexture.minMipLookup = minMipLookup_noFilter;
562     }
563     else if (gl_info->supported[ARB_TEXTURE_RECTANGLE] && (width != pow2_width || height != pow2_height)
564             && !(format->id == WINED3DFMT_P8_UINT && gl_info->supported[EXT_PALETTED_TEXTURE]
565             && wined3d_settings.rendertargetlock_mode == RTL_READTEX))
566     {
567         if ((width != 1) || (height != 1)) texture->baseTexture.pow2Matrix_identity = FALSE;
568
569         texture->baseTexture.pow2Matrix[0] = (float)width;
570         texture->baseTexture.pow2Matrix[5] = (float)height;
571         texture->baseTexture.pow2Matrix[10] = 1.0f;
572         texture->baseTexture.pow2Matrix[15] = 1.0f;
573         texture->target = GL_TEXTURE_RECTANGLE_ARB;
574         texture->cond_np2 = TRUE;
575
576         if(texture->resource.format->Flags & WINED3DFMT_FLAG_FILTERING)
577         {
578             texture->baseTexture.minMipLookup = minMipLookup_noMip;
579         }
580         else
581         {
582             texture->baseTexture.minMipLookup = minMipLookup_noFilter;
583         }
584     }
585     else
586     {
587         if ((width != pow2_width) || (height != pow2_height))
588         {
589             texture->baseTexture.pow2Matrix_identity = FALSE;
590             texture->baseTexture.pow2Matrix[0] = (((float)width) / ((float)pow2_width));
591             texture->baseTexture.pow2Matrix[5] = (((float)height) / ((float)pow2_height));
592         }
593         else
594         {
595             texture->baseTexture.pow2Matrix[0] = 1.0f;
596             texture->baseTexture.pow2Matrix[5] = 1.0f;
597         }
598
599         texture->baseTexture.pow2Matrix[10] = 1.0f;
600         texture->baseTexture.pow2Matrix[15] = 1.0f;
601         texture->target = GL_TEXTURE_2D;
602         texture->cond_np2 = FALSE;
603     }
604     TRACE("xf(%f) yf(%f)\n", texture->baseTexture.pow2Matrix[0], texture->baseTexture.pow2Matrix[5]);
605
606     /* Generate all the surfaces. */
607     tmp_w = width;
608     tmp_h = height;
609     for (i = 0; i < texture->baseTexture.level_count; ++i)
610     {
611         IWineD3DSurface *surface;
612
613         /* Use the callback to create the texture surface. */
614         hr = IWineD3DDeviceParent_CreateSurface(device->device_parent, parent, tmp_w, tmp_h,
615                 format->id, usage, pool, i, 0, &surface);
616         if (FAILED(hr))
617         {
618             FIXME("Failed to create surface %p, hr %#x\n", texture, hr);
619             texture_cleanup(texture);
620             return hr;
621         }
622
623         surface_set_container((IWineD3DSurfaceImpl *)surface, WINED3D_CONTAINER_TEXTURE, (IWineD3DBase *)texture);
624         surface_set_texture_target((IWineD3DSurfaceImpl *)surface, texture->target);
625         texture->baseTexture.sub_resources[i] = (IWineD3DResourceImpl *)surface;
626         TRACE("Created surface level %u @ %p.\n", i, surface);
627         /* Calculate the next mipmap level. */
628         tmp_w = max(1, tmp_w >> 1);
629         tmp_h = max(1, tmp_h >> 1);
630     }
631     texture->baseTexture.internal_preload = texture_internal_preload;
632
633     return WINED3D_OK;
634 }