texture.c 14.9 KB
Newer Older
1
/*
2
 * IWineD3DTexture implementation
3 4
 *
 * Copyright 2002-2005 Jason Edmeades
5 6
 * Copyright 2002-2005 Raphael Junqueira
 * Copyright 2005 Oliver Stieber
7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 24 25
 */

#include "config.h"
#include "wined3d_private.h"

26
WINE_DEFAULT_DEBUG_CHANNEL(d3d_texture);
27
#define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
28 29 30 31

/* *******************************************
   IWineD3DTexture IUnknown parts follow
   ******************************************* */
32
static HRESULT WINAPI IWineD3DTextureImpl_QueryInterface(IWineD3DTexture *iface, REFIID riid, LPVOID *ppobj)
33 34
{
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
35 36
    TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
    if (IsEqualGUID(riid, &IID_IUnknown)
37
        || IsEqualGUID(riid, &IID_IWineD3DBase)
38 39 40 41 42
        || IsEqualGUID(riid, &IID_IWineD3DResource)
        || IsEqualGUID(riid, &IID_IWineD3DBaseTexture)
        || IsEqualGUID(riid, &IID_IWineD3DTexture)){
        IUnknown_AddRef(iface);
        *ppobj = This;
43
        return WINED3D_OK;
44
    }
45
    *ppobj = NULL;
46 47 48
    return E_NOINTERFACE;
}

49
static ULONG WINAPI IWineD3DTextureImpl_AddRef(IWineD3DTexture *iface) {
50
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
51
    TRACE("(%p) : AddRef increasing from %d\n", This, This->resource.ref);
52 53 54
    return InterlockedIncrement(&This->resource.ref);
}

55
static ULONG WINAPI IWineD3DTextureImpl_Release(IWineD3DTexture *iface) {
56 57
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
    ULONG ref;
58
    TRACE("(%p) : Releasing from %d\n", This, This->resource.ref);
59 60
    ref = InterlockedDecrement(&This->resource.ref);
    if (ref == 0) {
61
        IWineD3DTexture_Destroy(iface, D3DCB_DefaultDestroySurface);
62 63 64 65
    }
    return ref;
}

66

67 68 69
/* ****************************************************
   IWineD3DTexture IWineD3DResource parts follow
   **************************************************** */
70
static HRESULT WINAPI IWineD3DTextureImpl_GetDevice(IWineD3DTexture *iface, IWineD3DDevice** ppDevice) {
71 72 73
    return IWineD3DResourceImpl_GetDevice((IWineD3DResource *)iface, ppDevice);
}

74
static HRESULT WINAPI IWineD3DTextureImpl_SetPrivateData(IWineD3DTexture *iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) {
75 76 77
    return IWineD3DResourceImpl_SetPrivateData((IWineD3DResource *)iface, refguid, pData, SizeOfData, Flags);
}

78
static HRESULT WINAPI IWineD3DTextureImpl_GetPrivateData(IWineD3DTexture *iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) {
79 80 81
    return IWineD3DResourceImpl_GetPrivateData((IWineD3DResource *)iface, refguid, pData, pSizeOfData);
}

82
static HRESULT WINAPI IWineD3DTextureImpl_FreePrivateData(IWineD3DTexture *iface, REFGUID refguid) {
83 84 85
    return IWineD3DResourceImpl_FreePrivateData((IWineD3DResource *)iface, refguid);
}

86
static DWORD WINAPI IWineD3DTextureImpl_SetPriority(IWineD3DTexture *iface, DWORD PriorityNew) {
87 88 89
    return IWineD3DResourceImpl_SetPriority((IWineD3DResource *)iface, PriorityNew);
}

90
static DWORD WINAPI IWineD3DTextureImpl_GetPriority(IWineD3DTexture *iface) {
91 92 93
    return IWineD3DResourceImpl_GetPriority((IWineD3DResource *)iface);
}

