2 * IWineD3DBaseTexture Implementation
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2002-2004 Raphael Junqueira
6 * Copyright 2005 Oliver Stieber
7 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wined3d_private.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(d3d_texture
);
28 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
30 HRESULT
basetexture_init(IWineD3DBaseTextureImpl
*texture
, UINT levels
, WINED3DRESOURCETYPE resource_type
,
31 IWineD3DDeviceImpl
*device
, UINT size
, DWORD usage
, const struct GlPixelFormatDesc
*format_desc
,
32 WINED3DPOOL pool
, IUnknown
*parent
)
36 hr
= resource_init((IWineD3DResource
*)texture
, resource_type
, device
, size
, usage
, format_desc
, pool
, parent
);
39 WARN("Failed to initialize resource, returning %#x\n", hr
);
43 texture
->baseTexture
.levels
= levels
;
44 texture
->baseTexture
.filterType
= (usage
& WINED3DUSAGE_AUTOGENMIPMAP
) ? WINED3DTEXF_LINEAR
: WINED3DTEXF_NONE
;
45 texture
->baseTexture
.LOD
= 0;
46 texture
->baseTexture
.dirty
= TRUE
;
47 texture
->baseTexture
.srgbDirty
= TRUE
;
48 texture
->baseTexture
.is_srgb
= FALSE
;
49 texture
->baseTexture
.pow2Matrix_identity
= TRUE
;
54 void basetexture_cleanup(IWineD3DBaseTexture
*iface
)
56 basetexture_unload(iface
);
57 resource_cleanup((IWineD3DResource
*)iface
);
60 void basetexture_unload(IWineD3DBaseTexture
*iface
)
62 IWineD3DTextureImpl
*This
= (IWineD3DTextureImpl
*)iface
;
63 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
65 if(This
->baseTexture
.textureName
) {
66 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
68 glDeleteTextures(1, &This
->baseTexture
.textureName
);
69 This
->baseTexture
.textureName
= 0;
73 if(This
->baseTexture
.srgbTextureName
) {
74 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
76 glDeleteTextures(1, &This
->baseTexture
.srgbTextureName
);
77 This
->baseTexture
.srgbTextureName
= 0;
80 This
->baseTexture
.dirty
= TRUE
;
81 This
->baseTexture
.srgbDirty
= TRUE
;
84 /* There is no OpenGL equivalent of setLOD, getLOD. All they do anyway is prioritize texture loading
85 * so just pretend that they work unless something really needs a failure. */
86 DWORD
basetexture_set_lod(IWineD3DBaseTexture
*iface
, DWORD LODNew
)
88 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
90 if (This
->resource
.pool
!= WINED3DPOOL_MANAGED
) {
91 return WINED3DERR_INVALIDCALL
;
94 if(LODNew
>= This
->baseTexture
.levels
)
95 LODNew
= This
->baseTexture
.levels
- 1;
96 This
->baseTexture
.LOD
= LODNew
;
98 TRACE("(%p) : set bogus LOD to %d\n", This
, This
->baseTexture
.LOD
);
100 return This
->baseTexture
.LOD
;
103 DWORD
basetexture_get_lod(IWineD3DBaseTexture
*iface
)
105 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
107 if (This
->resource
.pool
!= WINED3DPOOL_MANAGED
) {
108 return WINED3DERR_INVALIDCALL
;
111 TRACE("(%p) : returning %d\n", This
, This
->baseTexture
.LOD
);
113 return This
->baseTexture
.LOD
;
116 DWORD
basetexture_get_level_count(IWineD3DBaseTexture
*iface
)
118 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
119 TRACE("(%p) : returning %d\n", This
, This
->baseTexture
.levels
);
120 return This
->baseTexture
.levels
;
123 HRESULT
basetexture_set_autogen_filter_type(IWineD3DBaseTexture
*iface
, WINED3DTEXTUREFILTERTYPE FilterType
)
125 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
126 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
127 UINT textureDimensions
= IWineD3DBaseTexture_GetTextureDimensions(iface
);
129 if (!(This
->resource
.usage
& WINED3DUSAGE_AUTOGENMIPMAP
)) {
130 TRACE("(%p) : returning invalid call\n", This
);
131 return WINED3DERR_INVALIDCALL
;
133 if(This
->baseTexture
.filterType
!= FilterType
) {
134 /* What about multithreading? Do we want all the context overhead just to set this value?
135 * Or should we delay the applying until the texture is used for drawing? For now, apply
138 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
140 glBindTexture(textureDimensions
, This
->baseTexture
.textureName
);
141 checkGLcall("glBindTexture");
143 case WINED3DTEXF_NONE
:
144 case WINED3DTEXF_POINT
:
145 glTexParameteri(textureDimensions
, GL_GENERATE_MIPMAP_HINT_SGIS
, GL_FASTEST
);
146 checkGLcall("glTexParameteri(textureDimensions, GL_GENERATE_MIPMAP_HINT_SGIS, GL_FASTEST)");
149 case WINED3DTEXF_LINEAR
:
150 glTexParameteri(textureDimensions
, GL_GENERATE_MIPMAP_HINT_SGIS
, GL_NICEST
);
151 checkGLcall("glTexParameteri(textureDimensions, GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST)");
155 WARN("Unexpected filter type %d, setting to GL_NICEST\n", FilterType
);
156 glTexParameteri(textureDimensions
, GL_GENERATE_MIPMAP_HINT_SGIS
, GL_NICEST
);
157 checkGLcall("glTexParameteri(textureDimensions, GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST)");
161 This
->baseTexture
.filterType
= FilterType
;
162 TRACE("(%p) :\n", This
);
166 WINED3DTEXTUREFILTERTYPE
basetexture_get_autogen_filter_type(IWineD3DBaseTexture
*iface
)
168 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
169 FIXME("(%p) : stub\n", This
);
170 if (!(This
->resource
.usage
& WINED3DUSAGE_AUTOGENMIPMAP
)) {
171 return WINED3DTEXF_NONE
;
173 return This
->baseTexture
.filterType
;
176 void basetexture_generate_mipmaps(IWineD3DBaseTexture
*iface
)
178 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
179 /* TODO: implement filters using GL_SGI_generate_mipmaps http://oss.sgi.com/projects/ogl-sample/registry/SGIS/generate_mipmap.txt */
180 FIXME("(%p) : stub\n", This
);
184 BOOL
basetexture_set_dirty(IWineD3DBaseTexture
*iface
, BOOL dirty
)
187 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
188 old
= This
->baseTexture
.dirty
|| This
->baseTexture
.srgbDirty
;
189 This
->baseTexture
.dirty
= dirty
;
190 This
->baseTexture
.srgbDirty
= dirty
;
194 BOOL
basetexture_get_dirty(IWineD3DBaseTexture
*iface
)
196 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
197 return This
->baseTexture
.dirty
|| This
->baseTexture
.srgbDirty
;
200 HRESULT
basetexture_bind(IWineD3DBaseTexture
*iface
, BOOL srgb
, BOOL
*set_surface_desc
)
202 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
203 HRESULT hr
= WINED3D_OK
;
204 UINT textureDimensions
;
205 BOOL isNewTexture
= FALSE
;
208 TRACE("(%p) : About to bind texture\n", This
);
210 This
->baseTexture
.is_srgb
= srgb
; /* SRGB mode cache for PreLoad calls outside drawprim */
212 texture
= &This
->baseTexture
.srgbTextureName
;
213 states
= This
->baseTexture
.srgbstates
;
215 texture
= &This
->baseTexture
.textureName
;
216 states
= This
->baseTexture
.states
;
219 textureDimensions
= IWineD3DBaseTexture_GetTextureDimensions(iface
);
221 /* Generate a texture name if we don't already have one */
223 *set_surface_desc
= TRUE
;
224 glGenTextures(1, texture
);
225 checkGLcall("glGenTextures");
226 TRACE("Generated texture %d\n", *texture
);
227 if (This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
228 /* Tell opengl to try and keep this texture in video ram (well mostly) */
231 glPrioritizeTextures(1, texture
, &tmp
);
234 /* Initialise the state of the texture object
235 to the openGL defaults, not the directx defaults */
236 states
[WINED3DTEXSTA_ADDRESSU
] = WINED3DTADDRESS_WRAP
;
237 states
[WINED3DTEXSTA_ADDRESSV
] = WINED3DTADDRESS_WRAP
;
238 states
[WINED3DTEXSTA_ADDRESSW
] = WINED3DTADDRESS_WRAP
;
239 states
[WINED3DTEXSTA_BORDERCOLOR
] = 0;
240 states
[WINED3DTEXSTA_MAGFILTER
] = WINED3DTEXF_LINEAR
;
241 states
[WINED3DTEXSTA_MINFILTER
] = WINED3DTEXF_POINT
; /* GL_NEAREST_MIPMAP_LINEAR */
242 states
[WINED3DTEXSTA_MIPFILTER
] = WINED3DTEXF_LINEAR
; /* GL_NEAREST_MIPMAP_LINEAR */
243 states
[WINED3DTEXSTA_MAXMIPLEVEL
] = 0;
244 states
[WINED3DTEXSTA_MAXANISOTROPY
] = 0;
245 states
[WINED3DTEXSTA_SRGBTEXTURE
] = 0;
246 states
[WINED3DTEXSTA_ELEMENTINDEX
] = 0;
247 states
[WINED3DTEXSTA_DMAPOFFSET
] = 0;
248 states
[WINED3DTEXSTA_TSSADDRESSW
] = WINED3DTADDRESS_WRAP
;
249 IWineD3DBaseTexture_SetDirty(iface
, TRUE
);
252 if(This
->resource
.usage
& WINED3DUSAGE_AUTOGENMIPMAP
) {
253 /* This means double binding the texture at creation, but keeps the code simpler all
254 * in all, and the run-time path free from additional checks
256 glBindTexture(textureDimensions
, *texture
);
257 checkGLcall("glBindTexture");
258 glTexParameteri(textureDimensions
, GL_GENERATE_MIPMAP_SGIS
, GL_TRUE
);
259 checkGLcall("glTexParameteri(textureDimensions, GL_GENERATE_MIPMAP_SGIS, GL_TRUE)");
262 *set_surface_desc
= FALSE
;
265 /* Bind the texture */
267 glBindTexture(textureDimensions
, *texture
);
268 checkGLcall("glBindTexture");
270 /* For a new texture we have to set the textures levels after binding the texture.
271 * In theory this is all we should ever have to do, but because ATI's drivers are broken, we
272 * also need to set the texture dimensions before the texture is set
273 * Beware that texture rectangles do not support mipmapping, but set the maxmiplevel if we're
274 * relying on the partial GL_ARB_texture_non_power_of_two emulation with texture rectangles
275 * (ie, do not care for cond_np2 here, just look for GL_TEXTURE_RECTANGLE_ARB)
277 if(textureDimensions
!= GL_TEXTURE_RECTANGLE_ARB
) {
278 TRACE("Setting GL_TEXTURE_MAX_LEVEL to %d\n", This
->baseTexture
.levels
- 1);
279 glTexParameteri(textureDimensions
, GL_TEXTURE_MAX_LEVEL
, This
->baseTexture
.levels
- 1);
280 checkGLcall("glTexParameteri(textureDimensions, GL_TEXTURE_MAX_LEVEL, This->baseTexture.levels)");
282 if(textureDimensions
==GL_TEXTURE_CUBE_MAP_ARB
) {
283 /* Cubemaps are always set to clamp, regardless of the sampler state. */
284 glTexParameteri(textureDimensions
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
285 glTexParameteri(textureDimensions
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
286 glTexParameteri(textureDimensions
, GL_TEXTURE_WRAP_R
, GL_CLAMP_TO_EDGE
);
289 } else { /* this only happened if we've run out of openGL textures */
290 WARN("This texture doesn't have an openGL texture assigned to it\n");
291 hr
= WINED3DERR_INVALIDCALL
;
298 /* GL locking is done by the caller */
299 static inline void apply_wrap(const GLint textureDimensions
, const DWORD state
, const GLint type
,
303 if (state
< minLookup
[WINELOOKUP_WARPPARAM
] || state
> maxLookup
[WINELOOKUP_WARPPARAM
]) {
304 FIXME("Unrecognized or unsupported WINED3DTADDRESS_U value %d\n", state
);
306 if(textureDimensions
==GL_TEXTURE_CUBE_MAP_ARB
) {
307 /* Cubemaps are always set to clamp, regardless of the sampler state. */
308 wrapParm
= GL_CLAMP_TO_EDGE
;
309 } else if(cond_np2
) {
310 if(state
== WINED3DTADDRESS_WRAP
) {
311 wrapParm
= GL_CLAMP_TO_EDGE
;
313 wrapParm
= stateLookup
[WINELOOKUP_WARPPARAM
][state
- minLookup
[WINELOOKUP_WARPPARAM
]];
316 wrapParm
= stateLookup
[WINELOOKUP_WARPPARAM
][state
- minLookup
[WINELOOKUP_WARPPARAM
]];
318 TRACE("Setting WRAP_S to %d for %x\n", wrapParm
, textureDimensions
);
319 glTexParameteri(textureDimensions
, type
, wrapParm
);
320 checkGLcall("glTexParameteri(..., type, wrapParm)");
324 /* GL locking is done by the caller (state handler) */
325 void basetexture_apply_state_changes(IWineD3DBaseTexture
*iface
,
326 const DWORD textureStates
[WINED3D_HIGHEST_TEXTURE_STATE
+ 1],
327 const DWORD samplerStates
[WINED3D_HIGHEST_SAMPLER_STATE
+ 1])
329 IWineD3DBaseTextureImpl
*This
= (IWineD3DBaseTextureImpl
*)iface
;
330 DWORD state
, *states
;
331 GLint textureDimensions
= IWineD3DBaseTexture_GetTextureDimensions(iface
);
332 BOOL cond_np2
= IWineD3DBaseTexture_IsCondNP2(iface
);
334 TRACE("iface %p, textureStates %p, samplerStates %p\n", iface
, textureStates
, samplerStates
);
336 if(This
->baseTexture
.is_srgb
) {
337 states
= This
->baseTexture
.srgbstates
;
339 states
= This
->baseTexture
.states
;
342 /* This function relies on the correct texture being bound and loaded. */
344 if(samplerStates
[WINED3DSAMP_ADDRESSU
] != states
[WINED3DTEXSTA_ADDRESSU
]) {
345 state
= samplerStates
[WINED3DSAMP_ADDRESSU
];
346 apply_wrap(textureDimensions
, state
, GL_TEXTURE_WRAP_S
, cond_np2
);
347 states
[WINED3DTEXSTA_ADDRESSU
] = state
;
350 if(samplerStates
[WINED3DSAMP_ADDRESSV
] != states
[WINED3DTEXSTA_ADDRESSV
]) {
351 state
= samplerStates
[WINED3DSAMP_ADDRESSV
];
352 apply_wrap(textureDimensions
, state
, GL_TEXTURE_WRAP_T
, cond_np2
);
353 states
[WINED3DTEXSTA_ADDRESSV
] = state
;
356 if(samplerStates
[WINED3DSAMP_ADDRESSW
] != states
[WINED3DTEXSTA_ADDRESSW
]) {
357 state
= samplerStates
[WINED3DSAMP_ADDRESSW
];
358 apply_wrap(textureDimensions
, state
, GL_TEXTURE_WRAP_R
, cond_np2
);
359 states
[WINED3DTEXSTA_ADDRESSW
] = state
;
362 if(samplerStates
[WINED3DSAMP_BORDERCOLOR
] != states
[WINED3DTEXSTA_BORDERCOLOR
]) {
365 state
= samplerStates
[WINED3DSAMP_BORDERCOLOR
];
366 D3DCOLORTOGLFLOAT4(state
, col
);
367 TRACE("Setting border color for %u to %x\n", textureDimensions
, state
);
368 glTexParameterfv(textureDimensions
, GL_TEXTURE_BORDER_COLOR
, &col
[0]);
369 checkGLcall("glTexParameteri(..., GL_TEXTURE_BORDER_COLOR, ...)");
370 states
[WINED3DTEXSTA_BORDERCOLOR
] = state
;
373 if(samplerStates
[WINED3DSAMP_MAGFILTER
] != states
[WINED3DTEXSTA_MAGFILTER
]) {
375 state
= samplerStates
[WINED3DSAMP_MAGFILTER
];
376 if (state
> WINED3DTEXF_ANISOTROPIC
) {
377 FIXME("Unrecognized or unsupported MAGFILTER* value %d\n", state
);
379 glValue
= This
->baseTexture
.magLookup
[state
- WINED3DTEXF_NONE
];
380 TRACE("ValueMAG=%d setting MAGFILTER to %x\n", state
, glValue
);
381 glTexParameteri(textureDimensions
, GL_TEXTURE_MAG_FILTER
, glValue
);
382 /* We need to reset the Anisotropic filtering state when we change the mag filter to WINED3DTEXF_ANISOTROPIC (this seems a bit weird, check the documentation to see how it should be switched off. */
383 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC
) && WINED3DTEXF_ANISOTROPIC
== state
&&
385 glTexParameteri(textureDimensions
, GL_TEXTURE_MAX_ANISOTROPY_EXT
, samplerStates
[WINED3DSAMP_MAXANISOTROPY
]);
387 states
[WINED3DTEXSTA_MAGFILTER
] = state
;
391 if((samplerStates
[WINED3DSAMP_MINFILTER
] != states
[WINED3DTEXSTA_MINFILTER
] ||
392 samplerStates
[WINED3DSAMP_MIPFILTER
] != states
[WINED3DTEXSTA_MIPFILTER
] ||
393 samplerStates
[WINED3DSAMP_MAXMIPLEVEL
] != states
[WINED3DTEXSTA_MAXMIPLEVEL
])) {
396 states
[WINED3DTEXSTA_MIPFILTER
] = samplerStates
[WINED3DSAMP_MIPFILTER
];
397 states
[WINED3DTEXSTA_MINFILTER
] = samplerStates
[WINED3DSAMP_MINFILTER
];
398 states
[WINED3DTEXSTA_MAXMIPLEVEL
] = samplerStates
[WINED3DSAMP_MAXMIPLEVEL
];
400 if (states
[WINED3DTEXSTA_MINFILTER
] > WINED3DTEXF_ANISOTROPIC
||
401 states
[WINED3DTEXSTA_MIPFILTER
] > WINED3DTEXF_LINEAR
)
404 FIXME("Unrecognized or unsupported D3DSAMP_MINFILTER value %d D3DSAMP_MIPFILTER value %d\n",
405 states
[WINED3DTEXSTA_MINFILTER
],
406 states
[WINED3DTEXSTA_MIPFILTER
]);
408 glValue
= This
->baseTexture
.minMipLookup
409 [min(max(samplerStates
[WINED3DSAMP_MINFILTER
],WINED3DTEXF_NONE
), WINED3DTEXF_ANISOTROPIC
)]
410 .mip
[min(max(samplerStates
[WINED3DSAMP_MIPFILTER
],WINED3DTEXF_NONE
), WINED3DTEXF_LINEAR
)];
412 TRACE("ValueMIN=%d, ValueMIP=%d, setting MINFILTER to %x\n",
413 samplerStates
[WINED3DSAMP_MINFILTER
],
414 samplerStates
[WINED3DSAMP_MIPFILTER
], glValue
);
415 glTexParameteri(textureDimensions
, GL_TEXTURE_MIN_FILTER
, glValue
);
416 checkGLcall("glTexParameter GL_TEXTURE_MIN_FILTER, ...");
419 if(states
[WINED3DTEXSTA_MIPFILTER
] == WINED3DTEXF_NONE
) {
421 } else if(states
[WINED3DTEXSTA_MAXMIPLEVEL
] >= This
->baseTexture
.levels
) {
422 glValue
= This
->baseTexture
.levels
- 1;
424 glValue
= states
[WINED3DTEXSTA_MAXMIPLEVEL
];
426 glTexParameteri(textureDimensions
, GL_TEXTURE_BASE_LEVEL
, glValue
);
430 if(samplerStates
[WINED3DSAMP_MAXANISOTROPY
] != states
[WINED3DTEXSTA_MAXANISOTROPY
]) {
431 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC
) && !cond_np2
) {
432 glTexParameteri(textureDimensions
, GL_TEXTURE_MAX_ANISOTROPY_EXT
, samplerStates
[WINED3DSAMP_MAXANISOTROPY
]);
433 checkGLcall("glTexParameteri GL_TEXTURE_MAX_ANISOTROPY_EXT ...");
435 WARN("Unsupported in local OpenGL implementation: glTexParameteri GL_TEXTURE_MAX_ANISOTROPY_EXT\n");
437 states
[WINED3DTEXSTA_MAXANISOTROPY
] = samplerStates
[WINED3DSAMP_MAXANISOTROPY
];