device.c 114 KB
Newer Older
1 2 3
/*
 * IDirect3DDevice8 implementation
 *
4 5
 * Copyright 2002-2004 Jason Edmeades
 * Copyright 2004 Christian Costa
6 7 8 9 10 11 12 13 14 15 16 17 18
 *
 * 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
19
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 21
 */

22 23
#include "config.h"

24
#include <math.h>
25
#include <stdarg.h>
26

27 28 29 30 31 32 33 34
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "wingdi.h"
#include "wine/debug.h"

#include "d3d8_private.h"

35
WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
36

37 38 39 40 41 42 43
static void STDMETHODCALLTYPE d3d8_null_wined3d_object_destroyed(void *parent) {}

static const struct wined3d_parent_ops d3d8_null_wined3d_parent_ops =
{
    d3d8_null_wined3d_object_destroyed,
};

44
D3DFORMAT d3dformat_from_wined3dformat(enum wined3d_format_id format)
45 46 47 48 49 50 51 52 53
{
    BYTE *c = (BYTE *)&format;

    /* Don't translate FOURCC formats */
    if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format;

    switch(format)
    {
        case WINED3DFMT_UNKNOWN: return D3DFMT_UNKNOWN;
54 55 56 57 58 59 60 61
        case WINED3DFMT_B8G8R8_UNORM: return D3DFMT_R8G8B8;
        case WINED3DFMT_B8G8R8A8_UNORM: return D3DFMT_A8R8G8B8;
        case WINED3DFMT_B8G8R8X8_UNORM: return D3DFMT_X8R8G8B8;
        case WINED3DFMT_B5G6R5_UNORM: return D3DFMT_R5G6B5;
        case WINED3DFMT_B5G5R5X1_UNORM: return D3DFMT_X1R5G5B5;
        case WINED3DFMT_B5G5R5A1_UNORM: return D3DFMT_A1R5G5B5;
        case WINED3DFMT_B4G4R4A4_UNORM: return D3DFMT_A4R4G4B4;
        case WINED3DFMT_B2G3R3_UNORM: return D3DFMT_R3G3B2;
62
        case WINED3DFMT_A8_UNORM: return D3DFMT_A8;
63 64
        case WINED3DFMT_B2G3R3A8_UNORM: return D3DFMT_A8R3G3B2;
        case WINED3DFMT_B4G4R4X4_UNORM: return D3DFMT_X4R4G4B4;
65 66
        case WINED3DFMT_R10G10B10A2_UNORM: return D3DFMT_A2B10G10R10;
        case WINED3DFMT_R16G16_UNORM: return D3DFMT_G16R16;
67 68 69 70 71
        case WINED3DFMT_P8_UINT_A8_UNORM: return D3DFMT_A8P8;
        case WINED3DFMT_P8_UINT: return D3DFMT_P8;
        case WINED3DFMT_L8_UNORM: return D3DFMT_L8;
        case WINED3DFMT_L8A8_UNORM: return D3DFMT_A8L8;
        case WINED3DFMT_L4A4_UNORM: return D3DFMT_A4L4;
72
        case WINED3DFMT_R8G8_SNORM: return D3DFMT_V8U8;
73 74
        case WINED3DFMT_R5G5_SNORM_L6_UNORM: return D3DFMT_L6V5U5;
        case WINED3DFMT_R8G8_SNORM_L8X8_UNORM: return D3DFMT_X8L8V8U8;
75 76
        case WINED3DFMT_R8G8B8A8_SNORM: return D3DFMT_Q8W8V8U8;
        case WINED3DFMT_R16G16_SNORM: return D3DFMT_V16U16;
77 78
        case WINED3DFMT_R10G11B11_SNORM: return D3DFMT_W11V11U10;
        case WINED3DFMT_R10G10B10_SNORM_A2_UNORM: return D3DFMT_A2W10V10U10;
79
        case WINED3DFMT_D16_LOCKABLE: return D3DFMT_D16_LOCKABLE;
80 81
        case WINED3DFMT_D32_UNORM: return D3DFMT_D32;
        case WINED3DFMT_S1_UINT_D15_UNORM: return D3DFMT_D15S1;
82
        case WINED3DFMT_D24_UNORM_S8_UINT: return D3DFMT_D24S8;
83 84
        case WINED3DFMT_X8D24_UNORM: return D3DFMT_D24X8;
        case WINED3DFMT_S4X4_UINT_D24_UNORM: return D3DFMT_D24X4S4;
85 86 87
        case WINED3DFMT_D16_UNORM: return D3DFMT_D16;
        case WINED3DFMT_R16_UINT: return D3DFMT_INDEX16;
        case WINED3DFMT_R32_UINT: return D3DFMT_INDEX32;
88
        default:
89
            FIXME("Unhandled wined3d format %#x.\n", format);
90 91 92 93
            return D3DFMT_UNKNOWN;
    }
}

94
enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format)
95 96 97 98 99 100 101 102 103
{
    BYTE *c = (BYTE *)&format;

    /* Don't translate FOURCC formats */
    if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format;

    switch(format)
    {
        case D3DFMT_UNKNOWN: return WINED3DFMT_UNKNOWN;
104 105 106 107 108 109 110 111
        case D3DFMT_R8G8B8: return WINED3DFMT_B8G8R8_UNORM;
        case D3DFMT_A8R8G8B8: return WINED3DFMT_B8G8R8A8_UNORM;
        case D3DFMT_X8R8G8B8: return WINED3DFMT_B8G8R8X8_UNORM;
        case D3DFMT_R5G6B5: return WINED3DFMT_B5G6R5_UNORM;
        case D3DFMT_X1R5G5B5: return WINED3DFMT_B5G5R5X1_UNORM;
        case D3DFMT_A1R5G5B5: return WINED3DFMT_B5G5R5A1_UNORM;
        case D3DFMT_A4R4G4B4: return WINED3DFMT_B4G4R4A4_UNORM;
        case D3DFMT_R3G3B2: return WINED3DFMT_B2G3R3_UNORM;
112
        case D3DFMT_A8: return WINED3DFMT_A8_UNORM;
113 114
        case D3DFMT_A8R3G3B2: return WINED3DFMT_B2G3R3A8_UNORM;
        case D3DFMT_X4R4G4B4: return WINED3DFMT_B4G4R4X4_UNORM;
115 116
        case D3DFMT_A2B10G10R10: return WINED3DFMT_R10G10B10A2_UNORM;
        case D3DFMT_G16R16: return WINED3DFMT_R16G16_UNORM;
117 118 119 120 121
        case D3DFMT_A8P8: return WINED3DFMT_P8_UINT_A8_UNORM;
        case D3DFMT_P8: return WINED3DFMT_P8_UINT;
        case D3DFMT_L8: return WINED3DFMT_L8_UNORM;
        case D3DFMT_A8L8: return WINED3DFMT_L8A8_UNORM;
        case D3DFMT_A4L4: return WINED3DFMT_L4A4_UNORM;
122
        case D3DFMT_V8U8: return WINED3DFMT_R8G8_SNORM;
123 124
        case D3DFMT_L6V5U5: return WINED3DFMT_R5G5_SNORM_L6_UNORM;
        case D3DFMT_X8L8V8U8: return WINED3DFMT_R8G8_SNORM_L8X8_UNORM;
125 126
        case D3DFMT_Q8W8V8U8: return WINED3DFMT_R8G8B8A8_SNORM;
        case D3DFMT_V16U16: return WINED3DFMT_R16G16_SNORM;
127 128
        case D3DFMT_W11V11U10: return WINED3DFMT_R10G11B11_SNORM;
        case D3DFMT_A2W10V10U10: return WINED3DFMT_R10G10B10_SNORM_A2_UNORM;
129
        case D3DFMT_D16_LOCKABLE: return WINED3DFMT_D16_LOCKABLE;
130 131
        case D3DFMT_D32: return WINED3DFMT_D32_UNORM;
        case D3DFMT_D15S1: return WINED3DFMT_S1_UINT_D15_UNORM;
132
        case D3DFMT_D24S8: return WINED3DFMT_D24_UNORM_S8_UINT;
133 134
        case D3DFMT_D24X8: return WINED3DFMT_X8D24_UNORM;
        case D3DFMT_D24X4S4: return WINED3DFMT_S4X4_UINT_D24_UNORM;
135 136 137
        case D3DFMT_D16: return WINED3DFMT_D16_UNORM;
        case D3DFMT_INDEX16: return WINED3DFMT_R16_UINT;
        case D3DFMT_INDEX32: return WINED3DFMT_R32_UINT;
138
        default:
139
            FIXME("Unhandled D3DFORMAT %#x.\n", format);
140 141 142 143
            return WINED3DFMT_UNKNOWN;
    }
}

144 145
static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, UINT primitive_count)
{
146
    switch (primitive_type)
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
    {
        case D3DPT_POINTLIST:
            return primitive_count;

        case D3DPT_LINELIST:
            return primitive_count * 2;

        case D3DPT_LINESTRIP:
            return primitive_count + 1;

        case D3DPT_TRIANGLELIST:
            return primitive_count * 3;

        case D3DPT_TRIANGLESTRIP:
        case D3DPT_TRIANGLEFAN:
            return primitive_count + 2;

        default:
165
            FIXME("Unhandled primitive type %#x.\n", primitive_type);
166 167 168 169
            return 0;
    }
}

170 171 172 173 174 175 176 177 178 179 180 181 182 183
static void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *present_parameters,
        const struct wined3d_swapchain_desc *swapchain_desc)
{
    present_parameters->BackBufferWidth = swapchain_desc->backbuffer_width;
    present_parameters->BackBufferHeight = swapchain_desc->backbuffer_height;
    present_parameters->BackBufferFormat = d3dformat_from_wined3dformat(swapchain_desc->backbuffer_format);
    present_parameters->BackBufferCount = swapchain_desc->backbuffer_count;
    present_parameters->MultiSampleType = swapchain_desc->multisample_type;
    present_parameters->SwapEffect = swapchain_desc->swap_effect;
    present_parameters->hDeviceWindow = swapchain_desc->device_window;
    present_parameters->Windowed = swapchain_desc->windowed;
    present_parameters->EnableAutoDepthStencil = swapchain_desc->enable_auto_depth_stencil;
    present_parameters->AutoDepthStencilFormat
            = d3dformat_from_wined3dformat(swapchain_desc->auto_depth_stencil_format);
184
    present_parameters->Flags = swapchain_desc->flags & D3DPRESENTFLAGS_MASK;
185 186 187 188
    present_parameters->FullScreen_RefreshRateInHz = swapchain_desc->refresh_rate;
    present_parameters->FullScreen_PresentationInterval = swapchain_desc->swap_interval;
}

189
static BOOL wined3d_swapchain_desc_from_present_parameters(struct wined3d_swapchain_desc *swapchain_desc,
190 191
        const D3DPRESENT_PARAMETERS *present_parameters)
{
192
    if (!present_parameters->SwapEffect || present_parameters->SwapEffect > D3DSWAPEFFECT_COPY_VSYNC)
193 194 195 196 197
    {
        WARN("Invalid swap effect %u passed.\n", present_parameters->SwapEffect);
        return FALSE;
    }
    if (present_parameters->BackBufferCount > 3
198 199
            || ((present_parameters->SwapEffect == D3DSWAPEFFECT_COPY
            || present_parameters->SwapEffect == D3DSWAPEFFECT_COPY_VSYNC)
200 201 202 203 204 205
            && present_parameters->BackBufferCount > 1))
    {
        WARN("Invalid backbuffer count %u.\n", present_parameters->BackBufferCount);
        return FALSE;
    }

206 207 208 209 210 211 212 213 214 215 216 217
    swapchain_desc->backbuffer_width = present_parameters->BackBufferWidth;
    swapchain_desc->backbuffer_height = present_parameters->BackBufferHeight;
    swapchain_desc->backbuffer_format = wined3dformat_from_d3dformat(present_parameters->BackBufferFormat);
    swapchain_desc->backbuffer_count = max(1, present_parameters->BackBufferCount);
    swapchain_desc->multisample_type = present_parameters->MultiSampleType;
    swapchain_desc->multisample_quality = 0; /* d3d9 only */
    swapchain_desc->swap_effect = present_parameters->SwapEffect;
    swapchain_desc->device_window = present_parameters->hDeviceWindow;
    swapchain_desc->windowed = present_parameters->Windowed;
    swapchain_desc->enable_auto_depth_stencil = present_parameters->EnableAutoDepthStencil;
    swapchain_desc->auto_depth_stencil_format
            = wined3dformat_from_d3dformat(present_parameters->AutoDepthStencilFormat);
218 219
    swapchain_desc->flags
            = (present_parameters->Flags & D3DPRESENTFLAGS_MASK) | WINED3D_SWAPCHAIN_ALLOW_MODE_SWITCH;
220 221 222
    swapchain_desc->refresh_rate = present_parameters->FullScreen_RefreshRateInHz;
    swapchain_desc->swap_interval = present_parameters->FullScreen_PresentationInterval;
    swapchain_desc->auto_restore_display_mode = TRUE;
223

224 225 226
    if (present_parameters->Flags & ~D3DPRESENTFLAGS_MASK)
        FIXME("Unhandled flags %#x.\n", present_parameters->Flags & ~D3DPRESENTFLAGS_MASK);

227
    return TRUE;
228 229
}

230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
void d3dcaps_from_wined3dcaps(D3DCAPS8 *caps, const WINED3DCAPS *wined3d_caps)
{
    caps->DeviceType                = (D3DDEVTYPE)wined3d_caps->DeviceType;
    caps->AdapterOrdinal            = wined3d_caps->AdapterOrdinal;
    caps->Caps                      = wined3d_caps->Caps;
    caps->Caps2                     = wined3d_caps->Caps2;
    caps->Caps3                     = wined3d_caps->Caps3;
    caps->PresentationIntervals     = wined3d_caps->PresentationIntervals;
    caps->CursorCaps                = wined3d_caps->CursorCaps;
    caps->DevCaps                   = wined3d_caps->DevCaps;
    caps->PrimitiveMiscCaps         = wined3d_caps->PrimitiveMiscCaps;
    caps->RasterCaps                = wined3d_caps->RasterCaps;
    caps->ZCmpCaps                  = wined3d_caps->ZCmpCaps;
    caps->SrcBlendCaps              = wined3d_caps->SrcBlendCaps;
    caps->DestBlendCaps             = wined3d_caps->DestBlendCaps;
    caps->AlphaCmpCaps              = wined3d_caps->AlphaCmpCaps;
    caps->ShadeCaps                 = wined3d_caps->ShadeCaps;
    caps->TextureCaps               = wined3d_caps->TextureCaps;
    caps->TextureFilterCaps         = wined3d_caps->TextureFilterCaps;
    caps->CubeTextureFilterCaps     = wined3d_caps->CubeTextureFilterCaps;
    caps->VolumeTextureFilterCaps   = wined3d_caps->VolumeTextureFilterCaps;
    caps->TextureAddressCaps        = wined3d_caps->TextureAddressCaps;
    caps->VolumeTextureAddressCaps  = wined3d_caps->VolumeTextureAddressCaps;
    caps->LineCaps                  = wined3d_caps->LineCaps;
    caps->MaxTextureWidth           = wined3d_caps->MaxTextureWidth;
    caps->MaxTextureHeight          = wined3d_caps->MaxTextureHeight;
    caps->MaxVolumeExtent           = wined3d_caps->MaxVolumeExtent;
    caps->MaxTextureRepeat          = wined3d_caps->MaxTextureRepeat;
    caps->MaxTextureAspectRatio     = wined3d_caps->MaxTextureAspectRatio;
    caps->MaxAnisotropy             = wined3d_caps->MaxAnisotropy;
    caps->MaxVertexW                = wined3d_caps->MaxVertexW;
    caps->GuardBandLeft             = wined3d_caps->GuardBandLeft;
    caps->GuardBandTop              = wined3d_caps->GuardBandTop;
    caps->GuardBandRight            = wined3d_caps->GuardBandRight;
    caps->GuardBandBottom           = wined3d_caps->GuardBandBottom;
    caps->ExtentsAdjust             = wined3d_caps->ExtentsAdjust;
    caps->StencilCaps               = wined3d_caps->StencilCaps;
    caps->FVFCaps                   = wined3d_caps->FVFCaps;
    caps->TextureOpCaps             = wined3d_caps->TextureOpCaps;
    caps->MaxTextureBlendStages     = wined3d_caps->MaxTextureBlendStages;
    caps->MaxSimultaneousTextures   = wined3d_caps->MaxSimultaneousTextures;
    caps->VertexProcessingCaps      = wined3d_caps->VertexProcessingCaps;
    caps->MaxActiveLights           = wined3d_caps->MaxActiveLights;
    caps->MaxUserClipPlanes         = wined3d_caps->MaxUserClipPlanes;
    caps->MaxVertexBlendMatrices    = wined3d_caps->MaxVertexBlendMatrices;
    caps->MaxVertexBlendMatrixIndex = wined3d_caps->MaxVertexBlendMatrixIndex;
    caps->MaxPointSize              = wined3d_caps->MaxPointSize;
    caps->MaxPrimitiveCount         = wined3d_caps->MaxPrimitiveCount;
    caps->MaxVertexIndex            = wined3d_caps->MaxVertexIndex;
    caps->MaxStreams                = wined3d_caps->MaxStreams;
    caps->MaxStreamStride           = wined3d_caps->MaxStreamStride;
    caps->VertexShaderVersion       = wined3d_caps->VertexShaderVersion;
    caps->MaxVertexShaderConst      = wined3d_caps->MaxVertexShaderConst;
    caps->PixelShaderVersion        = wined3d_caps->PixelShaderVersion;
    caps->MaxPixelShaderValue       = wined3d_caps->PixelShader1xMaxValue;
285 286 287 288 289 290 291 292 293 294 295 296 297

    /* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
    if (caps->PixelShaderVersion)
        caps->PixelShaderVersion = D3DPS_VERSION(1, 4);
    else
        caps->PixelShaderVersion = D3DPS_VERSION(0, 0);
    if (caps->VertexShaderVersion)
        caps->VertexShaderVersion = D3DVS_VERSION(1, 1);
    else
        caps->VertexShaderVersion = D3DVS_VERSION(0, 0);
    caps->MaxVertexShaderConst = min(D3D8_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst);

    caps->StencilCaps &= ~WINED3DSTENCILCAPS_TWOSIDED;
298 299
}

300
/* Handle table functions */
301
static DWORD d3d8_allocate_handle(struct d3d8_handle_table *t, void *object, enum d3d8_handle_type type)
302
{
303 304
    struct d3d8_handle_entry *entry;

305 306
    if (t->free_entries)
    {
307
        DWORD index = t->free_entries - t->entries;
308
        /* Use a free handle */
309 310 311
        entry = t->free_entries;
        if (entry->type != D3D8_HANDLE_FREE)
        {
312
            ERR("Handle %u(%p) is in the free list, but has type %#x.\n", index, entry, entry->type);
313 314 315 316 317 318
            return D3D8_INVALID_HANDLE;
        }
        t->free_entries = entry->object;
        entry->object = object;
        entry->type = type;

319
        return index;
320
    }
321 322 323

    if (!(t->entry_count < t->table_size))
    {
324
        /* Grow the table */
325
        UINT new_size = t->table_size + (t->table_size >> 1);
326 327 328 329 330 331 332
        struct d3d8_handle_entry *new_entries = HeapReAlloc(GetProcessHeap(),
                0, t->entries, new_size * sizeof(*t->entries));
        if (!new_entries)
        {
            ERR("Failed to grow the handle table.\n");
            return D3D8_INVALID_HANDLE;
        }
333 334
        t->entries = new_entries;
        t->table_size = new_size;
335 336
    }

337 338 339 340
    entry = &t->entries[t->entry_count];
    entry->object = object;
    entry->type = type;

341
    return t->entry_count++;
342 343
}

344
static void *d3d8_free_handle(struct d3d8_handle_table *t, DWORD handle, enum d3d8_handle_type type)
345
{
346 347
    struct d3d8_handle_entry *entry;
    void *object;
348

349 350 351 352 353
    if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %u passed.\n", handle);
        return NULL;
    }
354 355

    entry = &t->entries[handle];
356 357 358 359 360 361 362 363 364
    if (entry->type != type)
    {
        WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type);
        return NULL;
    }

    object = entry->object;
    entry->object = t->free_entries;
    entry->type = D3D8_HANDLE_FREE;