94
static void WINAPI IWineD3DTextureImpl_PreLoad(IWineD3DTexture *iface) {
95 96

    /* Override the IWineD3DResource PreLoad method */
97 98
    unsigned int i;
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
99
    IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
100 101
    BOOL srgb_mode = This->baseTexture.is_srgb;
    BOOL srgb_was_toggled = FALSE;
102

103
    TRACE("(%p) : About to load texture\n", This);
104

105 106 107 108 109
    if(!device->isInDraw) {
        /* ActivateContext sets isInDraw to TRUE when loading a pbuffer into a texture, thus no danger of
         * recursive calls
         */
        ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
110 111 112 113
    } else if (GL_SUPPORT(EXT_TEXTURE_SRGB) && This->baseTexture.bindCount > 0) {
        srgb_mode = device->stateBlock->samplerState[This->baseTexture.sampler][WINED3DSAMP_SRGBTEXTURE];
        srgb_was_toggled = This->baseTexture.is_srgb != srgb_mode;
        This->baseTexture.is_srgb = srgb_mode;
114 115
    }

116 117
    IWineD3DTexture_BindTexture(iface);
    ENTER_GL();
118 119
    /* If the texture is marked dirty or the srgb sampler setting has changed since the last load then reload the surfaces */
    if (This->baseTexture.dirty) {
120
        for (i = 0; i < This->baseTexture.levels; i++) {
121
            IWineD3DSurface_LoadTexture(This->surfaces[i], srgb_mode);
122
        }
123 124 125 126 127
    } else if (srgb_was_toggled) {
        if (This->baseTexture.srgb_mode_change_count < 20)
            ++This->baseTexture.srgb_mode_change_count;
        else
            FIXME("Texture (%p) has been reloaded at least 20 times due to WINED3DSAMP_SRGBTEXTURE changes on it\'s sampler\n", This);
128

129
        for (i = 0; i < This->baseTexture.levels; i++) {
130
            IWineD3DSurface_AddDirtyRect(This->surfaces[i], NULL);
131 132 133
            IWineD3DSurface_SetGlTextureDesc(This->surfaces[i], This->baseTexture.textureName, IWineD3DTexture_GetTextureDimensions(iface));
            IWineD3DSurface_LoadTexture(This->surfaces[i], srgb_mode);
        }
134 135
    } else {
        TRACE("(%p) Texture not dirty, nothing to do\n" , iface);
136
    }
137 138
    LEAVE_GL();

139 140 141
    /* No longer dirty */
    This->baseTexture.dirty = FALSE;

142 143 144
    return ;
}

145
static void WINAPI IWineD3DTextureImpl_UnLoad(IWineD3DTexture *iface) {
146 147 148 149 150 151 152 153 154 155 156 157 158
    unsigned int i;
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
    TRACE("(%p)\n", This);

    /* Unload all the surfaces and reset the texture name. If UnLoad was called on the
     * surface before, this one will be a NOP and vice versa. Unloading an unloaded
     * surface is fine
     */
    for (i = 0; i < This->baseTexture.levels; i++) {
        IWineD3DSurface_UnLoad(This->surfaces[i]);
        IWineD3DSurface_SetGlTextureDesc(This->surfaces[i], 0, IWineD3DTexture_GetTextureDimensions(iface));
    }

159
    IWineD3DBaseTextureImpl_UnLoad((IWineD3DBaseTexture *) iface);
160 161
}

162
static WINED3DRESOURCETYPE WINAPI IWineD3DTextureImpl_GetType(IWineD3DTexture *iface) {
163 164 165
    return IWineD3DResourceImpl_GetType((IWineD3DResource *)iface);
}

166
static HRESULT WINAPI IWineD3DTextureImpl_GetParent(IWineD3DTexture *iface, IUnknown **pParent) {
167 168 169 170 171 172
    return IWineD3DResourceImpl_GetParent((IWineD3DResource *)iface, pParent);
}

/* ******************************************************
   IWineD3DTexture IWineD3DBaseTexture parts follow
   ****************************************************** */
173
static DWORD WINAPI IWineD3DTextureImpl_SetLOD(IWineD3DTexture *iface, DWORD LODNew) {
174 175 176
    return IWineD3DBaseTextureImpl_SetLOD((IWineD3DBaseTexture *)iface, LODNew);
}

177
static DWORD WINAPI IWineD3DTextureImpl_GetLOD(IWineD3DTexture *iface) {
178 179 180
    return IWineD3DBaseTextureImpl_GetLOD((IWineD3DBaseTexture *)iface);
}

181
static DWORD WINAPI IWineD3DTextureImpl_GetLevelCount(IWineD3DTexture *iface) {
182 183 184
    return IWineD3DBaseTextureImpl_GetLevelCount((IWineD3DBaseTexture *)iface);
}

185
static HRESULT WINAPI IWineD3DTextureImpl_SetAutoGenFilterType(IWineD3DTexture *iface, WINED3DTEXTUREFILTERTYPE FilterType) {
186 187 188
  return IWineD3DBaseTextureImpl_SetAutoGenFilterType((IWineD3DBaseTexture *)iface, FilterType);
}

189
static WINED3DTEXTUREFILTERTYPE WINAPI IWineD3DTextureImpl_GetAutoGenFilterType(IWineD3DTexture *iface) {
190 191 192
  return IWineD3DBaseTextureImpl_GetAutoGenFilterType((IWineD3DBaseTexture *)iface);
}

193
static void WINAPI IWineD3DTextureImpl_GenerateMipSubLevels(IWineD3DTexture *iface) {
194
    IWineD3DBaseTextureImpl_GenerateMipSubLevels((IWineD3DBaseTexture *)iface);
195 196 197
}

/* Internal function, No d3d mapping */
198
static BOOL WINAPI IWineD3DTextureImpl_SetDirty(IWineD3DTexture *iface, BOOL dirty) {
199
    return IWineD3DBaseTextureImpl_SetDirty((IWineD3DBaseTexture *)iface, dirty);
200 201
}

202
static BOOL WINAPI IWineD3DTextureImpl_GetDirty(IWineD3DTexture *iface) {
203 204 205
    return IWineD3DBaseTextureImpl_GetDirty((IWineD3DBaseTexture *)iface);
}

206
static HRESULT WINAPI IWineD3DTextureImpl_BindTexture(IWineD3DTexture *iface) {
207
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
208 209 210
    BOOL set_gl_texture_desc = This->baseTexture.textureName == 0;
    HRESULT hr;

211
    TRACE("(%p) : relay to BaseTexture\n", This);
212 213 214 215 216 217 218 219 220 221

    hr = IWineD3DBaseTextureImpl_BindTexture((IWineD3DBaseTexture *)iface);
    if (set_gl_texture_desc && SUCCEEDED(hr)) {
        UINT i;
        for (i = 0; i < This->baseTexture.levels; ++i) {
            IWineD3DSurface_SetGlTextureDesc(This->surfaces[i], This->baseTexture.textureName, IWineD3DTexture_GetTextureDimensions(iface));
        }
    }

    return hr;
222 223
}

224
static HRESULT WINAPI IWineD3DTextureImpl_UnBindTexture(IWineD3DTexture *iface) {
225
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
226
    TRACE("(%p) : relay to BaseTexture\n", This);
227
    return IWineD3DBaseTextureImpl_UnBindTexture((IWineD3DBaseTexture *)iface);
228 229
}

230
static UINT WINAPI IWineD3DTextureImpl_GetTextureDimensions(IWineD3DTexture *iface) {
231
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
232
    TRACE("(%p)\n", This);
233

234
    return This->target;
235 236
}

237
static void WINAPI IWineD3DTextureImpl_ApplyStateChanges(IWineD3DTexture *iface,
238 239
                                                   const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1],
                                                   const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1]) {
240
    TRACE("(%p) : relay to BaseTexture\n", iface);
241 242
    IWineD3DBaseTextureImpl_ApplyStateChanges((IWineD3DBaseTexture *)iface, textureStates, samplerStates);
}
243

244 245 246
/* *******************************************
   IWineD3DTexture IWineD3DTexture parts follow
   ******************************************* */
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
static void WINAPI IWineD3DTextureImpl_Destroy(IWineD3DTexture *iface, D3DCB_DESTROYSURFACEFN D3DCB_DestroySurface) {
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
    int i;

    TRACE("(%p) : Cleaning up\n",This);
    for (i = 0; i < This->baseTexture.levels; i++) {
        if (This->surfaces[i] != NULL) {
            /* Clean out the texture name we gave to the surface so that the surface doesn't try and release it */
            IWineD3DSurface_SetGlTextureDesc(This->surfaces[i], 0, 0);
            IWineD3DSurface_SetContainer(This->surfaces[i], 0);
            D3DCB_DestroySurface(This->surfaces[i]);
        }
    }
    TRACE("(%p) : cleaning up base texture\n", This);
    IWineD3DBaseTextureImpl_CleanUp((IWineD3DBaseTexture *)iface);
    /* free the object */
    HeapFree(GetProcessHeap(), 0, This);
}

266
static HRESULT WINAPI IWineD3DTextureImpl_GetLevelDesc(IWineD3DTexture *iface, UINT Level, WINED3DSURFACE_DESC* pDesc) {
267 268 269 270
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;

    if (Level < This->baseTexture.levels) {
        TRACE("(%p) Level (%d)\n", This, Level);
271
        return IWineD3DSurface_GetDesc(This->surfaces[Level], pDesc);
272 273
    }
    FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->baseTexture.levels);
274
    return WINED3DERR_INVALIDCALL;
275 276
}