365 366 367 368 369
    t->free_entries = entry;

    return object;
}

370
static void *d3d8_get_object(struct d3d8_handle_table *t, DWORD handle, enum d3d8_handle_type type)
371
{
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
    struct d3d8_handle_entry *entry;

    if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %u passed.\n", handle);
        return NULL;
    }

    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type);
        return NULL;
    }

    return entry->object;
388 389
}

390
static HRESULT WINAPI d3d8_device_QueryInterface(IDirect3DDevice8 *iface, REFIID riid, void **out)
391
{
392 393
    TRACE("iface %p, riid %s, out %p.\n",
            iface, debugstr_guid(riid), out);
Henri Verbeet's avatar
Henri Verbeet committed
394

395 396 397
    if (IsEqualGUID(riid, &IID_IDirect3DDevice8)
            || IsEqualGUID(riid, &IID_IUnknown))
    {
398
        IDirect3DDevice8_AddRef(iface);
399
        *out = iface;
H. Verbeet's avatar
H. Verbeet committed
400
        return S_OK;
401 402
    }

403 404
    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));

405
    *out = NULL;
406 407 408
    return E_NOINTERFACE;
}

409
static ULONG WINAPI d3d8_device_AddRef(IDirect3DDevice8 *iface)
410
{
411 412
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
    ULONG ref = InterlockedIncrement(&device->ref);
413

Henri Verbeet's avatar
Henri Verbeet committed
414
    TRACE("%p increasing refcount to %u.\n", iface, ref);
415 416

    return ref;
417 418
}

419
static ULONG WINAPI d3d8_device_Release(IDirect3DDevice8 *iface)
420
{
421
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
422 423
    ULONG ref;

424 425 426 427
    if (device->inDestruction)
        return 0;

    ref = InterlockedDecrement(&device->ref);
428

Henri Verbeet's avatar
Henri Verbeet committed
429
    TRACE("%p decreasing refcount to %u.\n", iface, ref);
430

431 432 433
    if (!ref)
    {
        IDirect3D8 *parent = device->d3d_parent;
434
        unsigned i;
435

436
        TRACE("Releasing wined3d device %p.\n", device->wined3d_device);
437 438 439

        wined3d_mutex_lock();

440
        device->inDestruction = TRUE;
441

442
        for (i = 0; i < device->numConvertedDecls; ++i)
443
        {
444
            d3d8_vertex_declaration_destroy(device->decls[i].declaration);
445
        }
446
        HeapFree(GetProcessHeap(), 0, device->decls);
447

448 449
        if (device->vertex_buffer)
            wined3d_buffer_decref(device->vertex_buffer);
450 451
        if (device->index_buffer)
            wined3d_buffer_decref(device->index_buffer);
452

453 454 455 456 457
        wined3d_device_uninit_3d(device->wined3d_device);
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
        HeapFree(GetProcessHeap(), 0, device->handle_table.entries);
        HeapFree(GetProcessHeap(), 0, device);
458 459

        wined3d_mutex_unlock();
460 461

        IDirect3D8_Release(parent);
462 463 464 465
    }
    return ref;
}

466
static HRESULT WINAPI d3d8_device_TestCooperativeLevel(IDirect3DDevice8 *iface)
467
{
468
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
469

Henri Verbeet's avatar
Henri Verbeet committed
470
    TRACE("iface %p.\n", iface);
471

472 473 474
    TRACE("device state: %#x.\n", device->device_state);

    switch (device->device_state)
475
    {
476 477 478 479 480 481 482
        default:
        case D3D8_DEVICE_STATE_OK:
            return D3D_OK;
        case D3D8_DEVICE_STATE_LOST:
            return D3DERR_DEVICELOST;
        case D3D8_DEVICE_STATE_NOT_RESET:
            return D3DERR_DEVICENOTRESET;
483
    }
484 485
}

486
static UINT WINAPI d3d8_device_GetAvailableTextureMem(IDirect3DDevice8 *iface)
487
{
488
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
489
    UINT ret;
490

Henri Verbeet's avatar
Henri Verbeet committed
491
    TRACE("iface %p.\n", iface);
492 493

    wined3d_mutex_lock();
494
    ret = wined3d_device_get_available_texture_mem(device->wined3d_device);
495 496
    wined3d_mutex_unlock();

497
    return ret;
498 499
}

500
static HRESULT WINAPI d3d8_device_ResourceManagerDiscardBytes(IDirect3DDevice8 *iface, DWORD byte_count)
501
{
502
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
503

504 505 506 507
    TRACE("iface %p, byte_count %u.\n", iface, byte_count);

    if (byte_count)
        FIXME("Byte count ignored.\n");
508 509

    wined3d_mutex_lock();
510
    wined3d_device_evict_managed_resources(device->wined3d_device);
511 512
    wined3d_mutex_unlock();

513
    return D3D_OK;
514
}
515

516
static HRESULT WINAPI d3d8_device_GetDirect3D(IDirect3DDevice8 *iface, IDirect3D8 **d3d8)
517
{
518
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
519

520
    TRACE("iface %p, d3d8 %p.\n", iface, d3d8);
521

522
    if (!d3d8)
523
        return D3DERR_INVALIDCALL;
524

525
    return IDirect3D8_QueryInterface(device->d3d_parent, &IID_IDirect3D8, (void **)d3d8);
526
}
527

528
static HRESULT WINAPI d3d8_device_GetDeviceCaps(IDirect3DDevice8 *iface, D3DCAPS8 *caps)
529
{
530
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
531
    WINED3DCAPS wined3d_caps;
532
    HRESULT hr;
533

534
    TRACE("iface %p, caps %p.\n", iface, caps);
Henri Verbeet's avatar
Henri Verbeet committed
535

536
    if (!caps)
537
        return D3DERR_INVALIDCALL;
538

539
    wined3d_mutex_lock();
540
    hr = wined3d_device_get_device_caps(device->wined3d_device, &wined3d_caps);
541 542
    wined3d_mutex_unlock();

543
    d3dcaps_from_wined3dcaps(caps, &wined3d_caps);
544

545
    return hr;
546
}
547

548
static HRESULT WINAPI d3d8_device_GetDisplayMode(IDirect3DDevice8 *iface, D3DDISPLAYMODE *mode)
549
{
550
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
551
    struct wined3d_display_mode wined3d_mode;
552
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
553

554
    TRACE("iface %p, mode %p.\n", iface, mode);
555

556
    wined3d_mutex_lock();
557
    hr = wined3d_device_get_display_mode(device->wined3d_device, 0, &wined3d_mode, NULL);
558
    wined3d_mutex_unlock();
559

560
    if (SUCCEEDED(hr))
561 562 563 564 565 566
    {
        mode->Width = wined3d_mode.width;
        mode->Height = wined3d_mode.height;
        mode->RefreshRate = wined3d_mode.refresh_rate;
        mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id);
    }
567

568
    return hr;
569
}
570

571 572
static HRESULT WINAPI d3d8_device_GetCreationParameters(IDirect3DDevice8 *iface,
        D3DDEVICE_CREATION_PARAMETERS *parameters)
573
{
574
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
575

576
    TRACE("iface %p, parameters %p.\n", iface, parameters);
577

578
    wined3d_mutex_lock();
579
    wined3d_device_get_creation_parameters(device->wined3d_device,
580
            (struct wined3d_device_creation_parameters *)parameters);
581 582
    wined3d_mutex_unlock();

583
    return D3D_OK;
584
}
585

586 587
static HRESULT WINAPI d3d8_device_SetCursorProperties(IDirect3DDevice8 *iface,
        UINT hotspot_x, UINT hotspot_y, IDirect3DSurface8 *bitmap)
588
{
589
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
590
    struct d3d8_surface *bitmap_impl = unsafe_impl_from_IDirect3DSurface8(bitmap);
591
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
592 593

    TRACE("iface %p, hotspot_x %u, hotspot_y %u, bitmap %p.\n",
594
            iface, hotspot_x, hotspot_y, bitmap);
Henri Verbeet's avatar
Henri Verbeet committed
595

596
    if (!bitmap)
597 598 599
    {
        WARN("No cursor bitmap, returning D3DERR_INVALIDCALL.\n");
        return D3DERR_INVALIDCALL;
600
    }
601

602
    wined3d_mutex_lock();
603
    hr = wined3d_device_set_cursor_properties(device->wined3d_device,
604
            hotspot_x, hotspot_y, bitmap_impl->wined3d_texture, bitmap_impl->sub_resource_idx);
605 606
    wined3d_mutex_unlock();

607
    return hr;
608
}
609

610
static void WINAPI d3d8_device_SetCursorPosition(IDirect3DDevice8 *iface, UINT x, UINT y, DWORD flags)
611
{
612
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
613

614
    TRACE("iface %p, x %u, y %u, flags %#x.\n", iface, x, y, flags);
615

616
    wined3d_mutex_lock();
617
    wined3d_device_set_cursor_position(device->wined3d_device, x, y, flags);
618
    wined3d_mutex_unlock();
619
}
620

621
static BOOL WINAPI d3d8_device_ShowCursor(IDirect3DDevice8 *iface, BOOL show)
622
{
623
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
624
    BOOL ret;
Henri Verbeet's avatar
Henri Verbeet committed
625

626
    TRACE("iface %p, show %#x.\n", iface, show);
627

628
    wined3d_mutex_lock();
629
    ret = wined3d_device_show_cursor(device->wined3d_device, show);
630 631
    wined3d_mutex_unlock();

632
    return ret;
633
}
634

635
static HRESULT WINAPI d3d8_device_CreateAdditionalSwapChain(IDirect3DDevice8 *iface,
636 637
        D3DPRESENT_PARAMETERS *present_parameters, IDirect3DSwapChain8 **swapchain)
{
638
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
639
    struct wined3d_swapchain_desc desc;
640
    struct d3d8_swapchain *object;
641
    UINT i, count;
642
    HRESULT hr;
643

Henri Verbeet's avatar
Henri Verbeet committed
644
    TRACE("iface %p, present_parameters %p, swapchain %p.\n",
645
            iface, present_parameters, swapchain);
646

647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
    if (!present_parameters->Windowed)
    {
        WARN("Trying to create an additional fullscreen swapchain, returning D3DERR_INVALIDCALL.\n");
        return D3DERR_INVALIDCALL;
    }

    wined3d_mutex_lock();
    count = wined3d_device_get_swapchain_count(device->wined3d_device);
    for (i = 0; i < count; ++i)
    {
        struct wined3d_swapchain *wined3d_swapchain;

        wined3d_swapchain = wined3d_device_get_swapchain(device->wined3d_device, i);
        wined3d_swapchain_get_desc(wined3d_swapchain, &desc);

        if (!desc.windowed)
        {
            wined3d_mutex_unlock();
            WARN("Trying to create an additional swapchain in fullscreen mode, returning D3DERR_INVALIDCALL.\n");
            return D3DERR_INVALIDCALL;
        }
    }
    wined3d_mutex_unlock();

671 672
    if (!wined3d_swapchain_desc_from_present_parameters(&desc, present_parameters))
        return D3DERR_INVALIDCALL;
673
    if (SUCCEEDED(hr = d3d8_swapchain_create(device, &desc, &object)))
674
        *swapchain = &object->IDirect3DSwapChain8_iface;
675
    present_parameters_from_wined3d_swapchain_desc(present_parameters, &desc);
676

677
    return hr;
678
}
679

680
static HRESULT CDECL reset_enum_callback(struct wined3d_resource *resource)
681 682
{
    struct wined3d_resource_desc desc;
683 684 685
    IDirect3DBaseTexture8 *texture;
    struct d3d8_surface *surface;
    IUnknown *parent;
686 687

    wined3d_resource_get_desc(resource, &desc);
688 689
    if (desc.pool != WINED3D_POOL_DEFAULT)
        return D3D_OK;
690

691 692 693 694 695
    if (desc.resource_type != WINED3D_RTYPE_TEXTURE_2D)
    {
        WARN("Resource %p in pool D3DPOOL_DEFAULT blocks the Reset call.\n", resource);
        return D3DERR_DEVICELOST;
    }
696

697 698 699 700 701 702
    parent = wined3d_resource_get_parent(resource);
    if (parent && SUCCEEDED(IUnknown_QueryInterface(parent, &IID_IDirect3DBaseTexture8, (void **)&texture)))
    {
        IDirect3DBaseTexture8_Release(texture);
        WARN("Texture %p (resource %p) in pool D3DPOOL_DEFAULT blocks the Reset call.\n", texture, resource);
        return D3DERR_DEVICELOST;
703 704
    }

705 706 707 708 709 710
    surface = wined3d_texture_get_sub_resource_parent(wined3d_texture_from_resource(resource), 0);
    if (!surface->resource.refcount)
        return D3D_OK;

    WARN("Surface %p in pool D3DPOOL_DEFAULT blocks the Reset call.\n", surface);
    return D3DERR_DEVICELOST;
711 712
}

713 714
static HRESULT WINAPI d3d8_device_Reset(IDirect3DDevice8 *iface,
        D3DPRESENT_PARAMETERS *present_parameters)
715
{
716
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
717
    struct wined3d_swapchain_desc swapchain_desc;
718 719
    HRESULT hr;

720
    TRACE("iface %p, present_parameters %p.\n", iface, present_parameters);
721

722 723 724 725 726
    if (device->device_state == D3D8_DEVICE_STATE_LOST)
    {
        WARN("App not active, returning D3DERR_DEVICELOST.\n");
        return D3DERR_DEVICELOST;
    }
727 728
    if (!wined3d_swapchain_desc_from_present_parameters(&swapchain_desc, present_parameters))
        return D3DERR_INVALIDCALL;
729

730
    wined3d_mutex_lock();
731 732 733 734 735 736 737

    if (device->vertex_buffer)
    {
        wined3d_buffer_decref(device->vertex_buffer);
        device->vertex_buffer = NULL;
        device->vertex_buffer_size = 0;
    }
738 739 740 741 742 743
    if (device->index_buffer)
    {
        wined3d_buffer_decref(device->index_buffer);
        device->index_buffer = NULL;
        device->index_buffer_size = 0;
    }
744

745 746
    if (SUCCEEDED(hr = wined3d_device_reset(device->wined3d_device, &swapchain_desc,
            NULL, reset_enum_callback, TRUE)))
747
    {
748
        present_parameters->BackBufferCount = swapchain_desc.backbuffer_count;
749
        wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_POINTSIZE_MIN, 0);
750
        device->device_state = D3D8_DEVICE_STATE_OK;
751 752 753
    }
    else
    {
754
        device->device_state = D3D8_DEVICE_STATE_NOT_RESET;
755
    }
756
    wined3d_mutex_unlock();
757 758

    return hr;
759
}
760

761 762
static HRESULT WINAPI d3d8_device_Present(IDirect3DDevice8 *iface, const RECT *src_rect,
        const RECT *dst_rect, HWND dst_window_override, const RGNDATA *dirty_region)
763
{
764
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
765

766 767
    TRACE("iface %p, src_rect %s, dst_rect %s, dst_window_override %p, dirty_region %p.\n",
            iface, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect), dst_window_override, dirty_region);
768

769 770 771 772 773 774 775
    /* Fraps does not hook IDirect3DDevice8::Present regardless of the hotpatch
     * attribute. It only hooks IDirect3DSwapChain8::Present. Yet it properly
     * shows a framerate on Windows in applications that only call the device
     * method, like e.g. the dx8 sdk samples. The conclusion is that native
     * calls the swapchain's public method from the device. */
    return IDirect3DSwapChain8_Present(&device->implicit_swapchain->IDirect3DSwapChain8_iface,
            src_rect, dst_rect, dst_window_override, dirty_region);
776
}
777

778 779
static HRESULT WINAPI d3d8_device_GetBackBuffer(IDirect3DDevice8 *iface,
        UINT backbuffer_idx, D3DBACKBUFFER_TYPE backbuffer_type, IDirect3DSurface8 **backbuffer)
780
{
781
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
782
    struct wined3d_swapchain *wined3d_swapchain;
783
    struct wined3d_texture *wined3d_texture;
784
    struct d3d8_surface *surface_impl;
785

Henri Verbeet's avatar
Henri Verbeet committed
786
    TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n",
787
            iface, backbuffer_idx, backbuffer_type, backbuffer);
788

789 790
    /* backbuffer_type is ignored by native. */

791
    /* No need to check for backbuffer == NULL, Windows crashes in that case. */
792 793
    wined3d_mutex_lock();

794 795
    wined3d_swapchain = device->implicit_swapchain->wined3d_swapchain;
    if (!(wined3d_texture = wined3d_swapchain_get_back_buffer(wined3d_swapchain, backbuffer_idx)))
796 797 798 799 800 801
    {
        wined3d_mutex_unlock();
        *backbuffer = NULL;
        return D3DERR_INVALIDCALL;
    }

802
    surface_impl = wined3d_texture_get_sub_resource_parent(wined3d_texture, 0);
803 804 805 806 807
    *backbuffer = &surface_impl->IDirect3DSurface8_iface;
    IDirect3DSurface8_AddRef(*backbuffer);

    wined3d_mutex_unlock();
    return D3D_OK;
808
}
809

810
static HRESULT WINAPI d3d8_device_GetRasterStatus(IDirect3DDevice8 *iface, D3DRASTER_STATUS *raster_status)
811
{
812
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
813
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
814

815
    TRACE("iface %p, raster_status %p.\n", iface, raster_status);
816

817
    wined3d_mutex_lock();
818
    hr = wined3d_device_get_raster_status(device->wined3d_device, 0, (struct wined3d_raster_status *)raster_status);
819 820
    wined3d_mutex_unlock();

821
    return hr;
822
}
823

824
static void WINAPI d3d8_device_SetGammaRamp(IDirect3DDevice8 *iface, DWORD flags, const D3DGAMMARAMP *ramp)
825
{
826
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
827

828
    TRACE("iface %p, flags %#x, ramp %p.\n", iface, flags, ramp);
829

830
    /* Note: D3DGAMMARAMP is compatible with struct wined3d_gamma_ramp. */
831
    wined3d_mutex_lock();
832
    wined3d_device_set_gamma_ramp(device->wined3d_device, 0, flags, (const struct wined3d_gamma_ramp *)ramp);
833
    wined3d_mutex_unlock();
834
}
835

836
static void WINAPI d3d8_device_GetGammaRamp(IDirect3DDevice8 *iface, D3DGAMMARAMP *ramp)
837
{
838
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
839

840
    TRACE("iface %p, ramp %p.\n", iface, ramp);
841

842
    /* Note: D3DGAMMARAMP is compatible with struct wined3d_gamma_ramp. */
843
    wined3d_mutex_lock();
844
    wined3d_device_get_gamma_ramp(device->wined3d_device, 0, (struct wined3d_gamma_ramp *)ramp);
845
    wined3d_mutex_unlock();
846
}
847

848
static HRESULT WINAPI d3d8_device_CreateTexture(IDirect3DDevice8 *iface,
849 850 851
        UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format,
        D3DPOOL pool, IDirect3DTexture8 **texture)
{
852
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
853
    struct d3d8_texture *object;
854
    HRESULT hr;
855

856 857
    TRACE("iface %p, width %u, height %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
            iface, width, height, levels, usage, format, pool, texture);
858

859 860 861
    if (!format)
        return D3DERR_INVALIDCALL;

862
    *texture = NULL;
863 864
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
    if (!object)
865
        return D3DERR_OUTOFVIDEOMEMORY;
866

867
    hr = texture_init(object, device, width, height, levels, usage, format, pool);
868 869 870
    if (FAILED(hr))
    {
        WARN("Failed to initialize texture, hr %#x.\n", hr);
871
        HeapFree(GetProcessHeap(), 0, object);
872 873 874 875
        return hr;
    }

    TRACE("Created texture %p.\n", object);
876
    *texture = (IDirect3DTexture8 *)&object->IDirect3DBaseTexture8_iface;
877

878
    return D3D_OK;
879
}
880

881
static HRESULT WINAPI d3d8_device_CreateVolumeTexture(IDirect3DDevice8 *iface,
882 883
        UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format,
        D3DPOOL pool, IDirect3DVolumeTexture8 **texture)
884
{
885
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
886
    struct d3d8_texture *object;
887
    HRESULT hr;
888

889 890
    TRACE("iface %p, width %u, height %u, depth %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
            iface, width, height, depth, levels, usage, format, pool, texture);
891

892 893 894
    if (!format)
        return D3DERR_INVALIDCALL;

895
    *texture = NULL;
896 897
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
    if (!object)
898 899
        return D3DERR_OUTOFVIDEOMEMORY;

900
    hr = volumetexture_init(object, device, width, height, depth, levels, usage, format, pool);
901 902 903
    if (FAILED(hr))
    {
        WARN("Failed to initialize volume texture, hr %#x.\n", hr);
904
        HeapFree(GetProcessHeap(), 0, object);
905
        return hr;
906
    }
907 908

    TRACE("Created volume texture %p.\n", object);
909
    *texture = (IDirect3DVolumeTexture8 *)&object->IDirect3DBaseTexture8_iface;
910 911

    return D3D_OK;
912
}
913

914
static HRESULT WINAPI d3d8_device_CreateCubeTexture(IDirect3DDevice8 *iface, UINT edge_length,
915
        UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool, IDirect3DCubeTexture8 **texture)
916
{
917
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
918
    struct d3d8_texture *object;
919
    HRESULT hr;
920

921 922
    TRACE("iface %p, edge_length %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
            iface, edge_length, levels, usage, format, pool, texture);
923

924 925 926
    if (!format)
        return D3DERR_INVALIDCALL;

927
    *texture = NULL;
928
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
929
    if (!object)
930
        return D3DERR_OUTOFVIDEOMEMORY;
931

932
    hr = cubetexture_init(object, device, edge_length, levels, usage, format, pool);
933 934 935
    if (FAILED(hr))
    {
        WARN("Failed to initialize cube texture, hr %#x.\n", hr);
936
        HeapFree(GetProcessHeap(), 0, object);
937
        return hr;
938
    }
939

940
    TRACE("Created cube texture %p.\n", object);
941
    *texture = (IDirect3DCubeTexture8 *)&object->IDirect3DBaseTexture8_iface;
942

943
    return hr;
944 945
}

946
static HRESULT WINAPI d3d8_device_CreateVertexBuffer(IDirect3DDevice8 *iface, UINT size,
947
        DWORD usage, DWORD fvf, D3DPOOL pool, IDirect3DVertexBuffer8 **buffer)
948
{
949
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
950
    struct d3d8_vertexbuffer *object;
951
    HRESULT hr;
952

953 954 955 956 957
    TRACE("iface %p, size %u, usage %#x, fvf %#x, pool %#x, buffer %p.\n",
            iface, size, usage, fvf, pool, buffer);

    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
    if (!object)
958 959
        return D3DERR_OUTOFVIDEOMEMORY;

960
    hr = vertexbuffer_init(object, device, size, usage, fvf, pool);
961 962 963
    if (FAILED(hr))
    {
        WARN("Failed to initialize vertex buffer, hr %#x.\n", hr);
964
        HeapFree(GetProcessHeap(), 0, object);
965
        return hr;
966
    }
967 968

    TRACE("Created vertex buffer %p.\n", object);
969
    *buffer = &object->IDirect3DVertexBuffer8_iface;
970 971

    return D3D_OK;
972 973
}

974
static HRESULT WINAPI d3d8_device_CreateIndexBuffer(IDirect3DDevice8 *iface, UINT size,
975
        DWORD usage, D3DFORMAT format, D3DPOOL pool, IDirect3DIndexBuffer8 **buffer)
976
{
977
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
978
    struct d3d8_indexbuffer *object;
979 980 981 982
    HRESULT hr;

    TRACE("iface %p, size %u, usage %#x, format %#x, pool %#x, buffer %p.\n",
            iface, size, usage, format, pool, buffer);
983

984
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
985
    if (!object)
986 987
        return D3DERR_OUTOFVIDEOMEMORY;

988
    hr = indexbuffer_init(object, device, size, usage, format, pool);
989 990 991
    if (FAILED(hr))
    {
        WARN("Failed to initialize index buffer, hr %#x.\n", hr);
992
        HeapFree(GetProcessHeap(), 0, object);
993
        return hr;
994
    }
995 996

    TRACE("Created index buffer %p.\n", object);
997
    *buffer = &object->IDirect3DIndexBuffer8_iface;
998 999

    return D3D_OK;
1000
}
1001

1002
static HRESULT d3d8_device_create_surface(struct d3d8_device *device, UINT width, UINT height,
1003 1004
        D3DFORMAT format, DWORD flags, IDirect3DSurface8 **surface, UINT usage, D3DPOOL pool,
        D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality)
1005
{
1006 1007 1008
    struct wined3d_resource_desc desc;
    struct d3d8_surface *surface_impl;
    struct wined3d_texture *texture;
1009
    HRESULT hr;
1010

1011 1012
    TRACE("device %p, width %u, height %u, format %#x, flags %#x, surface %p, "
            "usage %#x, pool %#x, multisample_type %#x, multisample_quality %u.\n",
1013
            device, width, height, format, flags, surface,
1014
            usage, pool, multisample_type, multisample_quality);
1015

1016
    desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
1017 1018 1019 1020 1021 1022 1023 1024 1025
    desc.format = wined3dformat_from_d3dformat(format);
    desc.multisample_type = multisample_type;
    desc.multisample_quality = multisample_quality;
    desc.usage = usage & WINED3DUSAGE_MASK;
    desc.pool = pool;
    desc.width = width;
    desc.height = height;
    desc.depth = 1;
    desc.size = 0;
1026

1027 1028
    wined3d_mutex_lock();

1029
    if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &desc,
1030
            1, 1, flags, NULL, NULL, &d3d8_null_wined3d_parent_ops, &texture)))
1031
    {
1032 1033
        wined3d_mutex_unlock();
        WARN("Failed to create texture, hr %#x.\n", hr);
1034
        return hr;
1035
    }
1036

1037
    surface_impl = wined3d_texture_get_sub_resource_parent(texture, 0);
1038 1039 1040 1041 1042 1043
    surface_impl->parent_device = &device->IDirect3DDevice8_iface;
    *surface = &surface_impl->IDirect3DSurface8_iface;
    IDirect3DSurface8_AddRef(*surface);
    wined3d_texture_decref(texture);

    wined3d_mutex_unlock();
1044 1045

    return D3D_OK;
1046 1047
}

1048 1049 1050
static HRESULT WINAPI d3d8_device_CreateRenderTarget(IDirect3DDevice8 *iface, UINT width,
        UINT height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, BOOL lockable,
        IDirect3DSurface8 **surface)
1051
{
1052
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1053
    DWORD flags = 0;
Henri Verbeet's avatar
Henri Verbeet committed
1054 1055

    TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, lockable %#x, surface %p.\n",
1056
            iface, width, height, format, multisample_type, lockable, surface);
1057

1058 1059 1060
    if (!format)
        return D3DERR_INVALIDCALL;

1061
    *surface = NULL;
1062
    if (lockable)
1063
        flags |= WINED3D_TEXTURE_CREATE_MAPPABLE;
1064 1065 1066

    return d3d8_device_create_surface(device, width, height, format, flags, surface,
            D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, multisample_type, 0);
1067
}
1068

1069 1070 1071
static HRESULT WINAPI d3d8_device_CreateDepthStencilSurface(IDirect3DDevice8 *iface,
        UINT width, UINT height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type,
        IDirect3DSurface8 **surface)
1072
{
1073
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1074 1075

    TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, surface %p.\n",
1076
            iface, width, height, format, multisample_type, surface);
1077

1078 1079 1080
    if (!format)
        return D3DERR_INVALIDCALL;

1081 1082
    *surface = NULL;

1083
    /* TODO: Verify that Discard is false */
1084
    return d3d8_device_create_surface(device, width, height, format, WINED3D_TEXTURE_CREATE_MAPPABLE,
1085
            surface, D3DUSAGE_DEPTHSTENCIL, D3DPOOL_DEFAULT, multisample_type, 0);
1086
}
1087

1088
/*  IDirect3DDevice8Impl::CreateImageSurface returns surface with pool type SYSTEMMEM */
1089 1090
static HRESULT WINAPI d3d8_device_CreateImageSurface(IDirect3DDevice8 *iface, UINT width,
        UINT height, D3DFORMAT format, IDirect3DSurface8 **surface)
1091
{
1092
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1093 1094

    TRACE("iface %p, width %u, height %u, format %#x, surface %p.\n",
1095
            iface, width, height, format, surface);
1096

1097 1098
    *surface = NULL;

1099
    return d3d8_device_create_surface(device, width, height, format, WINED3D_TEXTURE_CREATE_MAPPABLE,
1100
            surface, 0, D3DPOOL_SYSTEMMEM, D3DMULTISAMPLE_NONE, 0);
1101
}
1102

1103 1104 1105
static HRESULT WINAPI d3d8_device_CopyRects(IDirect3DDevice8 *iface,
        IDirect3DSurface8 *src_surface, const RECT *src_rects, UINT rect_count,
        IDirect3DSurface8 *dst_surface, const POINT *dst_points)
1106
{
1107 1108
    struct d3d8_surface *src = unsafe_impl_from_IDirect3DSurface8(src_surface);
    struct d3d8_surface *dst = unsafe_impl_from_IDirect3DSurface8(dst_surface);
1109
    enum wined3d_format_id src_format, dst_format;
1110
    struct wined3d_sub_resource_desc wined3d_desc;
1111
    UINT src_w, src_h;
1112

Henri Verbeet's avatar
Henri Verbeet committed
1113
    TRACE("iface %p, src_surface %p, src_rects %p, rect_count %u, dst_surface %p, dst_points %p.\n",
1114
            iface, src_surface, src_rects, rect_count, dst_surface, dst_points);
1115

1116 1117
    /* Check that the source texture is in WINED3D_POOL_SYSTEM_MEM and the
     * destination texture is in WINED3D_POOL_DEFAULT. */
1118

1119
    wined3d_mutex_lock();
1120
    wined3d_texture_get_sub_resource_desc(src->wined3d_texture, src->sub_resource_idx, &wined3d_desc);
1121 1122
    if (wined3d_desc.usage & WINED3DUSAGE_DEPTHSTENCIL)
    {
1123
        WARN("Source %p is a depth stencil surface, returning D3DERR_INVALIDCALL.\n", src_surface);
1124 1125 1126
        wined3d_mutex_unlock();
        return D3DERR_INVALIDCALL;
    }
1127
    src_format = wined3d_desc.format;
1128 1129
    src_w = wined3d_desc.width;
    src_h = wined3d_desc.height;
1130

1131
    wined3d_texture_get_sub_resource_desc(dst->wined3d_texture, dst->sub_resource_idx, &wined3d_desc);
1132 1133
    if (wined3d_desc.usage & WINED3DUSAGE_DEPTHSTENCIL)
    {
1134
        WARN("Destination %p is a depth stencil surface, returning D3DERR_INVALIDCALL.\n", dst_surface);
1135 1136 1137
        wined3d_mutex_unlock();
        return D3DERR_INVALIDCALL;
    }
1138
    dst_format = wined3d_desc.format;
1139 1140

    /* Check that the source and destination formats match */
1141
    if (src_format != dst_format)
1142
    {
1143 1144
        WARN("Source %p format must match the destination %p format, returning D3DERR_INVALIDCALL.\n",
                src_surface, dst_surface);
1145
        wined3d_mutex_unlock();
1146 1147
        return D3DERR_INVALIDCALL;
    }
1148

1149
    /* Quick if complete copy ... */
1150
    if (!rect_count && !src_rects && !dst_points)
1151
    {
1152
        RECT rect = {0, 0, src_w, src_h};
1153 1154
        wined3d_texture_blt(dst->wined3d_texture, dst->sub_resource_idx, &rect,
                src->wined3d_texture, src->sub_resource_idx, &rect, 0, NULL, WINED3D_TEXF_POINT);
1155 1156 1157
    }
    else
    {
1158 1159
        unsigned int i;
        /* Copy rect by rect */
1160
        if (src_rects && dst_points)
1161
        {
1162
            for (i = 0; i < rect_count; ++i)
1163
            {
1164 1165 1166 1167
                UINT w = src_rects[i].right - src_rects[i].left;
                UINT h = src_rects[i].bottom - src_rects[i].top;
                RECT dst_rect = {dst_points[i].x, dst_points[i].y,
                        dst_points[i].x + w, dst_points[i].y + h};
1168

1169 1170
                wined3d_texture_blt(dst->wined3d_texture, dst->sub_resource_idx, &dst_rect,
                        src->wined3d_texture, src->sub_resource_idx, &src_rects[i], 0, NULL, WINED3D_TEXF_POINT);
1171
            }
1172 1173 1174
        }
        else
        {
1175
            for (i = 0; i < rect_count; ++i)
1176
            {
1177 1178
                UINT w = src_rects[i].right - src_rects[i].left;
                UINT h = src_rects[i].bottom - src_rects[i].top;
1179 1180
                RECT dst_rect = {0, 0, w, h};

1181 1182
                wined3d_texture_blt(dst->wined3d_texture, dst->sub_resource_idx, &dst_rect,
                        src->wined3d_texture, src->sub_resource_idx, &src_rects[i], 0, NULL, WINED3D_TEXF_POINT);
1183 1184 1185
            }
        }
    }
1186
    wined3d_mutex_unlock();
1187

1188
    return WINED3D_OK;
1189
}
1190