277
static HRESULT WINAPI IWineD3DTextureImpl_GetSurfaceLevel(IWineD3DTexture *iface, UINT Level, IWineD3DSurface** ppSurfaceLevel) {
278
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
279
    HRESULT hr = WINED3DERR_INVALIDCALL;
280 281 282

    if (Level < This->baseTexture.levels) {
        *ppSurfaceLevel = This->surfaces[Level];
283
        IWineD3DSurface_AddRef(This->surfaces[Level]);
284
        hr = WINED3D_OK;
285 286
        TRACE("(%p) : returning %p for level %d\n", This, *ppSurfaceLevel, Level);
    }
287
    if (WINED3D_OK != hr) {
288 289 290 291
        WARN("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->baseTexture.levels);
        *ppSurfaceLevel = NULL; /* Just to be on the safe side.. */
    }
    return hr;
292 293
}

294
static HRESULT WINAPI IWineD3DTextureImpl_LockRect(IWineD3DTexture *iface, UINT Level, WINED3DLOCKED_RECT *pLockedRect,
295 296
                                            CONST RECT *pRect, DWORD Flags) {
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
297
    HRESULT hr = WINED3DERR_INVALIDCALL;
298 299

    if (Level < This->baseTexture.levels) {
300
        hr = IWineD3DSurface_LockRect(This->surfaces[Level], pLockedRect, pRect, Flags);
301
    }
302
    if (WINED3D_OK == hr) {
303
        TRACE("(%p) Level (%d) success\n", This, Level);
304
    } else {
305
        WARN("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->baseTexture.levels);
306
    }
307

308 309 310
    return hr;
}

311
static HRESULT WINAPI IWineD3DTextureImpl_UnlockRect(IWineD3DTexture *iface, UINT Level) {
312
   IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
313
    HRESULT hr = WINED3DERR_INVALIDCALL;
314 315

    if (Level < This->baseTexture.levels) {
316 317
        hr = IWineD3DSurface_UnlockRect(This->surfaces[Level]);
    }
318
    if ( WINED3D_OK == hr) {
319
        TRACE("(%p) Level (%d) success\n", This, Level);
320
    } else {
321
        WARN("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->baseTexture.levels);
322 323 324 325
    }
    return hr;
}

326
static HRESULT WINAPI IWineD3DTextureImpl_AddDirtyRect(IWineD3DTexture *iface, CONST RECT* pDirtyRect) {
327 328
    IWineD3DTextureImpl *This = (IWineD3DTextureImpl *)iface;
    This->baseTexture.dirty = TRUE;
329
    TRACE("(%p) : dirtyfication of surface Level (0)\n", This);
330
    return IWineD3DSurface_AddDirtyRect(This->surfaces[0], pDirtyRect);
331 332
}

333
const IWineD3DTextureVtbl IWineD3DTexture_Vtbl =
334
{
335
    /* IUnknown */
336 337 338
    IWineD3DTextureImpl_QueryInterface,
    IWineD3DTextureImpl_AddRef,
    IWineD3DTextureImpl_Release,
339
    /* IWineD3DResource */
340 341 342 343 344 345 346 347
    IWineD3DTextureImpl_GetParent,
    IWineD3DTextureImpl_GetDevice,
    IWineD3DTextureImpl_SetPrivateData,
    IWineD3DTextureImpl_GetPrivateData,
    IWineD3DTextureImpl_FreePrivateData,
    IWineD3DTextureImpl_SetPriority,
    IWineD3DTextureImpl_GetPriority,
    IWineD3DTextureImpl_PreLoad,
348
    IWineD3DTextureImpl_UnLoad,
349
    IWineD3DTextureImpl_GetType,
350
    /* IWineD3DBaseTexture */
351 352 353 354 355 356 357 358
    IWineD3DTextureImpl_SetLOD,
    IWineD3DTextureImpl_GetLOD,
    IWineD3DTextureImpl_GetLevelCount,
    IWineD3DTextureImpl_SetAutoGenFilterType,
    IWineD3DTextureImpl_GetAutoGenFilterType,
    IWineD3DTextureImpl_GenerateMipSubLevels,
    IWineD3DTextureImpl_SetDirty,
    IWineD3DTextureImpl_GetDirty,
359 360
    IWineD3DTextureImpl_BindTexture,
    IWineD3DTextureImpl_UnBindTexture,
361
    IWineD3DTextureImpl_GetTextureDimensions,
362
    IWineD3DTextureImpl_ApplyStateChanges,
363
    /* IWineD3DTexture */
364
    IWineD3DTextureImpl_Destroy,
365 366 367 368 369 370
    IWineD3DTextureImpl_GetLevelDesc,
    IWineD3DTextureImpl_GetSurfaceLevel,
    IWineD3DTextureImpl_LockRect,
    IWineD3DTextureImpl_UnlockRect,
    IWineD3DTextureImpl_AddDirtyRect
};