1191
static HRESULT WINAPI d3d8_device_UpdateTexture(IDirect3DDevice8 *iface,
1192
        IDirect3DBaseTexture8 *src_texture, IDirect3DBaseTexture8 *dst_texture)
1193
{
1194
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1195
    struct d3d8_texture *src_impl, *dst_impl;
1196
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1197

1198
    TRACE("iface %p, src_texture %p, dst_texture %p.\n", iface, src_texture, dst_texture);
1199

1200 1201 1202
    src_impl = unsafe_impl_from_IDirect3DBaseTexture8(src_texture);
    dst_impl = unsafe_impl_from_IDirect3DBaseTexture8(dst_texture);

1203
    wined3d_mutex_lock();
1204
    hr = wined3d_device_update_texture(device->wined3d_device,
1205
            src_impl->wined3d_texture, dst_impl->wined3d_texture);
1206 1207
    wined3d_mutex_unlock();

1208
    return hr;
1209
}
1210

1211
static HRESULT WINAPI d3d8_device_GetFrontBuffer(IDirect3DDevice8 *iface, IDirect3DSurface8 *dst_surface)
1212
{
1213
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1214
    struct d3d8_surface *dst_impl = unsafe_impl_from_IDirect3DSurface8(dst_surface);
1215
    HRESULT hr;
1216

1217
    TRACE("iface %p, dst_surface %p.\n", iface, dst_surface);
1218

1219 1220 1221
    if (!dst_surface)
    {
        WARN("Invalid destination surface passed.\n");
1222
        return D3DERR_INVALIDCALL;
1223
    }
1224

1225
    wined3d_mutex_lock();
1226 1227
    hr = wined3d_swapchain_get_front_buffer_data(device->implicit_swapchain->wined3d_swapchain,
            dst_impl->wined3d_texture, dst_impl->sub_resource_idx);
1228 1229
    wined3d_mutex_unlock();

1230
    return hr;
1231
}
1232

1233 1234
static HRESULT WINAPI d3d8_device_SetRenderTarget(IDirect3DDevice8 *iface,
        IDirect3DSurface8 *render_target, IDirect3DSurface8 *depth_stencil)
1235
{
1236
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1237 1238
    struct d3d8_surface *rt_impl = unsafe_impl_from_IDirect3DSurface8(render_target);
    struct d3d8_surface *ds_impl = unsafe_impl_from_IDirect3DSurface8(depth_stencil);
1239
    struct wined3d_rendertarget_view *original_dsv, *rtv;
1240
    HRESULT hr = D3D_OK;
Henri Verbeet's avatar
Henri Verbeet committed
1241

1242
    TRACE("iface %p, render_target %p, depth_stencil %p.\n", iface, render_target, depth_stencil);
1243

1244 1245 1246 1247 1248 1249
    if (rt_impl && d3d8_surface_get_device(rt_impl) != device)
    {
        WARN("Render target surface does not match device.\n");
        return D3DERR_INVALIDCALL;
    }

1250
    wined3d_mutex_lock();
1251

1252
    if (ds_impl)
1253
    {
1254
        struct wined3d_sub_resource_desc ds_desc, rt_desc;
1255 1256
        struct wined3d_rendertarget_view *original_rtv;
        struct d3d8_surface *original_surface;
1257 1258

        /* If no render target is passed in check the size against the current RT */
1259
        if (!render_target)
1260
        {
1261
            if (!(original_rtv = wined3d_device_get_rendertarget_view(device->wined3d_device, 0)))
1262 1263
            {
                wined3d_mutex_unlock();
1264
                return D3DERR_NOTFOUND;
1265
            }
1266
            original_surface = wined3d_rendertarget_view_get_sub_resource_parent(original_rtv);
1267 1268
            wined3d_texture_get_sub_resource_desc(original_surface->wined3d_texture,
                    original_surface->sub_resource_idx, &rt_desc);
1269
        }
1270
        else
1271 1272
            wined3d_texture_get_sub_resource_desc(rt_impl->wined3d_texture,
                    rt_impl->sub_resource_idx, &rt_desc);
1273

1274
        wined3d_texture_get_sub_resource_desc(ds_impl->wined3d_texture, ds_impl->sub_resource_idx, &ds_desc);
1275 1276 1277 1278 1279 1280 1281

        if (ds_desc.width < rt_desc.width || ds_desc.height < rt_desc.height)
        {
            WARN("Depth stencil is smaller than the render target, returning D3DERR_INVALIDCALL\n");
            wined3d_mutex_unlock();
            return D3DERR_INVALIDCALL;
        }
1282 1283 1284
        if (ds_desc.multisample_type != rt_desc.multisample_type
                || ds_desc.multisample_quality != rt_desc.multisample_quality)
        {
1285
            WARN("Multisample settings do not match, returning D3DERR_INVALIDCALL\n");
1286 1287 1288
            wined3d_mutex_unlock();
            return D3DERR_INVALIDCALL;
        }
1289 1290
    }

1291
    original_dsv = wined3d_device_get_depth_stencil_view(device->wined3d_device);
1292 1293 1294 1295 1296
    rtv = ds_impl ? d3d8_surface_acquire_rendertarget_view(ds_impl) : NULL;
    wined3d_device_set_depth_stencil_view(device->wined3d_device, rtv);
    d3d8_surface_release_rendertarget_view(ds_impl, rtv);
    rtv = render_target ? d3d8_surface_acquire_rendertarget_view(rt_impl) : NULL;
    if (render_target && FAILED(hr = wined3d_device_set_rendertarget_view(device->wined3d_device, 0, rtv, TRUE)))
1297
        wined3d_device_set_depth_stencil_view(device->wined3d_device, original_dsv);
1298
    d3d8_surface_release_rendertarget_view(rt_impl, rtv);
1299

1300 1301
    wined3d_mutex_unlock();

1302
    return hr;
1303
}
1304

1305
static HRESULT WINAPI d3d8_device_GetRenderTarget(IDirect3DDevice8 *iface, IDirect3DSurface8 **render_target)
1306
{
1307
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1308
    struct wined3d_rendertarget_view *wined3d_rtv;
1309
    struct d3d8_surface *surface_impl;
1310
    HRESULT hr;
1311

1312
    TRACE("iface %p, render_target %p.\n", iface, render_target);
1313

1314
    if (!render_target)
1315
        return D3DERR_INVALIDCALL;
1316 1317

    wined3d_mutex_lock();
1318
    if ((wined3d_rtv = wined3d_device_get_rendertarget_view(device->wined3d_device, 0)))
1319
    {
1320 1321 1322
        /* We want the sub resource parent here, since the view itself may be
         * internal to wined3d and may not have a parent. */
        surface_impl = wined3d_rendertarget_view_get_sub_resource_parent(wined3d_rtv);
1323 1324
        *render_target = &surface_impl->IDirect3DSurface8_iface;
        IDirect3DSurface8_AddRef(*render_target);
1325
        hr = D3D_OK;
1326 1327 1328
    }
    else
    {
1329
        ERR("Failed to get wined3d render target.\n");
1330
        *render_target = NULL;
1331
        hr = D3DERR_NOTFOUND;
1332
    }
1333
    wined3d_mutex_unlock();
1334 1335

    return hr;
1336
}
1337

1338
static HRESULT WINAPI d3d8_device_GetDepthStencilSurface(IDirect3DDevice8 *iface, IDirect3DSurface8 **depth_stencil)
1339
{
1340
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1341
    struct wined3d_rendertarget_view *wined3d_dsv;
1342
    struct d3d8_surface *surface_impl;
1343
    HRESULT hr = D3D_OK;
1344

1345
    TRACE("iface %p, depth_stencil %p.\n", iface, depth_stencil);
Henri Verbeet's avatar
Henri Verbeet committed
1346

1347
    if (!depth_stencil)
1348
        return D3DERR_INVALIDCALL;
1349

1350
    wined3d_mutex_lock();
1351
    if ((wined3d_dsv = wined3d_device_get_depth_stencil_view(device->wined3d_device)))
1352
    {
1353 1354 1355
        /* We want the sub resource parent here, since the view itself may be
         * internal to wined3d and may not have a parent. */
        surface_impl = wined3d_rendertarget_view_get_sub_resource_parent(wined3d_dsv);
1356 1357
        *depth_stencil = &surface_impl->IDirect3DSurface8_iface;
        IDirect3DSurface8_AddRef(*depth_stencil);
1358 1359 1360
    }
    else
    {
1361
        hr = D3DERR_NOTFOUND;
1362
        *depth_stencil = NULL;
1363
    }
1364
    wined3d_mutex_unlock();
1365

1366
    return hr;
1367 1368
}

1369
static HRESULT WINAPI d3d8_device_BeginScene(IDirect3DDevice8 *iface)
1370
{
1371
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1372
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1373 1374

    TRACE("iface %p.\n", iface);
1375

1376
    wined3d_mutex_lock();
1377
    hr = wined3d_device_begin_scene(device->wined3d_device);
1378 1379
    wined3d_mutex_unlock();

1380
    return hr;
1381
}
1382

1383
static HRESULT WINAPI DECLSPEC_HOTPATCH d3d8_device_EndScene(IDirect3DDevice8 *iface)
1384
{
1385
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1386
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1387 1388

    TRACE("iface %p.\n", iface);
1389

1390
    wined3d_mutex_lock();
1391
    hr = wined3d_device_end_scene(device->wined3d_device);
1392 1393
    wined3d_mutex_unlock();

1394
    return hr;
1395 1396
}

1397
static HRESULT WINAPI d3d8_device_Clear(IDirect3DDevice8 *iface, DWORD rect_count,
1398
        const D3DRECT *rects, DWORD flags, D3DCOLOR color, float z, DWORD stencil)
1399
{
1400 1401 1402 1403 1404 1405 1406
    const struct wined3d_color c =
    {
        ((color >> 16) & 0xff) / 255.0f,
        ((color >>  8) & 0xff) / 255.0f,
        (color & 0xff) / 255.0f,
        ((color >> 24) & 0xff) / 255.0f,
    };
1407
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1408
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1409 1410

    TRACE("iface %p, rect_count %u, rects %p, flags %#x, color 0x%08x, z %.8e, stencil %u.\n",
1411
            iface, rect_count, rects, flags, color, z, stencil);
1412

1413 1414 1415 1416 1417 1418
    if (rect_count && !rects)
    {
        WARN("count %u with NULL rects.\n", rect_count);
        rect_count = 0;
    }

1419
    wined3d_mutex_lock();
1420
    hr = wined3d_device_clear(device->wined3d_device, rect_count, (const RECT *)rects, flags, &c, z, stencil);
1421 1422
    wined3d_mutex_unlock();

1423
    return hr;
1424
}
1425

1426 1427
static HRESULT WINAPI d3d8_device_SetTransform(IDirect3DDevice8 *iface,
        D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
1428
{
1429
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1430

1431
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
1432

1433
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
1434
    wined3d_mutex_lock();
1435
    wined3d_device_set_transform(device->wined3d_device, state, (const struct wined3d_matrix *)matrix);
1436 1437
    wined3d_mutex_unlock();

1438
    return D3D_OK;
1439
}
1440

1441 1442
static HRESULT WINAPI d3d8_device_GetTransform(IDirect3DDevice8 *iface,
        D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
1443
{
1444
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1445

1446
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
1447

1448
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
1449
    wined3d_mutex_lock();
1450
    wined3d_device_get_transform(device->wined3d_device, state, (struct wined3d_matrix *)matrix);
1451 1452
    wined3d_mutex_unlock();

1453
    return D3D_OK;
1454
}
1455

1456 1457
static HRESULT WINAPI d3d8_device_MultiplyTransform(IDirect3DDevice8 *iface,
        D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
1458
{
1459
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1460

1461
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
1462

1463
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
1464
    wined3d_mutex_lock();
1465
    wined3d_device_multiply_transform(device->wined3d_device, state, (const struct wined3d_matrix *)matrix);
1466 1467
    wined3d_mutex_unlock();

1468
    return D3D_OK;
1469
}
1470

1471
static HRESULT WINAPI d3d8_device_SetViewport(IDirect3DDevice8 *iface, const D3DVIEWPORT8 *viewport)
1472
{
1473
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1474
    struct wined3d_viewport vp;
Henri Verbeet's avatar
Henri Verbeet committed
1475

1476
    TRACE("iface %p, viewport %p.\n", iface, viewport);
1477

1478 1479 1480 1481 1482 1483 1484
    vp.x = viewport->X;
    vp.y = viewport->Y;
    vp.width = viewport->Width;
    vp.height = viewport->Height;
    vp.min_z = viewport->MinZ;
    vp.max_z = viewport->MaxZ;

1485
    wined3d_mutex_lock();
1486
    wined3d_device_set_viewport(device->wined3d_device, &vp);
1487 1488
    wined3d_mutex_unlock();

1489
    return D3D_OK;
1490 1491
}

1492
static HRESULT WINAPI d3d8_device_GetViewport(IDirect3DDevice8 *iface, D3DVIEWPORT8 *viewport)
1493
{
1494
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1495
    struct wined3d_viewport wined3d_viewport;
Henri Verbeet's avatar
Henri Verbeet committed
1496

1497
    TRACE("iface %p, viewport %p.\n", iface, viewport);
1498

1499
    wined3d_mutex_lock();
1500
    wined3d_device_get_viewport(device->wined3d_device, &wined3d_viewport);
1501 1502
    wined3d_mutex_unlock();

1503 1504 1505 1506 1507 1508 1509
    viewport->X = wined3d_viewport.x;
    viewport->Y = wined3d_viewport.y;
    viewport->Width = wined3d_viewport.width;
    viewport->Height = wined3d_viewport.height;
    viewport->MinZ = wined3d_viewport.min_z;
    viewport->MaxZ = wined3d_viewport.max_z;

1510
    return D3D_OK;
1511
}
1512

1513
static HRESULT WINAPI d3d8_device_SetMaterial(IDirect3DDevice8 *iface, const D3DMATERIAL8 *material)
1514
{
1515
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1516

1517
    TRACE("iface %p, material %p.\n", iface, material);
1518

1519
    /* Note: D3DMATERIAL8 is compatible with struct wined3d_material. */
1520
    wined3d_mutex_lock();
1521
    wined3d_device_set_material(device->wined3d_device, (const struct wined3d_material *)material);
1522 1523
    wined3d_mutex_unlock();

1524
    return D3D_OK;
1525 1526
}

1527
static HRESULT WINAPI d3d8_device_GetMaterial(IDirect3DDevice8 *iface, D3DMATERIAL8 *material)
1528
{
1529
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1530

1531
    TRACE("iface %p, material %p.\n", iface, material);
1532

1533
    /* Note: D3DMATERIAL8 is compatible with struct wined3d_material. */
1534
    wined3d_mutex_lock();
1535
    wined3d_device_get_material(device->wined3d_device, (struct wined3d_material *)material);
1536 1537
    wined3d_mutex_unlock();

1538
    return D3D_OK;
1539 1540
}

1541
static HRESULT WINAPI d3d8_device_SetLight(IDirect3DDevice8 *iface, DWORD index, const D3DLIGHT8 *light)
1542
{
1543
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1544
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1545

1546
    TRACE("iface %p, index %u, light %p.\n", iface, index, light);
1547

1548
    /* Note: D3DLIGHT8 is compatible with struct wined3d_light. */
1549
    wined3d_mutex_lock();
1550
    hr = wined3d_device_set_light(device->wined3d_device, index, (const struct wined3d_light *)light);
1551 1552
    wined3d_mutex_unlock();

1553
    return hr;
1554
}
1555

1556
static HRESULT WINAPI d3d8_device_GetLight(IDirect3DDevice8 *iface, DWORD index, D3DLIGHT8 *light)
1557
{
1558
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1559
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1560

1561
    TRACE("iface %p, index %u, light %p.\n", iface, index, light);
1562

1563
    /* Note: D3DLIGHT8 is compatible with struct wined3d_light. */
1564
    wined3d_mutex_lock();
1565
    hr = wined3d_device_get_light(device->wined3d_device, index, (struct wined3d_light *)light);
1566 1567
    wined3d_mutex_unlock();

1568
    return hr;
1569 1570
}

1571
static HRESULT WINAPI d3d8_device_LightEnable(IDirect3DDevice8 *iface, DWORD index, BOOL enable)
1572
{
1573
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1574
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1575

1576
    TRACE("iface %p, index %u, enable %#x.\n", iface, index, enable);
1577

1578
    wined3d_mutex_lock();
1579
    hr = wined3d_device_set_light_enable(device->wined3d_device, index, enable);
1580 1581
    wined3d_mutex_unlock();

1582
    return hr;
1583
}
1584

1585
static HRESULT WINAPI d3d8_device_GetLightEnable(IDirect3DDevice8 *iface, DWORD index, BOOL *enable)
1586
{
1587
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1588
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1589

1590
    TRACE("iface %p, index %u, enable %p.\n", iface, index, enable);
1591

1592
    wined3d_mutex_lock();
1593
    hr = wined3d_device_get_light_enable(device->wined3d_device, index, enable);
1594 1595
    wined3d_mutex_unlock();

1596
    return hr;
1597
}
1598

1599
static HRESULT WINAPI d3d8_device_SetClipPlane(IDirect3DDevice8 *iface, DWORD index, const float *plane)
1600
{
1601
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1602
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1603

1604
    TRACE("iface %p, index %u, plane %p.\n", iface, index, plane);
1605

1606
    wined3d_mutex_lock();
1607
    hr = wined3d_device_set_clip_plane(device->wined3d_device, index, (const struct wined3d_vec4 *)plane);
1608 1609
    wined3d_mutex_unlock();

1610
    return hr;
1611
}
1612

1613
static HRESULT WINAPI d3d8_device_GetClipPlane(IDirect3DDevice8 *iface, DWORD index, float *plane)
1614
{
1615
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1616
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1617

1618
    TRACE("iface %p, index %u, plane %p.\n", iface, index, plane);
Jason Edmeades's avatar
Jason Edmeades committed
1619

1620
    wined3d_mutex_lock();
1621
    hr = wined3d_device_get_clip_plane(device->wined3d_device, index, (struct wined3d_vec4 *)plane);
1622 1623
    wined3d_mutex_unlock();

1624
    return hr;
1625
}
1626

1627 1628
static HRESULT WINAPI d3d8_device_SetRenderState(IDirect3DDevice8 *iface,
        D3DRENDERSTATETYPE state, DWORD value)
1629
{
1630
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1631

1632
    TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
1633

1634
    wined3d_mutex_lock();
1635
    switch (state)
1636 1637
    {
        case D3DRS_ZBIAS:
1638
            wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DEPTHBIAS, value);
1639 1640 1641
            break;

        default:
1642
            wined3d_device_set_render_state(device->wined3d_device, state, value);
1643
    }
1644 1645
    wined3d_mutex_unlock();

1646
    return D3D_OK;
1647
}
1648

1649 1650
static HRESULT WINAPI d3d8_device_GetRenderState(IDirect3DDevice8 *iface,
        D3DRENDERSTATETYPE state, DWORD *value)
1651
{
1652
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
Henri Verbeet's avatar
Henri Verbeet committed
1653

1654
    TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
1655

1656
    wined3d_mutex_lock();
1657
    switch (state)
1658 1659
    {
        case D3DRS_ZBIAS:
1660
            *value = wined3d_device_get_render_state(device->wined3d_device, WINED3D_RS_DEPTHBIAS);
1661 1662 1663
            break;

        default:
1664
            *value = wined3d_device_get_render_state(device->wined3d_device, state);
1665
    }
1666 1667
    wined3d_mutex_unlock();

1668
    return D3D_OK;
1669
}
1670

1671
static HRESULT WINAPI d3d8_device_BeginStateBlock(IDirect3DDevice8 *iface)
1672
{
1673
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1674
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1675 1676

    TRACE("iface %p.\n", iface);
1677

1678
    wined3d_mutex_lock();
1679
    hr = wined3d_device_begin_stateblock(device->wined3d_device);
1680 1681
    wined3d_mutex_unlock();

1682
    return hr;
1683
}
1684

1685
static HRESULT WINAPI d3d8_device_EndStateBlock(IDirect3DDevice8 *iface, DWORD *token)
1686
{
1687
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1688
    struct wined3d_stateblock *stateblock;
1689
    HRESULT hr;
1690

1691
    TRACE("iface %p, token %p.\n", iface, token);
1692

Austin English's avatar
Austin English committed
1693
    /* Tell wineD3D to endstateblock before anything else (in case we run out
1694 1695
     * of memory later and cause locking problems)
     */
1696
    wined3d_mutex_lock();
1697
    hr = wined3d_device_end_stateblock(device->wined3d_device, &stateblock);
1698 1699
    if (FAILED(hr))
    {
1700
        WARN("Failed to end the state block, %#x.\n", hr);
1701
        wined3d_mutex_unlock();
1702
        return hr;
1703
    }
1704

1705
    *token = d3d8_allocate_handle(&device->handle_table, stateblock, D3D8_HANDLE_SB);
1706
    wined3d_mutex_unlock();
1707

1708
    if (*token == D3D8_INVALID_HANDLE)
1709 1710
    {
        ERR("Failed to create a handle\n");
1711
        wined3d_mutex_lock();
1712
        wined3d_stateblock_decref(stateblock);
1713
        wined3d_mutex_unlock();
1714 1715
        return E_FAIL;
    }
1716
    ++*token;
1717

1718
    TRACE("Returning %#x (%p).\n", *token, stateblock);
1719

1720
    return hr;
1721 1722
}

1723
static HRESULT WINAPI d3d8_device_ApplyStateBlock(IDirect3DDevice8 *iface, DWORD token)
1724
{
1725
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1726
    struct wined3d_stateblock *stateblock;
1727

1728
    TRACE("iface %p, token %#x.\n", iface, token);
1729

1730 1731
    if (!token)
        return D3D_OK;
1732

1733
    wined3d_mutex_lock();
1734
    stateblock = d3d8_get_object(&device->handle_table, token - 1, D3D8_HANDLE_SB);
1735
    if (!stateblock)
1736
    {
1737
        WARN("Invalid handle (%#x) passed.\n", token);
1738
        wined3d_mutex_unlock();
1739 1740
        return D3DERR_INVALIDCALL;
    }
1741
    wined3d_stateblock_apply(stateblock);
1742 1743
    wined3d_mutex_unlock();

1744
    return D3D_OK;
1745
}
1746

1747
static HRESULT WINAPI d3d8_device_CaptureStateBlock(IDirect3DDevice8 *iface, DWORD token)
1748
{
1749
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1750
    struct wined3d_stateblock *stateblock;
1751

1752
    TRACE("iface %p, token %#x.\n", iface, token);
1753

1754
    wined3d_mutex_lock();
1755
    stateblock = d3d8_get_object(&device->handle_table, token - 1, D3D8_HANDLE_SB);
1756
    if (!stateblock)
1757
    {
1758
        WARN("Invalid handle (%#x) passed.\n", token);
1759
        wined3d_mutex_unlock();
1760 1761
        return D3DERR_INVALIDCALL;
    }
1762
    wined3d_stateblock_capture(stateblock);
1763 1764
    wined3d_mutex_unlock();

1765
    return D3D_OK;
1766 1767
}

1768
static HRESULT WINAPI d3d8_device_DeleteStateBlock(IDirect3DDevice8 *iface, DWORD token)
1769
{
1770
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1771
    struct wined3d_stateblock *stateblock;
1772

1773
    TRACE("iface %p, token %#x.\n", iface, token);
1774

1775
    wined3d_mutex_lock();
1776
    stateblock = d3d8_free_handle(&device->handle_table, token - 1, D3D8_HANDLE_SB);
1777

1778
    if (!stateblock)
1779
    {
1780
        WARN("Invalid handle (%#x) passed.\n", token);
1781
        wined3d_mutex_unlock();
1782 1783
        return D3DERR_INVALIDCALL;
    }
1784

1785
    if (wined3d_stateblock_decref(stateblock))
1786
    {
1787
        ERR("Stateblock %p has references left, this shouldn't happen.\n", stateblock);
1788
    }
1789
    wined3d_mutex_unlock();
1790

1791
    return D3D_OK;
1792
}
1793

1794 1795
static HRESULT WINAPI d3d8_device_CreateStateBlock(IDirect3DDevice8 *iface,
        D3DSTATEBLOCKTYPE type, DWORD *handle)
1796
{
1797
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1798
    struct wined3d_stateblock *stateblock;
1799
    HRESULT hr;
1800

1801
    TRACE("iface %p, type %#x, handle %p.\n", iface, type, handle);
1802

1803 1804 1805
    if (type != D3DSBT_ALL
            && type != D3DSBT_PIXELSTATE
            && type != D3DSBT_VERTEXSTATE)
1806 1807 1808 1809
    {
        WARN("Unexpected stateblock type, returning D3DERR_INVALIDCALL\n");
        return D3DERR_INVALIDCALL;
    }
1810

1811
    wined3d_mutex_lock();
1812
    hr = wined3d_stateblock_create(device->wined3d_device, (enum wined3d_stateblock_type)type, &stateblock);
1813 1814
    if (FAILED(hr))
    {
1815
        wined3d_mutex_unlock();
1816
        ERR("Failed to create the state block, hr %#x\n", hr);
1817 1818 1819
        return hr;
    }

1820
    *handle = d3d8_allocate_handle(&device->handle_table, stateblock, D3D8_HANDLE_SB);
1821
    wined3d_mutex_unlock();
1822 1823 1824 1825

    if (*handle == D3D8_INVALID_HANDLE)
    {
        ERR("Failed to allocate a handle.\n");
1826
        wined3d_mutex_lock();
1827
        wined3d_stateblock_decref(stateblock);
1828
        wined3d_mutex_unlock();
1829 1830 1831 1832
        return E_FAIL;
    }
    ++*handle;

1833
    TRACE("Returning %#x (%p).\n", *handle, stateblock);
1834 1835

    return hr;
1836
}
1837

1838
static HRESULT WINAPI d3d8_device_SetClipStatus(IDirect3DDevice8 *iface, const D3DCLIPSTATUS8 *clip_status)
1839
{
1840
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1841
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1842

1843
    TRACE("iface %p, clip_status %p.\n", iface, clip_status);
1844
    /* FIXME: Verify that D3DCLIPSTATUS8 ~= struct wined3d_clip_status. */
1845 1846

    wined3d_mutex_lock();
1847
    hr = wined3d_device_set_clip_status(device->wined3d_device, (const struct wined3d_clip_status *)clip_status);
1848 1849
    wined3d_mutex_unlock();

1850
    return hr;
1851
}
1852

1853
static HRESULT WINAPI d3d8_device_GetClipStatus(IDirect3DDevice8 *iface, D3DCLIPSTATUS8 *clip_status)
1854
{
1855
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1856
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1857

1858
    TRACE("iface %p, clip_status %p.\n", iface, clip_status);
1859

1860
    wined3d_mutex_lock();
1861
    hr = wined3d_device_get_clip_status(device->wined3d_device, (struct wined3d_clip_status *)clip_status);
1862 1863
    wined3d_mutex_unlock();

1864
    return hr;
1865
}
1866

1867
static HRESULT WINAPI d3d8_device_GetTexture(IDirect3DDevice8 *iface, DWORD stage, IDirect3DBaseTexture8 **texture)
1868
{
1869
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1870
    struct wined3d_texture *wined3d_texture;
1871
    struct d3d8_texture *texture_impl;
1872

1873
    TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
1874

1875
    if (!texture)
1876 1877
        return D3DERR_INVALIDCALL;

1878
    wined3d_mutex_lock();
1879
    if ((wined3d_texture = wined3d_device_get_texture(device->wined3d_device, stage)))
1880
    {
1881
        texture_impl = wined3d_texture_get_parent(wined3d_texture);
1882 1883
        *texture = &texture_impl->IDirect3DBaseTexture8_iface;
        IDirect3DBaseTexture8_AddRef(*texture);
1884 1885 1886
    }
    else
    {
1887
        *texture = NULL;
1888
    }
1889
    wined3d_mutex_unlock();
1890

1891
    return D3D_OK;
1892 1893
}

1894
static HRESULT WINAPI d3d8_device_SetTexture(IDirect3DDevice8 *iface, DWORD stage, IDirect3DBaseTexture8 *texture)
1895
{
1896
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1897
    struct d3d8_texture *texture_impl;
1898
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
1899

1900 1901 1902
    TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);

    texture_impl = unsafe_impl_from_IDirect3DBaseTexture8(texture);
1903

1904
    wined3d_mutex_lock();
1905
    hr = wined3d_device_set_texture(device->wined3d_device, stage,
1906
            texture_impl ? texture_impl->wined3d_texture : NULL);
1907 1908
    wined3d_mutex_unlock();

1909
    return hr;
1910 1911
}

1912 1913 1914
static const struct tss_lookup
{
    BOOL sampler_state;
1915 1916 1917 1918 1919
    union
    {
        enum wined3d_texture_stage_state texture_state;
        enum wined3d_sampler_state sampler_state;
    } u;
1920 1921 1922
}
tss_lookup[] =
{
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951
    {FALSE, {WINED3D_TSS_INVALID}},                   /*  0, unused */
    {FALSE, {WINED3D_TSS_COLOR_OP}},                  /*  1, D3DTSS_COLOROP */
    {FALSE, {WINED3D_TSS_COLOR_ARG1}},                /*  2, D3DTSS_COLORARG1 */
    {FALSE, {WINED3D_TSS_COLOR_ARG2}},                /*  3, D3DTSS_COLORARG2 */
    {FALSE, {WINED3D_TSS_ALPHA_OP}},                  /*  4, D3DTSS_ALPHAOP */
    {FALSE, {WINED3D_TSS_ALPHA_ARG1}},                /*  5, D3DTSS_ALPHAARG1 */
    {FALSE, {WINED3D_TSS_ALPHA_ARG2}},                /*  6, D3DTSS_ALPHAARG2 */
    {FALSE, {WINED3D_TSS_BUMPENV_MAT00}},             /*  7, D3DTSS_BUMPENVMAT00 */
    {FALSE, {WINED3D_TSS_BUMPENV_MAT01}},             /*  8, D3DTSS_BUMPENVMAT01 */
    {FALSE, {WINED3D_TSS_BUMPENV_MAT10}},             /*  9, D3DTSS_BUMPENVMAT10 */
    {FALSE, {WINED3D_TSS_BUMPENV_MAT11}},             /* 10, D3DTSS_BUMPENVMAT11 */
    {FALSE, {WINED3D_TSS_TEXCOORD_INDEX}},            /* 11, D3DTSS_TEXCOORDINDEX */
    {FALSE, {WINED3D_TSS_INVALID}},                   /* 12, unused */
    {TRUE,  {WINED3D_SAMP_ADDRESS_U}},                /* 13, D3DTSS_ADDRESSU */
    {TRUE,  {WINED3D_SAMP_ADDRESS_V}},                /* 14, D3DTSS_ADDRESSV */
    {TRUE,  {WINED3D_SAMP_BORDER_COLOR}},             /* 15, D3DTSS_BORDERCOLOR */
    {TRUE,  {WINED3D_SAMP_MAG_FILTER}},               /* 16, D3DTSS_MAGFILTER */
    {TRUE,  {WINED3D_SAMP_MIN_FILTER}},               /* 17, D3DTSS_MINFILTER */
    {TRUE,  {WINED3D_SAMP_MIP_FILTER}},               /* 18, D3DTSS_MIPFILTER */
    {TRUE,  {WINED3D_SAMP_MIPMAP_LOD_BIAS}},          /* 19, D3DTSS_MIPMAPLODBIAS */
    {TRUE,  {WINED3D_SAMP_MAX_MIP_LEVEL}},            /* 20, D3DTSS_MAXMIPLEVEL */
    {TRUE,  {WINED3D_SAMP_MAX_ANISOTROPY}},           /* 21, D3DTSS_MAXANISOTROPY */
    {FALSE, {WINED3D_TSS_BUMPENV_LSCALE}},            /* 22, D3DTSS_BUMPENVLSCALE */
    {FALSE, {WINED3D_TSS_BUMPENV_LOFFSET}},           /* 23, D3DTSS_BUMPENVLOFFSET */
    {FALSE, {WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS}},   /* 24, D3DTSS_TEXTURETRANSFORMFLAGS */
    {TRUE,  {WINED3D_SAMP_ADDRESS_W}},                /* 25, D3DTSS_ADDRESSW */
    {FALSE, {WINED3D_TSS_COLOR_ARG0}},                /* 26, D3DTSS_COLORARG0 */
    {FALSE, {WINED3D_TSS_ALPHA_ARG0}},                /* 27, D3DTSS_ALPHAARG0 */
    {FALSE, {WINED3D_TSS_RESULT_ARG}},                /* 28, D3DTSS_RESULTARG */
1952 1953
};

1954 1955
static HRESULT WINAPI d3d8_device_GetTextureStageState(IDirect3DDevice8 *iface,
        DWORD stage, D3DTEXTURESTAGESTATETYPE Type, DWORD *value)
1956
{
1957
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1958
    const struct tss_lookup *l;
Henri Verbeet's avatar
Henri Verbeet committed
1959

1960
    TRACE("iface %p, stage %u, state %#x, value %p.\n", iface, stage, Type, value);
1961

1962 1963 1964 1965 1966 1967 1968 1969
    if (Type >= sizeof(tss_lookup) / sizeof(*tss_lookup))
    {
        WARN("Invalid Type %#x passed.\n", Type);
        return D3D_OK;
    }

    l = &tss_lookup[Type];

1970
    wined3d_mutex_lock();
1971
    if (l->sampler_state)
1972
        *value = wined3d_device_get_sampler_state(device->wined3d_device, stage, l->u.sampler_state);
1973
    else
1974
        *value = wined3d_device_get_texture_stage_state(device->wined3d_device, stage, l->u.texture_state);
1975
    wined3d_mutex_unlock();
1976

1977
    return D3D_OK;
1978
}
1979

1980 1981
static HRESULT WINAPI d3d8_device_SetTextureStageState(IDirect3DDevice8 *iface,
        DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD value)
1982
{
1983
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
1984
    const struct tss_lookup *l;
Henri Verbeet's avatar
Henri Verbeet committed
1985

1986
    TRACE("iface %p, stage %u, state %#x, value %#x.\n", iface, stage, type, value);
1987

1988
    if (type >= sizeof(tss_lookup) / sizeof(*tss_lookup))
1989
    {
1990
        WARN("Invalid type %#x passed.\n", type);
1991 1992 1993
        return D3D_OK;
    }

1994
    l = &tss_lookup[type];
1995

1996
    wined3d_mutex_lock();
1997
    if (l->sampler_state)
1998
        wined3d_device_set_sampler_state(device->wined3d_device, stage, l->u.sampler_state, value);
1999
    else
2000
        wined3d_device_set_texture_stage_state(device->wined3d_device, stage, l->u.texture_state, value);
2001
    wined3d_mutex_unlock();
2002

2003
    return D3D_OK;
2004
}
2005

2006
static HRESULT WINAPI d3d8_device_ValidateDevice(IDirect3DDevice8 *iface, DWORD *pass_count)
2007
{
2008
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2009
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2010

2011
    TRACE("iface %p, pass_count %p.\n", iface, pass_count);
2012

2013
    wined3d_mutex_lock();
2014
    hr = wined3d_device_validate_device(device->wined3d_device, pass_count);
2015 2016
    wined3d_mutex_unlock();

2017
    return hr;
2018
}
2019

2020
static HRESULT WINAPI d3d8_device_GetInfo(IDirect3DDevice8 *iface,
Henri Verbeet's avatar
Henri Verbeet committed
2021 2022 2023 2024
        DWORD info_id, void *info, DWORD info_size)
{
    FIXME("iface %p, info_id %#x, info %p, info_size %u stub!\n", iface, info_id, info, info_size);

2025
    return D3D_OK;
2026
}
2027

2028 2029
static HRESULT WINAPI d3d8_device_SetPaletteEntries(IDirect3DDevice8 *iface,
        UINT palette_idx, const PALETTEENTRY *entries)
2030
{
2031
    WARN("iface %p, palette_idx %u, entries %p unimplemented\n", iface, palette_idx, entries);
Henri Verbeet's avatar
Henri Verbeet committed
2032

2033 2034
    /* GPUs stopped supporting palettized textures with the Shader Model 1 generation. Wined3d
     * does not have a d3d8/9-style palette API */
2035

2036
    return D3D_OK;
2037
}
2038

2039 2040
static HRESULT WINAPI d3d8_device_GetPaletteEntries(IDirect3DDevice8 *iface,
        UINT palette_idx, PALETTEENTRY *entries)
2041
{
2042
    FIXME("iface %p, palette_idx %u, entries %p unimplemented.\n", iface, palette_idx, entries);
2043

2044
    return D3DERR_INVALIDCALL;
2045
}
2046

2047
static HRESULT WINAPI d3d8_device_SetCurrentTexturePalette(IDirect3DDevice8 *iface, UINT palette_idx)
2048
{
2049
    WARN("iface %p, palette_idx %u unimplemented.\n", iface, palette_idx);
2050

2051
    return D3D_OK;
2052
}
2053

2054
static HRESULT WINAPI d3d8_device_GetCurrentTexturePalette(IDirect3DDevice8 *iface, UINT *palette_idx)
2055
{
2056
    FIXME("iface %p, palette_idx %p unimplemented.\n", iface, palette_idx);
2057

2058
    return D3DERR_INVALIDCALL;
2059
}
2060

2061 2062
static HRESULT WINAPI d3d8_device_DrawPrimitive(IDirect3DDevice8 *iface,
        D3DPRIMITIVETYPE primitive_type, UINT start_vertex, UINT primitive_count)
2063
{
2064
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2065
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2066 2067

    TRACE("iface %p, primitive_type %#x, start_vertex %u, primitive_count %u.\n",
2068
            iface, primitive_type, start_vertex, primitive_count);
2069

2070
    wined3d_mutex_lock();
2071
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
2072 2073
    hr = wined3d_device_draw_primitive(device->wined3d_device, start_vertex,
            vertex_count_from_primitive_count(primitive_type, primitive_count));
2074 2075
    wined3d_mutex_unlock();

2076
    return hr;
2077
}
2078

2079 2080 2081
static HRESULT WINAPI d3d8_device_DrawIndexedPrimitive(IDirect3DDevice8 *iface,
        D3DPRIMITIVETYPE primitive_type, UINT min_vertex_idx, UINT vertex_count,
        UINT start_idx, UINT primitive_count)
2082
{
2083
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2084
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2085 2086

    TRACE("iface %p, primitive_type %#x, min_vertex_idx %u, vertex_count %u, start_idx %u, primitive_count %u.\n",
2087
            iface, primitive_type, min_vertex_idx, vertex_count, start_idx, primitive_count);
2088

2089
    wined3d_mutex_lock();
2090
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
2091 2092
    hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, start_idx,
            vertex_count_from_primitive_count(primitive_type, primitive_count));
2093 2094
    wined3d_mutex_unlock();

2095
    return hr;
2096 2097
}

2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
/* The caller is responsible for wined3d locking */
static HRESULT d3d8_device_prepare_vertex_buffer(struct d3d8_device *device, UINT min_size)
{
    HRESULT hr;

    if (device->vertex_buffer_size < min_size || !device->vertex_buffer)
    {
        UINT size = max(device->vertex_buffer_size * 2, min_size);
        struct wined3d_buffer *buffer;

        TRACE("Growing vertex buffer to %u bytes\n", size);

        hr = wined3d_buffer_create_vb(device->wined3d_device, size, WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY,
                WINED3D_POOL_DEFAULT, NULL, &d3d8_null_wined3d_parent_ops, &buffer);
        if (FAILED(hr))
        {
            ERR("(%p) wined3d_buffer_create_vb failed with hr = %08x\n", device, hr);
            return hr;
        }

        if (device->vertex_buffer)
            wined3d_buffer_decref(device->vertex_buffer);

        device->vertex_buffer = buffer;
        device->vertex_buffer_size = size;
        device->vertex_buffer_pos = 0;
    }
    return D3D_OK;
}

2128 2129 2130
static HRESULT WINAPI d3d8_device_DrawPrimitiveUP(IDirect3DDevice8 *iface,
        D3DPRIMITIVETYPE primitive_type, UINT primitive_count, const void *data,
        UINT stride)
2131
{
2132
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2133
    HRESULT hr;
2134
    UINT vtx_count = vertex_count_from_primitive_count(primitive_type, primitive_count);
2135 2136
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
2137
    UINT size = vtx_count * stride;
2138
    struct wined3d_resource *vb;
2139
    UINT vb_pos, align;
Henri Verbeet's avatar
Henri Verbeet committed
2140 2141

    TRACE("iface %p, primitive_type %#x, primitive_count %u, data %p, stride %u.\n",
2142
            iface, primitive_type, primitive_count, data, stride);
2143

2144 2145 2146 2147 2148 2149
    if (!primitive_count)
    {
        WARN("primitive_count is 0, returning D3D_OK\n");
        return D3D_OK;
    }

2150
    wined3d_mutex_lock();
2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
    hr = d3d8_device_prepare_vertex_buffer(device, size);
    if (FAILED(hr))
        goto done;

    vb_pos = device->vertex_buffer_pos;
    align = vb_pos % stride;
    if (align) align = stride - align;
    if (vb_pos + size + align > device->vertex_buffer_size)
        vb_pos = 0;
    else
        vb_pos += align;

2163 2164 2165 2166 2167
    wined3d_box.left = vb_pos;
    wined3d_box.right = vb_pos + size;
    vb = wined3d_buffer_get_resource(device->vertex_buffer);
    if (FAILED(wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
            vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))
2168
        goto done;
2169 2170
    memcpy(wined3d_map_desc.data, data, size);
    wined3d_resource_unmap(vb, 0);
2171 2172 2173 2174 2175 2176
    device->vertex_buffer_pos = vb_pos + size;

    hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, stride);
    if (FAILED(hr))
        goto done;

2177
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
2178 2179
    hr = wined3d_device_draw_primitive(device->wined3d_device, vb_pos / stride, vtx_count);
    wined3d_device_set_stream_source(device->wined3d_device, 0, NULL, 0, 0);
2180

2181 2182
done:
    wined3d_mutex_unlock();
2183
    return hr;
2184 2185
}

2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
/* The caller is responsible for wined3d locking */
static HRESULT d3d8_device_prepare_index_buffer(struct d3d8_device *device, UINT min_size)
{
    HRESULT hr;

    if (device->index_buffer_size < min_size || !device->index_buffer)
    {
        UINT size = max(device->index_buffer_size * 2, min_size);
        struct wined3d_buffer *buffer;

        TRACE("Growing index buffer to %u bytes\n", size);

        hr = wined3d_buffer_create_ib(device->wined3d_device, size, WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY,
                WINED3D_POOL_DEFAULT, NULL, &d3d8_null_wined3d_parent_ops, &buffer);
        if (FAILED(hr))
        {
            ERR("(%p) wined3d_buffer_create_ib failed with hr = %08x\n", device, hr);
            return hr;
        }

        if (device->index_buffer)
            wined3d_buffer_decref(device->index_buffer);

        device->index_buffer = buffer;
        device->index_buffer_size = size;
        device->index_buffer_pos = 0;
    }
    return D3D_OK;
}

2216
static HRESULT WINAPI d3d8_device_DrawIndexedPrimitiveUP(IDirect3DDevice8 *iface,
2217
        D3DPRIMITIVETYPE primitive_type, UINT min_vertex_idx, UINT vertex_count,
2218 2219
        UINT primitive_count, const void *index_data, D3DFORMAT index_format,
        const void *vertex_data, UINT vertex_stride)
2220
{
2221
    UINT idx_count = vertex_count_from_primitive_count(primitive_type, primitive_count);
2222
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2223
    UINT idx_fmt_size = index_format == D3DFMT_INDEX16 ? 2 : 4;
2224
    UINT vtx_size = vertex_count * vertex_stride;
2225
    UINT idx_size = idx_count * idx_fmt_size;
2226 2227 2228
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
    struct wined3d_resource *ib, *vb;
2229 2230
    UINT vb_pos, ib_pos, align;
    HRESULT hr;
2231

2232
    TRACE("iface %p, primitive_type %#x, min_vertex_idx %u, vertex_count %u, primitive_count %u, "
Henri Verbeet's avatar
Henri Verbeet committed
2233
            "index_data %p, index_format %#x, vertex_data %p, vertex_stride %u.\n",
2234
            iface, primitive_type, min_vertex_idx, vertex_count, primitive_count,
2235
            index_data, index_format, vertex_data, vertex_stride);
2236

2237 2238 2239 2240 2241 2242
    if (!primitive_count)
    {
        WARN("primitive_count is 0, returning D3D_OK\n");
        return D3D_OK;
    }

2243
    wined3d_mutex_lock();
2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256

    hr = d3d8_device_prepare_vertex_buffer(device, vtx_size);
    if (FAILED(hr))
        goto done;

    vb_pos = device->vertex_buffer_pos;
    align = vb_pos % vertex_stride;
    if (align) align = vertex_stride - align;
    if (vb_pos + vtx_size + align > device->vertex_buffer_size)
        vb_pos = 0;
    else
        vb_pos += align;

2257 2258 2259 2260 2261
    wined3d_box.left = vb_pos;
    wined3d_box.right = vb_pos + vtx_size;
    vb = wined3d_buffer_get_resource(device->vertex_buffer);
    if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
            vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))
2262
        goto done;
2263
    memcpy(wined3d_map_desc.data, (char *)vertex_data + min_vertex_idx * vertex_stride, vtx_size);
2264
    wined3d_resource_unmap(vb, 0);
2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278
    device->vertex_buffer_pos = vb_pos + vtx_size;

    hr = d3d8_device_prepare_index_buffer(device, idx_size);
    if (FAILED(hr))
        goto done;

    ib_pos = device->index_buffer_pos;
    align = ib_pos % idx_fmt_size;
    if (align) align = idx_fmt_size - align;
    if (ib_pos + idx_size + align > device->index_buffer_size)
        ib_pos = 0;
    else
        ib_pos += align;

2279 2280 2281 2282 2283
    wined3d_box.left = ib_pos;
    wined3d_box.right = ib_pos + idx_size;
    ib = wined3d_buffer_get_resource(device->index_buffer);
    if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box,
            ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))
2284
        goto done;
2285 2286
    memcpy(wined3d_map_desc.data, index_data, idx_size);
    wined3d_resource_unmap(ib, 0);
2287 2288 2289 2290 2291 2292 2293
    device->index_buffer_pos = ib_pos + idx_size;

    hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, vertex_stride);
    if (FAILED(hr))
        goto done;

    wined3d_device_set_index_buffer(device->wined3d_device, device->index_buffer,
2294
            wined3dformat_from_d3dformat(index_format), 0);
2295
    wined3d_device_set_base_vertex_index(device->wined3d_device, vb_pos / vertex_stride - min_vertex_idx);
2296

2297
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
2298
    hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, ib_pos / idx_fmt_size, idx_count);
2299

2300
    wined3d_device_set_stream_source(device->wined3d_device, 0, NULL, 0, 0);
2301
    wined3d_device_set_index_buffer(device->wined3d_device, NULL, WINED3DFMT_UNKNOWN, 0);
2302 2303 2304 2305
    wined3d_device_set_base_vertex_index(device->wined3d_device, 0);

done:
    wined3d_mutex_unlock();
2306
    return hr;
2307
}
2308

2309 2310
static HRESULT WINAPI d3d8_device_ProcessVertices(IDirect3DDevice8 *iface, UINT src_start_idx,
        UINT dst_idx, UINT vertex_count, IDirect3DVertexBuffer8 *dst_buffer, DWORD flags)
2311
{
2312
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2313
    struct d3d8_vertexbuffer *dst = unsafe_impl_from_IDirect3DVertexBuffer8(dst_buffer);
2314
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2315 2316

    TRACE("iface %p, src_start_idx %u, dst_idx %u, vertex_count %u, dst_buffer %p, flags %#x.\n",
2317
            iface, src_start_idx, dst_idx, vertex_count, dst_buffer, flags);
2318

2319
    wined3d_mutex_lock();
2320
    hr = wined3d_device_process_vertices(device->wined3d_device, src_start_idx, dst_idx,
2321
            vertex_count, dst->wined3d_buffer, NULL, flags, dst->fvf);
2322 2323
    wined3d_mutex_unlock();

2324
    return hr;
2325
}
2326

2327
static HRESULT WINAPI d3d8_device_CreateVertexShader(IDirect3DDevice8 *iface,
2328 2329
        const DWORD *declaration, const DWORD *byte_code, DWORD *shader, DWORD usage)
{
2330
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2331
    struct d3d8_vertex_shader *object;
2332
    DWORD shader_handle;
2333
    DWORD handle;
2334
    HRESULT hr;
2335

2336 2337
    TRACE("iface %p, declaration %p, byte_code %p, shader %p, usage %#x.\n",
            iface, declaration, byte_code, shader, usage);
2338

2339
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2340 2341 2342 2343
    if (!object)
    {
        *shader = 0;
        return E_OUTOFMEMORY;
2344
    }
2345

2346
    wined3d_mutex_lock();
2347
    handle = d3d8_allocate_handle(&device->handle_table, object, D3D8_HANDLE_VS);
2348
    wined3d_mutex_unlock();
2349
    if (handle == D3D8_INVALID_HANDLE)
2350
    {
2351
        ERR("Failed to allocate vertex shader handle.\n");
2352
        HeapFree(GetProcessHeap(), 0, object);
2353
        *shader = 0;
2354 2355 2356
        return E_OUTOFMEMORY;
    }

2357
    shader_handle = handle + VS_HIGHESTFIXEDFXF + 1;
2358

2359
    hr = d3d8_vertex_shader_init(object, device, declaration, byte_code, shader_handle, usage);
2360 2361 2362 2363
    if (FAILED(hr))
    {
        WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
        wined3d_mutex_lock();
2364
        d3d8_free_handle(&device->handle_table, handle, D3D8_HANDLE_VS);
2365 2366 2367 2368
        wined3d_mutex_unlock();
        HeapFree(GetProcessHeap(), 0, object);
        *shader = 0;
        return hr;
2369
    }
2370

2371 2372
    TRACE("Created vertex shader %p (handle %#x).\n", object, shader_handle);
    *shader = shader_handle;
2373

2374
    return D3D_OK;
2375
}
2376

2377
static struct d3d8_vertex_declaration *d3d8_device_get_fvf_declaration(struct d3d8_device *device, DWORD fvf)
2378
{
2379
    struct d3d8_vertex_declaration *d3d8_declaration;
2380
    struct FvfToDecl *convertedDecls = device->decls;
2381
    int p, low, high; /* deliberately signed */
2382
    HRESULT hr;
2383 2384 2385 2386

    TRACE("Searching for declaration for fvf %08x... ", fvf);

    low = 0;
2387 2388 2389
    high = device->numConvertedDecls - 1;
    while (low <= high)
    {
2390 2391
        p = (low + high) >> 1;
        TRACE("%d ", p);
2392

2393 2394 2395 2396 2397
        if (convertedDecls[p].fvf == fvf)
        {
            TRACE("found %p\n", convertedDecls[p].declaration);
            return convertedDecls[p].declaration;
        }
2398 2399

        if (convertedDecls[p].fvf < fvf)
2400
            low = p + 1;
2401
        else
2402 2403 2404 2405
            high = p - 1;
    }
    TRACE("not found. Creating and inserting at position %d.\n", low);

2406
    if (!(d3d8_declaration = HeapAlloc(GetProcessHeap(), 0, sizeof(*d3d8_declaration))))
2407 2408
        return NULL;

2409
    if (FAILED(hr = d3d8_vertex_declaration_init_fvf(d3d8_declaration, device, fvf)))
2410
    {
2411
        WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
2412 2413 2414
        HeapFree(GetProcessHeap(), 0, d3d8_declaration);
        return NULL;
    }
2415

2416 2417 2418 2419
    if (device->declArraySize == device->numConvertedDecls)
    {
        UINT grow = device->declArraySize / 2;

2420
        convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
2421
                sizeof(*convertedDecls) * (device->numConvertedDecls + grow));
2422 2423 2424
        if (!convertedDecls)
        {
            d3d8_vertex_declaration_destroy(d3d8_declaration);
2425 2426
            return NULL;
        }
2427 2428
        device->decls = convertedDecls;
        device->declArraySize += grow;
2429 2430
    }

2431 2432
    memmove(convertedDecls + low + 1, convertedDecls + low,
            sizeof(*convertedDecls) * (device->numConvertedDecls - low));
2433
    convertedDecls[low].declaration = d3d8_declaration;
2434
    convertedDecls[low].fvf = fvf;
2435 2436 2437
    ++device->numConvertedDecls;

    TRACE("Returning %p. %u decls in array.\n", d3d8_declaration, device->numConvertedDecls);
2438

2439
    return d3d8_declaration;
2440 2441
}

2442
static HRESULT WINAPI d3d8_device_SetVertexShader(IDirect3DDevice8 *iface, DWORD shader)
2443
{
2444 2445
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
    struct d3d8_vertex_shader *shader_impl;
2446

2447
    TRACE("iface %p, shader %#x.\n", iface, shader);
2448

2449 2450 2451
    if (VS_HIGHESTFIXEDFXF >= shader)
    {
        TRACE("Setting FVF, %#x\n", shader);
2452

2453
        wined3d_mutex_lock();
2454 2455 2456
        wined3d_device_set_vertex_declaration(device->wined3d_device,
                d3d8_device_get_fvf_declaration(device, shader)->wined3d_vertex_declaration);
        wined3d_device_set_vertex_shader(device->wined3d_device, NULL);
2457 2458
        wined3d_mutex_unlock();

2459 2460
        return D3D_OK;
    }
2461

2462
    TRACE("Setting shader\n");
2463

2464
    wined3d_mutex_lock();
2465
    if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS)))
2466
    {
2467
        WARN("Invalid handle (%#x) passed.\n", shader);
2468 2469
        wined3d_mutex_unlock();

2470
        return D3DERR_INVALIDCALL;
2471
    }
2472

2473
    wined3d_device_set_vertex_declaration(device->wined3d_device,
2474
            shader_impl->vertex_declaration->wined3d_vertex_declaration);
2475
    wined3d_device_set_vertex_shader(device->wined3d_device, shader_impl->wined3d_shader);
2476
    wined3d_mutex_unlock();
2477

2478
    return D3D_OK;
2479
}
Raphael Junqueira's avatar
Raphael Junqueira committed
2480

2481
static HRESULT WINAPI d3d8_device_GetVertexShader(IDirect3DDevice8 *iface, DWORD *shader)
2482
{
2483
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2484
    struct wined3d_vertex_declaration *wined3d_declaration;
2485
    struct d3d8_vertex_declaration *d3d8_declaration;
2486

2487
    TRACE("iface %p, shader %p.\n", iface, shader);
2488

2489
    wined3d_mutex_lock();
2490
    if ((wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device)))
2491
    {
2492 2493
        d3d8_declaration = wined3d_vertex_declaration_get_parent(wined3d_declaration);
        *shader = d3d8_declaration->shader_handle;
2494
    }
2495
    else
2496
    {
2497
        *shader = 0;
2498
    }
2499
    wined3d_mutex_unlock();
2500

2501
    TRACE("Returning %#x.\n", *shader);
Raphael Junqueira's avatar
Raphael Junqueira committed
2502

2503
    return D3D_OK;
2504 2505
}

2506
static HRESULT WINAPI d3d8_device_DeleteVertexShader(IDirect3DDevice8 *iface, DWORD shader)
2507
{
2508 2509
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
    struct d3d8_vertex_shader *shader_impl;
2510

2511
    TRACE("iface %p, shader %#x.\n", iface, shader);
2512

2513
    wined3d_mutex_lock();
2514
    if (!(shader_impl = d3d8_free_handle(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS)))
2515
    {
2516
        WARN("Invalid handle (%#x) passed.\n", shader);
2517 2518
        wined3d_mutex_unlock();

2519
        return D3DERR_INVALIDCALL;
2520
    }
2521

2522 2523 2524
    if (shader_impl->wined3d_shader
            && wined3d_device_get_vertex_shader(device->wined3d_device) == shader_impl->wined3d_shader)
        IDirect3DDevice8_SetVertexShader(iface, 0);
2525

2526
    wined3d_mutex_unlock();
2527

2528
    d3d8_vertex_shader_destroy(shader_impl);
2529

2530
    return D3D_OK;
2531 2532
}

2533 2534
static HRESULT WINAPI d3d8_device_SetVertexShaderConstant(IDirect3DDevice8 *iface,
        DWORD start_register, const void *data, DWORD count)
2535
{
2536
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2537
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2538

2539 2540
    TRACE("iface %p, start_register %u, data %p, count %u.\n",
            iface, start_register, data, count);
2541

2542 2543
    if (start_register + count > D3D8_MAX_VERTEX_SHADER_CONSTANTF)
    {
2544
        WARN("Trying to access %u constants, but d3d8 only supports %u\n",
2545
             start_register + count, D3D8_MAX_VERTEX_SHADER_CONSTANTF);
2546 2547 2548
        return D3DERR_INVALIDCALL;
    }

2549
    wined3d_mutex_lock();
2550
    hr = wined3d_device_set_vs_consts_f(device->wined3d_device, start_register, count, data);
2551 2552
    wined3d_mutex_unlock();

2553
    return hr;
2554
}
2555

2556 2557
static HRESULT WINAPI d3d8_device_GetVertexShaderConstant(IDirect3DDevice8 *iface,
        DWORD start_register, void *data, DWORD count)
2558
{
2559
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2560
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2561

2562 2563
    TRACE("iface %p, start_register %u, data %p, count %u.\n",
            iface, start_register, data, count);
2564

2565 2566
    if (start_register + count > D3D8_MAX_VERTEX_SHADER_CONSTANTF)
    {
2567
        WARN("Trying to access %u constants, but d3d8 only supports %u\n",
2568
             start_register + count, D3D8_MAX_VERTEX_SHADER_CONSTANTF);
2569 2570 2571
        return D3DERR_INVALIDCALL;
    }

2572
    wined3d_mutex_lock();
2573
    hr = wined3d_device_get_vs_consts_f(device->wined3d_device, start_register, count, data);
2574 2575
    wined3d_mutex_unlock();

2576
    return hr;
2577
}
Raphael Junqueira's avatar
Raphael Junqueira committed
2578

2579 2580
static HRESULT WINAPI d3d8_device_GetVertexShaderDeclaration(IDirect3DDevice8 *iface,
        DWORD shader, void *data, DWORD *data_size)
2581
{
2582
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2583
    struct d3d8_vertex_declaration *declaration;
2584
    struct d3d8_vertex_shader *shader_impl;
Raphael Junqueira's avatar
Raphael Junqueira committed
2585

Henri Verbeet's avatar
Henri Verbeet committed
2586
    TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
2587
            iface, shader, data, data_size);
2588

2589
    wined3d_mutex_lock();
2590
    shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
2591 2592
    wined3d_mutex_unlock();

2593
    if (!shader_impl)
2594
    {
2595
        WARN("Invalid handle (%#x) passed.\n", shader);
2596 2597
        return D3DERR_INVALIDCALL;
    }
2598
    declaration = shader_impl->vertex_declaration;
2599

2600 2601 2602
    if (!data)
    {
        *data_size = declaration->elements_size;
2603 2604 2605
        return D3D_OK;
    }

2606
    /* MSDN claims that if *data_size is smaller than the required size
2607 2608
     * we should write the required size and return D3DERR_MOREDATA.
     * That's not actually true. */
2609
    if (*data_size < declaration->elements_size)
2610 2611
        return D3DERR_INVALIDCALL;

2612
    memcpy(data, declaration->elements, declaration->elements_size);
2613 2614

    return D3D_OK;
2615
}
2616

2617 2618
static HRESULT WINAPI d3d8_device_GetVertexShaderFunction(IDirect3DDevice8 *iface,
        DWORD shader, void *data, DWORD *data_size)
2619
{
2620 2621
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
    struct d3d8_vertex_shader *shader_impl = NULL;
2622
    HRESULT hr;
Raphael Junqueira's avatar
Raphael Junqueira committed
2623

Henri Verbeet's avatar
Henri Verbeet committed
2624
    TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
2625
            iface, shader, data, data_size);
2626

2627
    wined3d_mutex_lock();
2628
    if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS)))
2629
    {
2630
        WARN("Invalid handle (%#x) passed.\n", shader);
2631 2632
        wined3d_mutex_unlock();

2633 2634 2635
        return D3DERR_INVALIDCALL;
    }

2636
    if (!shader_impl->wined3d_shader)
2637
    {
2638
        wined3d_mutex_unlock();
2639
        *data_size = 0;
2640
        return D3D_OK;
2641 2642
    }

2643
    hr = wined3d_shader_get_byte_code(shader_impl->wined3d_shader, data, data_size);
2644
    wined3d_mutex_unlock();
2645

2646
    return hr;
2647 2648
}

2649 2650
static HRESULT WINAPI d3d8_device_SetIndices(IDirect3DDevice8 *iface,
        IDirect3DIndexBuffer8 *buffer, UINT base_vertex_idx)
2651
{
2652
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2653
    struct d3d8_indexbuffer *ib = unsafe_impl_from_IDirect3DIndexBuffer8(buffer);
Henri Verbeet's avatar
Henri Verbeet committed
2654

2655
    TRACE("iface %p, buffer %p, base_vertex_idx %u.\n", iface, buffer, base_vertex_idx);
2656

2657 2658 2659 2660 2661 2662
    /* WineD3D takes an INT(due to d3d9), but d3d8 uses UINTs. Do I have to add a check here that
     * the UINT doesn't cause an overflow in the INT? It seems rather unlikely because such large
     * vertex buffers can't be created to address them with an index that requires the 32nd bit
     * (4 Byte minimum vertex size * 2^31-1 -> 8 gb buffer. The index sign would be the least
     * problem)
     */
2663
    wined3d_mutex_lock();
2664
    wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_idx);
2665
    wined3d_device_set_index_buffer(device->wined3d_device,
2666
            ib ? ib->wined3d_buffer : NULL, ib ? ib->format : WINED3DFMT_UNKNOWN, 0);
2667 2668
    wined3d_mutex_unlock();

2669
    return D3D_OK;
2670
}
2671

2672 2673
static HRESULT WINAPI d3d8_device_GetIndices(IDirect3DDevice8 *iface,
        IDirect3DIndexBuffer8 **buffer, UINT *base_vertex_index)
2674
{
2675
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2676
    enum wined3d_format_id wined3d_format;
2677
    struct wined3d_buffer *wined3d_buffer;
2678
    struct d3d8_indexbuffer *buffer_impl;
2679

2680
    TRACE("iface %p, buffer %p, base_vertex_index %p.\n", iface, buffer, base_vertex_index);
2681

2682
    if (!buffer)
2683
        return D3DERR_INVALIDCALL;
2684

2685
    /* The case from UINT to INT is safe because d3d8 will never set negative values */
2686
    wined3d_mutex_lock();
2687
    *base_vertex_index = wined3d_device_get_base_vertex_index(device->wined3d_device);
2688
    if ((wined3d_buffer = wined3d_device_get_index_buffer(device->wined3d_device, &wined3d_format, NULL)))
2689 2690 2691 2692 2693 2694
    {
        buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
        *buffer = &buffer_impl->IDirect3DIndexBuffer8_iface;
        IDirect3DIndexBuffer8_AddRef(*buffer);
    }
    else
2695
    {
2696
        *buffer = NULL;
2697
    }
2698
    wined3d_mutex_unlock();
2699

2700
    return D3D_OK;
2701
}
2702

2703
static HRESULT WINAPI d3d8_device_CreatePixelShader(IDirect3DDevice8 *iface,
2704 2705
        const DWORD *byte_code, DWORD *shader)
{
2706
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2707
    struct d3d8_pixel_shader *object;
2708
    DWORD shader_handle;
2709 2710
    DWORD handle;
    HRESULT hr;
2711

2712
    TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader);
2713

2714
    if (!shader)
2715
        return D3DERR_INVALIDCALL;
2716

2717 2718
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
    if (!object)
2719 2720
        return E_OUTOFMEMORY;

2721
    wined3d_mutex_lock();
2722
    handle = d3d8_allocate_handle(&device->handle_table, object, D3D8_HANDLE_PS);
2723
    wined3d_mutex_unlock();
2724 2725
    if (handle == D3D8_INVALID_HANDLE)
    {
2726 2727
        ERR("Failed to allocate pixel shader handle.\n");
        HeapFree(GetProcessHeap(), 0, object);
2728 2729 2730
        return E_OUTOFMEMORY;
    }

2731
    shader_handle = handle + VS_HIGHESTFIXEDFXF + 1;
2732

2733
    hr = d3d8_pixel_shader_init(object, device, byte_code, shader_handle);
2734 2735 2736 2737
    if (FAILED(hr))
    {
        WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
        wined3d_mutex_lock();
2738
        d3d8_free_handle(&device->handle_table, handle, D3D8_HANDLE_PS);
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748
        wined3d_mutex_unlock();
        HeapFree(GetProcessHeap(), 0, object);
        *shader = 0;
        return hr;
    }

    TRACE("Created pixel shader %p (handle %#x).\n", object, shader_handle);
    *shader = shader_handle;

    return D3D_OK;
2749
}
2750

2751
static HRESULT WINAPI d3d8_device_SetPixelShader(IDirect3DDevice8 *iface, DWORD shader)
2752
{
2753 2754
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
    struct d3d8_pixel_shader *shader_impl;
2755

2756
    TRACE("iface %p, shader %#x.\n", iface, shader);
2757

2758
    wined3d_mutex_lock();
2759

2760
    if (!shader)
2761
    {
2762
        wined3d_device_set_pixel_shader(device->wined3d_device, NULL);
2763
        wined3d_mutex_unlock();
2764
        return D3D_OK;
2765 2766
    }

2767
    if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS)))
2768
    {
2769
        WARN("Invalid handle (%#x) passed.\n", shader);
2770
        wined3d_mutex_unlock();
2771
        return D3DERR_INVALIDCALL;
2772 2773
    }

2774
    TRACE("Setting shader %p.\n", shader_impl);
2775
    wined3d_device_set_pixel_shader(device->wined3d_device, shader_impl->wined3d_shader);
2776 2777
    wined3d_mutex_unlock();

2778
    return D3D_OK;
2779
}
2780

2781
static HRESULT WINAPI d3d8_device_GetPixelShader(IDirect3DDevice8 *iface, DWORD *shader)
2782
{
2783
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2784
    struct wined3d_shader *object;
Henri Verbeet's avatar
Henri Verbeet committed
2785

2786
    TRACE("iface %p, shader %p.\n", iface, shader);
Henri Verbeet's avatar
Henri Verbeet committed
2787

2788
    if (!shader)
2789
        return D3DERR_INVALIDCALL;
2790

2791
    wined3d_mutex_lock();
2792
    if ((object = wined3d_device_get_pixel_shader(device->wined3d_device)))
2793
    {
2794
        struct d3d8_pixel_shader *d3d8_shader;
2795
        d3d8_shader = wined3d_shader_get_parent(object);
2796
        *shader = d3d8_shader->handle;
2797 2798 2799
    }
    else
    {
2800
        *shader = 0;
2801
    }
2802
    wined3d_mutex_unlock();
2803

2804
    TRACE("Returning %#x.\n", *shader);
2805

2806
    return D3D_OK;
2807 2808
}

2809
static HRESULT WINAPI d3d8_device_DeletePixelShader(IDirect3DDevice8 *iface, DWORD shader)
2810
{
2811 2812
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
    struct d3d8_pixel_shader *shader_impl;
Raphael Junqueira's avatar
Raphael Junqueira committed
2813

2814
    TRACE("iface %p, shader %#x.\n", iface, shader);
2815

2816
    wined3d_mutex_lock();
2817

2818
    if (!(shader_impl = d3d8_free_handle(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS)))
2819
    {
2820
        WARN("Invalid handle (%#x) passed.\n", shader);
2821
        wined3d_mutex_unlock();
2822
        return D3DERR_INVALIDCALL;
2823
    }
2824

2825 2826
    if (wined3d_device_get_pixel_shader(device->wined3d_device) == shader_impl->wined3d_shader)
        IDirect3DDevice8_SetPixelShader(iface, 0);
2827

2828
    wined3d_mutex_unlock();
2829

2830
    d3d8_pixel_shader_destroy(shader_impl);
2831

Raphael Junqueira's avatar
Raphael Junqueira committed
2832
    return D3D_OK;
2833
}
Raphael Junqueira's avatar
Raphael Junqueira committed
2834

2835 2836
static HRESULT WINAPI d3d8_device_SetPixelShaderConstant(IDirect3DDevice8 *iface,
        DWORD start_register, const void *data, DWORD count)
2837
{
2838
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2839
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2840

2841 2842
    TRACE("iface %p, start_register %u, data %p, count %u.\n",
            iface, start_register, data, count);
2843

2844
    wined3d_mutex_lock();
2845
    hr = wined3d_device_set_ps_consts_f(device->wined3d_device, start_register, count, data);
2846 2847
    wined3d_mutex_unlock();

2848
    return hr;
2849
}
2850

2851 2852
static HRESULT WINAPI d3d8_device_GetPixelShaderConstant(IDirect3DDevice8 *iface,
        DWORD start_register, void *data, DWORD count)
2853
{
2854
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2855
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2856

2857 2858
    TRACE("iface %p, start_register %u, data %p, count %u.\n",
            iface, start_register, data, count);
2859

2860
    wined3d_mutex_lock();
2861
    hr = wined3d_device_get_ps_consts_f(device->wined3d_device, start_register, count, data);
2862 2863
    wined3d_mutex_unlock();

2864
    return hr;
2865
}
Raphael Junqueira's avatar
Raphael Junqueira committed
2866

2867 2868
static HRESULT WINAPI d3d8_device_GetPixelShaderFunction(IDirect3DDevice8 *iface,
        DWORD shader, void *data, DWORD *data_size)
2869
{
2870 2871
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
    struct d3d8_pixel_shader *shader_impl = NULL;
2872
    HRESULT hr;
2873

Henri Verbeet's avatar
Henri Verbeet committed
2874
    TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
2875
            iface, shader, data, data_size);
2876

2877
    wined3d_mutex_lock();
2878
    if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS)))
2879
    {
2880
        WARN("Invalid handle (%#x) passed.\n", shader);
2881 2882
        wined3d_mutex_unlock();

2883 2884 2885
        return D3DERR_INVALIDCALL;
    }

2886
    hr = wined3d_shader_get_byte_code(shader_impl->wined3d_shader, data, data_size);
2887 2888
    wined3d_mutex_unlock();

2889
    return hr;
2890
}
2891

2892 2893
static HRESULT WINAPI d3d8_device_DrawRectPatch(IDirect3DDevice8 *iface, UINT handle,
        const float *segment_count, const D3DRECTPATCH_INFO *patch_info)
2894
{
2895
    FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n",
2896
            iface, handle, segment_count, patch_info);
2897
    return D3D_OK;
2898
}
2899

2900 2901
static HRESULT WINAPI d3d8_device_DrawTriPatch(IDirect3DDevice8 *iface, UINT handle,
        const float *segment_count, const D3DTRIPATCH_INFO *patch_info)
2902
{
2903
    FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n",
2904
            iface, handle, segment_count, patch_info);
2905
    return D3D_OK;
2906
}
2907

2908
static HRESULT WINAPI d3d8_device_DeletePatch(IDirect3DDevice8 *iface, UINT handle)
2909
{
2910 2911
    FIXME("iface %p, handle %#x unimplemented.\n", iface, handle);
    return D3DERR_INVALIDCALL;
2912 2913
}

2914 2915
static HRESULT WINAPI d3d8_device_SetStreamSource(IDirect3DDevice8 *iface,
        UINT stream_idx, IDirect3DVertexBuffer8 *buffer, UINT stride)
2916
{
2917
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2918
    struct d3d8_vertexbuffer *buffer_impl = unsafe_impl_from_IDirect3DVertexBuffer8(buffer);
2919
    HRESULT hr;
Henri Verbeet's avatar
Henri Verbeet committed
2920 2921

    TRACE("iface %p, stream_idx %u, buffer %p, stride %u.\n",
2922
            iface, stream_idx, buffer, stride);
2923

2924
    wined3d_mutex_lock();
2925
    hr = wined3d_device_set_stream_source(device->wined3d_device, stream_idx,
2926
            buffer_impl ? buffer_impl->wined3d_buffer : NULL, 0, stride);
2927 2928
    wined3d_mutex_unlock();

2929
    return hr;
2930
}
2931

2932 2933
static HRESULT WINAPI d3d8_device_GetStreamSource(IDirect3DDevice8 *iface,
        UINT stream_idx, IDirect3DVertexBuffer8 **buffer, UINT *stride)
2934
{
2935
    struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
2936
    struct d3d8_vertexbuffer *buffer_impl;
2937
    struct wined3d_buffer *wined3d_buffer = NULL;
2938
    HRESULT hr;
2939

Henri Verbeet's avatar
Henri Verbeet committed
2940
    TRACE("iface %p, stream_idx %u, buffer %p, stride %p.\n",
2941
            iface, stream_idx, buffer, stride);
2942

2943
    if (!buffer)
2944
        return D3DERR_INVALIDCALL;
2945

2946
    wined3d_mutex_lock();
2947 2948
    hr = wined3d_device_get_stream_source(device->wined3d_device, stream_idx, &wined3d_buffer, 0, stride);
    if (SUCCEEDED(hr) && wined3d_buffer)
2949
    {
2950 2951 2952
        buffer_impl = wined3d_buffer_get_parent(wined3d_buffer);
        *buffer = &buffer_impl->IDirect3DVertexBuffer8_iface;
        IDirect3DVertexBuffer8_AddRef(*buffer);
2953 2954 2955
    }
    else
    {
2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063
        if (FAILED(hr))
            ERR("Failed to get wined3d stream source, hr %#x.\n", hr);
        *buffer = NULL;
    }
    wined3d_mutex_unlock();

    return hr;
}

static const struct IDirect3DDevice8Vtbl d3d8_device_vtbl =
{
    d3d8_device_QueryInterface,
    d3d8_device_AddRef,
    d3d8_device_Release,
    d3d8_device_TestCooperativeLevel,
    d3d8_device_GetAvailableTextureMem,
    d3d8_device_ResourceManagerDiscardBytes,
    d3d8_device_GetDirect3D,
    d3d8_device_GetDeviceCaps,
    d3d8_device_GetDisplayMode,
    d3d8_device_GetCreationParameters,
    d3d8_device_SetCursorProperties,
    d3d8_device_SetCursorPosition,
    d3d8_device_ShowCursor,
    d3d8_device_CreateAdditionalSwapChain,
    d3d8_device_Reset,
    d3d8_device_Present,
    d3d8_device_GetBackBuffer,
    d3d8_device_GetRasterStatus,
    d3d8_device_SetGammaRamp,
    d3d8_device_GetGammaRamp,
    d3d8_device_CreateTexture,
    d3d8_device_CreateVolumeTexture,
    d3d8_device_CreateCubeTexture,
    d3d8_device_CreateVertexBuffer,
    d3d8_device_CreateIndexBuffer,
    d3d8_device_CreateRenderTarget,
    d3d8_device_CreateDepthStencilSurface,
    d3d8_device_CreateImageSurface,
    d3d8_device_CopyRects,
    d3d8_device_UpdateTexture,
    d3d8_device_GetFrontBuffer,
    d3d8_device_SetRenderTarget,
    d3d8_device_GetRenderTarget,
    d3d8_device_GetDepthStencilSurface,
    d3d8_device_BeginScene,
    d3d8_device_EndScene,
    d3d8_device_Clear,
    d3d8_device_SetTransform,
    d3d8_device_GetTransform,
    d3d8_device_MultiplyTransform,
    d3d8_device_SetViewport,
    d3d8_device_GetViewport,
    d3d8_device_SetMaterial,
    d3d8_device_GetMaterial,
    d3d8_device_SetLight,
    d3d8_device_GetLight,
    d3d8_device_LightEnable,
    d3d8_device_GetLightEnable,
    d3d8_device_SetClipPlane,
    d3d8_device_GetClipPlane,
    d3d8_device_SetRenderState,
    d3d8_device_GetRenderState,
    d3d8_device_BeginStateBlock,
    d3d8_device_EndStateBlock,
    d3d8_device_ApplyStateBlock,
    d3d8_device_CaptureStateBlock,
    d3d8_device_DeleteStateBlock,
    d3d8_device_CreateStateBlock,
    d3d8_device_SetClipStatus,
    d3d8_device_GetClipStatus,
    d3d8_device_GetTexture,
    d3d8_device_SetTexture,
    d3d8_device_GetTextureStageState,
    d3d8_device_SetTextureStageState,
    d3d8_device_ValidateDevice,
    d3d8_device_GetInfo,
    d3d8_device_SetPaletteEntries,
    d3d8_device_GetPaletteEntries,
    d3d8_device_SetCurrentTexturePalette,
    d3d8_device_GetCurrentTexturePalette,
    d3d8_device_DrawPrimitive,
    d3d8_device_DrawIndexedPrimitive,
    d3d8_device_DrawPrimitiveUP,
    d3d8_device_DrawIndexedPrimitiveUP,
    d3d8_device_ProcessVertices,
    d3d8_device_CreateVertexShader,
    d3d8_device_SetVertexShader,
    d3d8_device_GetVertexShader,
    d3d8_device_DeleteVertexShader,
    d3d8_device_SetVertexShaderConstant,
    d3d8_device_GetVertexShaderConstant,
    d3d8_device_GetVertexShaderDeclaration,
    d3d8_device_GetVertexShaderFunction,
    d3d8_device_SetStreamSource,
    d3d8_device_GetStreamSource,
    d3d8_device_SetIndices,
    d3d8_device_GetIndices,
    d3d8_device_CreatePixelShader,
    d3d8_device_SetPixelShader,
    d3d8_device_GetPixelShader,
    d3d8_device_DeletePixelShader,
    d3d8_device_SetPixelShaderConstant,
    d3d8_device_GetPixelShaderConstant,
    d3d8_device_GetPixelShaderFunction,
    d3d8_device_DrawRectPatch,
    d3d8_device_DrawTriPatch,
    d3d8_device_DeletePatch,
3064
};
3065

3066
static inline struct d3d8_device *device_from_device_parent(struct wined3d_device_parent *device_parent)
3067
{
3068
    return CONTAINING_RECORD(device_parent, struct d3d8_device, device_parent);
3069 3070
}

3071
static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
3072
        struct wined3d_device *device)
3073
{
3074
    TRACE("device_parent %p, device %p\n", device_parent, device);
3075 3076
}

3077 3078 3079 3080 3081
static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
{
    TRACE("device_parent %p.\n", device_parent);
}

3082 3083
static void CDECL device_parent_activate(struct wined3d_device_parent *device_parent, BOOL activate)
{
3084 3085
    struct d3d8_device *device = device_from_device_parent(device_parent);

3086
    TRACE("device_parent %p, activate %#x.\n", device_parent, activate);
3087 3088 3089 3090 3091

    if (!activate)
        InterlockedCompareExchange(&device->device_state, D3D8_DEVICE_STATE_LOST, D3D8_DEVICE_STATE_OK);
    else
        InterlockedCompareExchange(&device->device_state, D3D8_DEVICE_STATE_NOT_RESET, D3D8_DEVICE_STATE_LOST);
3092 3093
}

3094
static HRESULT CDECL device_parent_surface_created(struct wined3d_device_parent *device_parent,
3095 3096
        struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,
        void **parent, const struct wined3d_parent_ops **parent_ops)
3097
{
3098
    struct d3d8_surface *d3d_surface;
3099

3100 3101
    TRACE("device_parent %p, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
            device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
3102

3103
    if (!(d3d_surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*d3d_surface))))
3104
        return E_OUTOFMEMORY;
3105

3106
    surface_init(d3d_surface, wined3d_texture, sub_resource_idx, parent_ops);
3107
    *parent = d3d_surface;
3108 3109
    TRACE("Created surface %p.\n", d3d_surface);

3110
    return D3D_OK;
3111 3112
}

3113
static HRESULT CDECL device_parent_volume_created(struct wined3d_device_parent *device_parent,
3114
        struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,
3115
        void **parent, const struct wined3d_parent_ops **parent_ops)
3116 3117 3118
{
    struct d3d8_volume *d3d_volume;

3119 3120
    TRACE("device_parent %p, texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
            device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
3121 3122 3123 3124

    if (!(d3d_volume = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*d3d_volume))))
        return E_OUTOFMEMORY;

3125
    volume_init(d3d_volume, wined3d_texture, sub_resource_idx, parent_ops);
3126 3127 3128 3129 3130 3131
    *parent = d3d_volume;
    TRACE("Created volume %p.\n", d3d_volume);

    return D3D_OK;
}

3132
static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_device_parent *device_parent,
3133 3134
        void *container_parent, const struct wined3d_resource_desc *desc, DWORD texture_flags,
        struct wined3d_texture **texture)
3135
{
3136
    struct d3d8_device *device = device_from_device_parent(device_parent);
3137
    struct d3d8_surface *d3d_surface;
3138 3139
    HRESULT hr;

3140 3141
    TRACE("device_parent %p, container_parent %p, desc %p, texture flags %#x, texture %p.\n",
            device_parent, container_parent, desc, texture_flags, texture);
3142

3143 3144 3145
    if (FAILED(hr = wined3d_texture_create(device->wined3d_device, desc, 1, 1,
            texture_flags | WINED3D_TEXTURE_CREATE_MAPPABLE,  NULL, &device->IDirect3DDevice8_iface,
            &d3d8_null_wined3d_parent_ops, texture)))
3146
    {
3147
        WARN("Failed to create texture, hr %#x.\n", hr);
3148 3149 3150
        return hr;
    }

3151
    d3d_surface = wined3d_texture_get_sub_resource_parent(*texture, 0);
3152
    d3d_surface->parent_device = &device->IDirect3DDevice8_iface;
3153 3154 3155 3156

    return hr;
}

3157
static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
3158
        struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
3159
{
3160
    struct d3d8_device *device = device_from_device_parent(device_parent);
3161
    struct d3d8_swapchain *d3d_swapchain;
3162 3163
    HRESULT hr;

3164
    TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
3165

3166
    if (FAILED(hr = d3d8_swapchain_create(device, desc, &d3d_swapchain)))
3167
    {
3168
        WARN("Failed to create swapchain, hr %#x.\n", hr);
3169 3170 3171 3172
        *swapchain = NULL;
        return hr;
    }

3173
    *swapchain = d3d_swapchain->wined3d_swapchain;
3174
    wined3d_swapchain_incref(*swapchain);
3175
    IDirect3DSwapChain8_Release(&d3d_swapchain->IDirect3DSwapChain8_iface);
3176 3177 3178 3179

    return hr;
}

3180
static const struct wined3d_device_parent_ops d3d8_wined3d_device_parent_ops =
3181
{
3182
    device_parent_wined3d_device_created,
3183
    device_parent_mode_changed,
3184
    device_parent_activate,
3185
    device_parent_surface_created,
3186
    device_parent_volume_created,
3187
    device_parent_create_swapchain_texture,
3188
    device_parent_create_swapchain,
3189
};
3190

3191 3192 3193
static void setup_fpu(void)
{
#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
3194
    WORD cw;
3195 3196 3197
    __asm__ volatile ("fnstcw %0" : "=m" (cw));
    cw = (cw & ~0xf3f) | 0x3f;
    __asm__ volatile ("fldcw %0" : : "m" (cw));
3198 3199 3200 3201 3202
#elif defined(__i386__) && defined(_MSC_VER)
    WORD cw;
    __asm fnstcw cw;
    cw = (cw & ~0xf3f) | 0x3f;
    __asm fldcw cw;
3203 3204 3205 3206 3207
#else
    FIXME("FPU setup not implemented for this platform.\n");
#endif
}

3208
HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wined3d *wined3d, UINT adapter,
3209 3210
        D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters)
{
3211
    struct wined3d_swapchain_desc swapchain_desc;
3212
    struct wined3d_swapchain *wined3d_swapchain;
3213 3214
    HRESULT hr;

3215
    device->IDirect3DDevice8_iface.lpVtbl = &d3d8_device_vtbl;
3216
    device->device_parent.ops = &d3d8_wined3d_device_parent_ops;
3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
    device->ref = 1;
    device->handle_table.entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
            D3D8_INITIAL_HANDLE_TABLE_SIZE * sizeof(*device->handle_table.entries));
    if (!device->handle_table.entries)
    {
        ERR("Failed to allocate handle table memory.\n");
        return E_OUTOFMEMORY;
    }
    device->handle_table.table_size = D3D8_INITIAL_HANDLE_TABLE_SIZE;

3227 3228
    if (!(flags & D3DCREATE_FPU_PRESERVE)) setup_fpu();

3229
    wined3d_mutex_lock();
3230
    hr = wined3d_device_create(wined3d, adapter, device_type, focus_window, flags, 4,
3231
            &device->device_parent, &device->wined3d_device);
3232 3233 3234 3235 3236 3237 3238 3239
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d device, hr %#x.\n", hr);
        wined3d_mutex_unlock();
        HeapFree(GetProcessHeap(), 0, device->handle_table.entries);
        return hr;
    }

3240 3241
    if (!parameters->Windowed)
    {
3242 3243
        HWND device_window = parameters->hDeviceWindow;

3244 3245 3246
        if (!focus_window)
            focus_window = device_window;
        if (FAILED(hr = wined3d_device_acquire_focus_window(device->wined3d_device, focus_window)))
3247 3248
        {
            ERR("Failed to acquire focus window, hr %#x.\n", hr);
3249
            wined3d_device_decref(device->wined3d_device);
3250 3251 3252 3253
            wined3d_mutex_unlock();
            HeapFree(GetProcessHeap(), 0, device->handle_table.entries);
            return hr;
        }
3254

3255 3256 3257
        if (!device_window)
            device_window = focus_window;
        wined3d_device_setup_fullscreen_window(device->wined3d_device, device_window,
3258 3259
                parameters->BackBufferWidth,
                parameters->BackBufferHeight);
3260 3261
    }

3262 3263
    if (flags & D3DCREATE_MULTITHREADED)
        wined3d_device_set_multithreaded(device->wined3d_device);
3264

3265 3266 3267 3268 3269 3270 3271 3272
    if (!wined3d_swapchain_desc_from_present_parameters(&swapchain_desc, parameters))
    {
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        HeapFree(GetProcessHeap(), 0, device->handle_table.entries);
        return D3DERR_INVALIDCALL;
    }
3273 3274

    hr = wined3d_device_init_3d(device->wined3d_device, &swapchain_desc);
3275 3276 3277
    if (FAILED(hr))
    {
        WARN("Failed to initialize 3D, hr %#x.\n", hr);
3278 3279
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
3280 3281 3282 3283 3284
        wined3d_mutex_unlock();
        HeapFree(GetProcessHeap(), 0, device->handle_table.entries);
        return hr;
    }

3285
    wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_POINTSIZE_MIN, 0);
3286 3287
    wined3d_mutex_unlock();

3288
    present_parameters_from_wined3d_swapchain_desc(parameters, &swapchain_desc);
3289 3290 3291 3292 3293

    device->declArraySize = 16;
    device->decls = HeapAlloc(GetProcessHeap(), 0, device->declArraySize * sizeof(*device->decls));
    if (!device->decls)
    {
3294
        ERR("Failed to allocate FVF vertex declaration map memory.\n");
3295 3296 3297 3298
        hr = E_OUTOFMEMORY;
        goto err;
    }

3299 3300 3301
    wined3d_swapchain = wined3d_device_get_swapchain(device->wined3d_device, 0);
    device->implicit_swapchain = wined3d_swapchain_get_parent(wined3d_swapchain);

3302 3303 3304
    device->d3d_parent = &parent->IDirect3D8_iface;
    IDirect3D8_AddRef(device->d3d_parent);

3305 3306 3307 3308
    return D3D_OK;

err:
    wined3d_mutex_lock();
3309 3310 3311
    wined3d_device_uninit_3d(device->wined3d_device);
    wined3d_device_release_focus_window(device->wined3d_device);
    wined3d_device_decref(device->wined3d_device);
3312 3313 3314 3315
    wined3d_mutex_unlock();
    HeapFree(GetProcessHeap(), 0, device->handle_table.entries);
    return hr;
}