dlls/d3drm/texture.c

   1 /*
   2  * Implementation of IDirect3DRMTextureX interfaces
   3  *
   4  * Copyright 2012 Christian Costa
   5  * Copyright 2016 Aaryaman Vasishta
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * 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 #include "d3drm_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  25
  26 static inline struct d3drm_texture *impl_from_IDirect3DRMTexture(IDirect3DRMTexture *iface)
  27 {
  28     return CONTAINING_RECORD(iface, struct d3drm_texture, IDirect3DRMTexture_iface);
  29 }
  30
  31 static inline struct d3drm_texture *impl_from_IDirect3DRMTexture2(IDirect3DRMTexture2 *iface)
  32 {
  33     return CONTAINING_RECORD(iface, struct d3drm_texture, IDirect3DRMTexture2_iface);
  34 }
  35
  36 static inline struct d3drm_texture *impl_from_IDirect3DRMTexture3(IDirect3DRMTexture3 *iface)
  37 {
  38     return CONTAINING_RECORD(iface, struct d3drm_texture, IDirect3DRMTexture3_iface);
  39 }
  40
  41 static void d3drm_texture_destroy(struct d3drm_texture *texture)
  42 {
  43     TRACE("texture %p is being destroyed.\n", texture);
  44
  45     d3drm_object_cleanup((IDirect3DRMObject*)&texture->IDirect3DRMTexture_iface, &texture->obj);
  46     if (texture->image || texture->surface)
  47         IDirect3DRM_Release(texture->d3drm);
  48     if (texture->surface)
  49         IDirectDrawSurface_Release(texture->surface);
  50     free(texture);
  51 }
  52
  53 static BOOL d3drm_validate_image(D3DRMIMAGE *image)
  54 {
  55     if (!image
  56             || !image->red_mask
  57             || !image->green_mask
  58             || !image->blue_mask
  59             || !image->buffer1
  60             || !(image->rgb || (image->palette && image->palette_size)))
  61     {
  62         return FALSE;
  63     }
  64
  65     return TRUE;
  66 }
  67
  68 static BOOL d3drm_image_palettise(D3DRMIMAGE *image, unsigned char *src_data,
  69         SIZE_T w, SIZE_T h, BOOL flip)
  70 {
  71     unsigned char *dst_data, *src_ptr, *dst_ptr;
  72     SIZE_T src_pitch, dst_pitch, i, x, y;
  73     D3DRMPALETTEENTRY *palette, *entry;
  74     unsigned int colour_count = 0;
  75
  76     if (w > (~(SIZE_T)0 - 3) / h)
  77         return FALSE;
  78
  79     src_pitch = flip ? -w * 3 : w * 3;
  80     dst_pitch = (w + 3) & ~3;
  81
  82     if (!(dst_data = malloc(dst_pitch * h)))
  83     {
  84         WARN("Failed to allocate image buffer.\n");
  85         return FALSE;
  86     }
  87     memset(dst_data, 0xff, dst_pitch * h);
  88
  89     if (!(palette = malloc(256 * sizeof(*palette))))
  90     {
  91         WARN("Failed to allocate palette.\n");
  92         free(dst_data);
  93         return FALSE;
  94     }
  95
  96     src_ptr = flip ? &src_data[(h - 1) * w * 3] : src_data;
  97     dst_ptr = dst_data;
  98
  99     for (y = 0; y < h; ++y)
 100     {
 101         for (x = 0; x < w; ++x)
 102         {
 103             for (i = 0; i < colour_count; ++i)
 104             {
 105                 entry = &palette[i];
 106                 if (entry->red == src_ptr[x * 3 + 2]
 107                         && entry->green == src_ptr[x * 3 + 1]
 108                         && entry->blue == src_ptr[x * 3 + 0])
 109                     break;
 110             }
 111
 112             if (i == colour_count)
 113             {
 114                 if (colour_count == 256)
 115                 {
 116                     free(dst_data);
 117                     free(palette);
 118                     return FALSE;
 119                 }
 120
 121                 entry = &palette[colour_count++];
 122                 entry->red = src_ptr[x * 3 + 2];
 123                 entry->green = src_ptr[x * 3 + 1];
 124                 entry->blue = src_ptr[x * 3 + 0];
 125                 entry->flags = D3DRMPALETTE_READONLY;
 126             }
 127
 128             dst_ptr[x] = i;
 129         }
 130
 131         src_ptr += src_pitch;
 132         dst_ptr += dst_pitch;
 133     }
 134
 135     image->depth = 8;
 136     image->rgb = 0;
 137     image->bytes_per_line = dst_pitch;
 138     image->buffer1 = dst_data;
 139     image->red_mask = 0xff;
 140     image->green_mask = 0xff;
 141     image->blue_mask = 0xff;
 142     image->palette_size = colour_count;
 143     if (!(image->palette = realloc(palette, colour_count * sizeof(*palette))))
 144         image->palette = palette;
 145
 146     return TRUE;
 147 }
 148
 149 static HRESULT d3drm_image_load_32(D3DRMIMAGE *image, unsigned char *src_data,
 150         LONGLONG src_data_size, SIZE_T w, SIZE_T h, BOOL flip)
 151 {
 152     unsigned char *dst_data, *src_ptr, *dst_ptr;
 153     SIZE_T src_pitch, dst_pitch, x, y;
 154
 155     if (d3drm_image_palettise(image, src_data, w, h, flip))
 156         return D3DRM_OK;
 157
 158     if (w > (~(SIZE_T)0 / 4) / h)
 159         return D3DRMERR_BADALLOC;
 160
 161     src_pitch = flip ? -w * 3 : w * 3;
 162     dst_pitch = w * 4;
 163
 164     if (!(dst_data = malloc(dst_pitch * h)))
 165     {
 166         WARN("Failed to allocate image buffer.\n");
 167         return D3DRMERR_BADALLOC;
 168     }
 169
 170     src_ptr = flip ? &src_data[(h - 1) * w * 3] : src_data;
 171     dst_ptr = dst_data;
 172
 173     for (y = 0; y < h; ++y)
 174     {
 175         for (x = 0; x < w; ++x)
 176         {
 177             dst_ptr[x * 4 + 0] = src_ptr[x * 3 + 0];
 178             dst_ptr[x * 4 + 1] = src_ptr[x * 3 + 1];
 179             dst_ptr[x * 4 + 2] = src_ptr[x * 3 + 2];
 180             dst_ptr[x * 4 + 3] = 0xff;
 181         }
 182
 183         src_ptr += src_pitch;
 184         dst_ptr += dst_pitch;
 185     }
 186
 187     image->depth = 32;
 188     image->rgb = 1;
 189     image->bytes_per_line = dst_pitch;
 190     image->buffer1 = dst_data;
 191     image->red_mask = 0xff0000;
 192     image->green_mask = 0x00ff00;
 193     image->blue_mask = 0x0000ff;
 194     image->palette_size = 0;
 195     image->palette = NULL;
 196
 197     return D3DRM_OK;
 198 }
 199
 200 static HRESULT d3drm_image_load_8(D3DRMIMAGE *image, const RGBQUAD *palette,
 201         unsigned char *src_data, LONGLONG src_data_size, SIZE_T w, SIZE_T h, BOOL flip)
 202 {
 203     unsigned char *dst_data;
 204     SIZE_T i;
 205
 206     if (w > ~(SIZE_T)0 / h)
 207         return D3DRMERR_BADALLOC;
 208
 209     if (!(dst_data = malloc(w * h)))
 210     {
 211         WARN("Failed to allocate image buffer.\n");
 212         return D3DRMERR_BADALLOC;
 213     }
 214
 215     if (!(image->palette = malloc(256 * sizeof(*image->palette))))
 216     {
 217         WARN("Failed to allocate palette.\n");
 218         free(dst_data);
 219         return D3DRMERR_BADALLOC;
 220     }
 221
 222     for (i = 0; i < 256; ++i)
 223     {
 224         image->palette[i].red = palette[i].rgbRed;
 225         image->palette[i].green = palette[i].rgbGreen;
 226         image->palette[i].blue = palette[i].rgbBlue;
 227         image->palette[i].flags = D3DRMPALETTE_READONLY;
 228     }
 229
 230     if (flip)
 231     {
 232         for (i = 0; i < h; ++i)
 233         {
 234             memcpy(&dst_data[i * w], &src_data[(h - 1 - i) * w], w);
 235         }
 236     }
 237     else
 238     {
 239         memcpy(dst_data, src_data, w * h);
 240     }
 241
 242     image->depth = 8;
 243     image->rgb = 0;
 244     image->bytes_per_line = w;
 245     image->buffer1 = dst_data;
 246     image->red_mask = 0xff;
 247     image->green_mask = 0xff;
 248     image->blue_mask = 0xff;
 249     image->palette_size = 256;
 250
 251     return D3DRM_OK;
 252 }
 253
 254 static void CDECL destroy_image_callback(IDirect3DRMObject *obj, void *arg)
 255 {
 256     D3DRMIMAGE *image = arg;
 257
 258     TRACE("texture object %p, image %p.\n", obj, image);
 259
 260     free(image->buffer1);
 261     free(image);
 262 }
 263
 264 static HRESULT d3drm_texture_load(struct d3drm_texture *texture,
 265         const char *path, BOOL flip, D3DRMIMAGE **image_out)
 266 {
 267     BITMAPFILEHEADER *header;
 268     unsigned int w, h, bpp;
 269     HANDLE file, mapping;
 270     LARGE_INTEGER size;
 271     D3DRMIMAGE *image;
 272     BITMAPINFO *info;
 273     LONGLONG rem;
 274     HRESULT hr;
 275
 276     if ((file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
 277         return D3DRMERR_BADOBJECT;
 278
 279     mapping = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL);
 280     CloseHandle(file);
 281     if (!mapping || mapping == INVALID_HANDLE_VALUE)
 282         return D3DRMERR_BADVALUE;
 283
 284     if (!GetFileSizeEx(mapping, &size))
 285     {
 286         CloseHandle(mapping);
 287         return D3DRMERR_BADVALUE;
 288     }
 289     rem = size.QuadPart;
 290
 291     header = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
 292     CloseHandle(mapping);
 293     if (!header)
 294         return D3DRMERR_BADVALUE;
 295
 296     hr = D3DRMERR_BADALLOC;
 297     if (!(image = calloc(1, sizeof(*image))))
 298         goto fail;
 299
 300     hr = D3DRMERR_BADFILE;
 301     if (rem < sizeof(*header) || header->bfType != 0x4d42 /* BM */)
 302         goto fail;
 303     rem -= sizeof(*header);
 304
 305     info = (BITMAPINFO *)&header[1];
 306     /* Only allow version 1 DIB's (BITMAPINFOHEADER) to be loaded. */
 307     if (rem < sizeof(info->bmiHeader) || info->bmiHeader.biSize != sizeof(info->bmiHeader))
 308         goto fail;
 309     rem -= sizeof(info->bmiHeader);
 310
 311     w = info->bmiHeader.biWidth;
 312     h = abs(info->bmiHeader.biHeight);
 313     bpp = info->bmiHeader.biBitCount == 24 ? 32 : info->bmiHeader.biBitCount;
 314     if (bpp != 8 && bpp != 32)
 315         goto fail;
 316
 317     image->width = w;
 318     image->height = h;
 319     image->aspectx = 1;
 320     image->aspecty = 1;
 321     if (bpp == 8)
 322     {
 323         rem -= 256 * sizeof(*info->bmiColors);
 324         if (w > rem / h)
 325             goto fail;
 326         hr = d3drm_image_load_8(image, info->bmiColors, (unsigned char *)&info->bmiColors[256], rem, w, h, flip);
 327     }
 328     else
 329     {
 330         if (w > (rem / 3) / h)
 331             goto fail;
 332         hr = d3drm_image_load_32(image, (unsigned char *)&info->bmiColors, rem, w, h, flip);
 333     }
 334     if (FAILED(hr))
 335         goto fail;
 336
 337     /* Use an internal destroy callback to destroy the image struct. */
 338     hr = IDirect3DRMObject_AddDestroyCallback(&texture->IDirect3DRMTexture3_iface, destroy_image_callback, image);
 339
 340     *image_out = image;
 341
 342     UnmapViewOfFile(header);
 343
 344     return hr;
 345
 346 fail:
 347     free(image);
 348     UnmapViewOfFile(header);
 349
 350     return hr;
 351 }
 352
 353 static HRESULT WINAPI d3drm_texture1_QueryInterface(IDirect3DRMTexture *iface, REFIID riid, void **out)
 354 {
 355     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 356
 357     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 358
 359     return IDirect3DRMTexture3_QueryInterface(&texture->IDirect3DRMTexture3_iface, riid, out);
 360 }
 361
 362 static ULONG WINAPI d3drm_texture1_AddRef(IDirect3DRMTexture *iface)
 363 {
 364     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 365
 366     TRACE("iface %p.\n", iface);
 367
 368     return IDirect3DRMTexture3_AddRef(&texture->IDirect3DRMTexture3_iface);
 369 }
 370
 371 static ULONG WINAPI d3drm_texture1_Release(IDirect3DRMTexture *iface)
 372 {
 373     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 374
 375     TRACE("iface %p.\n", iface);
 376
 377     return IDirect3DRMTexture3_Release(&texture->IDirect3DRMTexture3_iface);
 378 }
 379
 380 static HRESULT WINAPI d3drm_texture1_Clone(IDirect3DRMTexture *iface,
 381         IUnknown *outer, REFIID iid, void **out)
 382 {
 383     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 384
 385     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
 386
 387     return IDirect3DRMTexture3_Clone(&texture->IDirect3DRMTexture3_iface, outer, iid, out);
 388 }
 389
 390 static HRESULT WINAPI d3drm_texture1_AddDestroyCallback(IDirect3DRMTexture *iface,
 391         D3DRMOBJECTCALLBACK cb, void *ctx)
 392 {
 393     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 394
 395     TRACE("iface %p, cb %p, ctx %p\n", iface, cb, ctx);
 396
 397     return IDirect3DRMTexture3_AddDestroyCallback(&texture->IDirect3DRMTexture3_iface, cb, ctx);
 398 }
 399
 400 static HRESULT WINAPI d3drm_texture1_DeleteDestroyCallback(IDirect3DRMTexture *iface,
 401         D3DRMOBJECTCALLBACK cb, void *ctx)
 402 {
 403     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 404
 405     TRACE("iface %p, cb %p, ctx %p\n", iface, cb, ctx);
 406
 407     return IDirect3DRMTexture3_DeleteDestroyCallback(&texture->IDirect3DRMTexture3_iface, cb, ctx);
 408 }
 409
 410 static HRESULT WINAPI d3drm_texture1_SetAppData(IDirect3DRMTexture *iface, DWORD data)
 411 {
 412     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 413
 414     TRACE("iface %p, data %#lx.\n", iface, data);
 415
 416     return IDirect3DRMTexture3_SetAppData(&texture->IDirect3DRMTexture3_iface, data);
 417 }
 418
 419 static DWORD WINAPI d3drm_texture1_GetAppData(IDirect3DRMTexture *iface)
 420 {
 421     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 422
 423     TRACE("iface %p.\n", iface);
 424
 425     return IDirect3DRMTexture3_GetAppData(&texture->IDirect3DRMTexture3_iface);
 426 }
 427
 428 static HRESULT WINAPI d3drm_texture1_SetName(IDirect3DRMTexture *iface, const char *name)
 429 {
 430     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 431
 432     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 433
 434     return IDirect3DRMTexture3_SetName(&texture->IDirect3DRMTexture3_iface, name);
 435 }
 436
 437 static HRESULT WINAPI d3drm_texture1_GetName(IDirect3DRMTexture *iface, DWORD *size, char *name)
 438 {
 439     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 440
 441     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 442
 443     return IDirect3DRMTexture3_GetName(&texture->IDirect3DRMTexture3_iface, size, name);
 444 }
 445
 446 static HRESULT WINAPI d3drm_texture1_GetClassName(IDirect3DRMTexture *iface, DWORD *size, char *name)
 447 {
 448     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 449
 450     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 451
 452     return IDirect3DRMTexture3_GetClassName(&texture->IDirect3DRMTexture3_iface, size, name);
 453 }
 454
 455 static HRESULT WINAPI d3drm_texture1_InitFromFile(IDirect3DRMTexture *iface, const char *filename)
 456 {
 457     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 458     D3DRMIMAGE *image;
 459     HRESULT hr;
 460
 461     TRACE("iface %p, filename %s.\n", iface, debugstr_a(filename));
 462
 463     if (FAILED(hr = d3drm_texture_load(texture, filename, FALSE, &image)))
 464         return hr;
 465
 466     return IDirect3DRMTexture3_InitFromImage(&texture->IDirect3DRMTexture3_iface, image);
 467 }
 468
 469 static HRESULT WINAPI d3drm_texture1_InitFromSurface(IDirect3DRMTexture *iface,
 470         IDirectDrawSurface *surface)
 471 {
 472     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 473
 474     TRACE("iface %p, surface %p.\n", iface, surface);
 475
 476     return IDirect3DRMTexture3_InitFromSurface(&texture->IDirect3DRMTexture3_iface, surface);
 477 }
 478
 479 static HRESULT WINAPI d3drm_texture1_InitFromResource(IDirect3DRMTexture *iface, HRSRC resource)
 480 {
 481     FIXME("iface %p, resource %p stub!\n", iface, resource);
 482
 483     return E_NOTIMPL;
 484 }
 485
 486 static HRESULT WINAPI d3drm_texture1_Changed(IDirect3DRMTexture *iface, BOOL pixels, BOOL palette)
 487 {
 488     FIXME("iface %p, pixels %#x, palette %#x stub!\n", iface, pixels, palette);
 489
 490     return E_NOTIMPL;
 491 }
 492
 493 static HRESULT WINAPI d3drm_texture1_SetColors(IDirect3DRMTexture *iface, DWORD max_colors)
 494 {
 495     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 496
 497     TRACE("iface %p, max_colors %lu.\n", iface, max_colors);
 498
 499     return IDirect3DRMTexture3_SetColors(&texture->IDirect3DRMTexture3_iface, max_colors);
 500 }
 501
 502 static HRESULT WINAPI d3drm_texture1_SetShades(IDirect3DRMTexture *iface, DWORD max_shades)
 503 {
 504     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 505
 506     TRACE("iface %p, max_shades %lu.\n", iface, max_shades);
 507
 508     return IDirect3DRMTexture3_SetShades(&texture->IDirect3DRMTexture3_iface, max_shades);
 509 }
 510
 511 static HRESULT WINAPI d3drm_texture1_SetDecalSize(IDirect3DRMTexture *iface, D3DVALUE width, D3DVALUE height)
 512 {
 513     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 514
 515     TRACE("iface %p, width %.8e, height %.8e.\n", iface, width, height);
 516
 517     return IDirect3DRMTexture3_SetDecalSize(&texture->IDirect3DRMTexture3_iface, width, height);
 518 }
 519
 520 static HRESULT WINAPI d3drm_texture1_SetDecalOrigin(IDirect3DRMTexture *iface, LONG x, LONG y)
 521 {
 522     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 523
 524     TRACE("iface %p, x %ld, y %ld.\n", iface, x, y);
 525
 526     return IDirect3DRMTexture3_SetDecalOrigin(&texture->IDirect3DRMTexture3_iface, x, y);
 527 }
 528
 529 static HRESULT WINAPI d3drm_texture1_SetDecalScale(IDirect3DRMTexture *iface, DWORD scale)
 530 {
 531     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 532
 533     TRACE("iface %p, scale %lu.\n", iface, scale);
 534
 535     return IDirect3DRMTexture3_SetDecalScale(&texture->IDirect3DRMTexture3_iface, scale);
 536 }
 537
 538 static HRESULT WINAPI d3drm_texture1_SetDecalTransparency(IDirect3DRMTexture *iface, BOOL transparency)
 539 {
 540     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 541
 542     TRACE("iface %p, transparency %#x.\n", iface, transparency);
 543
 544     return IDirect3DRMTexture3_SetDecalTransparency(&texture->IDirect3DRMTexture3_iface, transparency);
 545 }
 546
 547 static HRESULT WINAPI d3drm_texture1_SetDecalTransparentColor(IDirect3DRMTexture *iface, D3DCOLOR color)
 548 {
 549     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 550
 551     TRACE("iface %p, color 0x%08lx.\n", iface, color);
 552
 553     return IDirect3DRMTexture3_SetDecalTransparentColor(&texture->IDirect3DRMTexture3_iface, color);
 554 }
 555
 556 static HRESULT WINAPI d3drm_texture1_GetDecalSize(IDirect3DRMTexture *iface, D3DVALUE *width, D3DVALUE *height)
 557 {
 558     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 559
 560     TRACE("iface %p, width %p, height %p.\n", iface, width, height);
 561
 562     return IDirect3DRMTexture3_GetDecalSize(&texture->IDirect3DRMTexture3_iface, width, height);
 563 }
 564
 565 static HRESULT WINAPI d3drm_texture1_GetDecalOrigin(IDirect3DRMTexture *iface, LONG *x, LONG *y)
 566 {
 567     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 568
 569     TRACE("iface %p, x %p, y %p.\n", iface, x, y);
 570
 571     return IDirect3DRMTexture3_GetDecalOrigin(&texture->IDirect3DRMTexture3_iface, x, y);
 572 }
 573
 574 static D3DRMIMAGE * WINAPI d3drm_texture1_GetImage(IDirect3DRMTexture *iface)
 575 {
 576     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 577
 578     TRACE("iface %p.\n", iface);
 579
 580     return IDirect3DRMTexture3_GetImage(&texture->IDirect3DRMTexture3_iface);
 581 }
 582
 583 static DWORD WINAPI d3drm_texture1_GetShades(IDirect3DRMTexture *iface)
 584 {
 585     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 586
 587     TRACE("iface %p.\n", iface);
 588
 589     return IDirect3DRMTexture3_GetShades(&texture->IDirect3DRMTexture3_iface);
 590 }
 591
 592 static DWORD WINAPI d3drm_texture1_GetColors(IDirect3DRMTexture *iface)
 593 {
 594     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 595
 596     TRACE("iface %p.\n", iface);
 597
 598     return IDirect3DRMTexture3_GetColors(&texture->IDirect3DRMTexture3_iface);
 599 }
 600
 601 static DWORD WINAPI d3drm_texture1_GetDecalScale(IDirect3DRMTexture *iface)
 602 {
 603     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 604
 605     TRACE("iface %p.\n", iface);
 606
 607     return IDirect3DRMTexture3_GetDecalScale(&texture->IDirect3DRMTexture3_iface);
 608 }
 609
 610 static BOOL WINAPI d3drm_texture1_GetDecalTransparency(IDirect3DRMTexture *iface)
 611 {
 612     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 613
 614     TRACE("iface %p.\n", iface);
 615
 616     return IDirect3DRMTexture3_GetDecalTransparency(&texture->IDirect3DRMTexture3_iface);
 617 }
 618
 619 static D3DCOLOR WINAPI d3drm_texture1_GetDecalTransparentColor(IDirect3DRMTexture *iface)
 620 {
 621     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture(iface);
 622
 623     TRACE("iface %p.\n", iface);
 624
 625     return IDirect3DRMTexture3_GetDecalTransparentColor(&texture->IDirect3DRMTexture3_iface);
 626 }
 627
 628 static const struct IDirect3DRMTextureVtbl d3drm_texture1_vtbl =
 629 {
 630     d3drm_texture1_QueryInterface,
 631     d3drm_texture1_AddRef,
 632     d3drm_texture1_Release,
 633     d3drm_texture1_Clone,
 634     d3drm_texture1_AddDestroyCallback,
 635     d3drm_texture1_DeleteDestroyCallback,
 636     d3drm_texture1_SetAppData,
 637     d3drm_texture1_GetAppData,
 638     d3drm_texture1_SetName,
 639     d3drm_texture1_GetName,
 640     d3drm_texture1_GetClassName,
 641     d3drm_texture1_InitFromFile,
 642     d3drm_texture1_InitFromSurface,
 643     d3drm_texture1_InitFromResource,
 644     d3drm_texture1_Changed,
 645     d3drm_texture1_SetColors,
 646     d3drm_texture1_SetShades,
 647     d3drm_texture1_SetDecalSize,
 648     d3drm_texture1_SetDecalOrigin,
 649     d3drm_texture1_SetDecalScale,
 650     d3drm_texture1_SetDecalTransparency,
 651     d3drm_texture1_SetDecalTransparentColor,
 652     d3drm_texture1_GetDecalSize,
 653     d3drm_texture1_GetDecalOrigin,
 654     d3drm_texture1_GetImage,
 655     d3drm_texture1_GetShades,
 656     d3drm_texture1_GetColors,
 657     d3drm_texture1_GetDecalScale,
 658     d3drm_texture1_GetDecalTransparency,
 659     d3drm_texture1_GetDecalTransparentColor,
 660 };
 661
 662 static HRESULT WINAPI d3drm_texture2_QueryInterface(IDirect3DRMTexture2 *iface, REFIID riid, void **out)
 663 {
 664     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 665
 666     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 667
 668     return IDirect3DRMTexture3_QueryInterface(&texture->IDirect3DRMTexture3_iface, riid, out);
 669 }
 670
 671 static ULONG WINAPI d3drm_texture2_AddRef(IDirect3DRMTexture2 *iface)
 672 {
 673     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 674
 675     TRACE("iface %p.\n", iface);
 676
 677     return IDirect3DRMTexture3_AddRef(&texture->IDirect3DRMTexture3_iface);
 678 }
 679
 680 static ULONG WINAPI d3drm_texture2_Release(IDirect3DRMTexture2 *iface)
 681 {
 682     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 683
 684     TRACE("iface %p.\n", iface);
 685
 686     return IDirect3DRMTexture3_Release(&texture->IDirect3DRMTexture3_iface);
 687 }
 688
 689 static HRESULT WINAPI d3drm_texture2_Clone(IDirect3DRMTexture2 *iface,
 690         IUnknown *outer, REFIID iid, void **out)
 691 {
 692     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 693
 694     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
 695
 696     return IDirect3DRMTexture3_Clone(&texture->IDirect3DRMTexture3_iface, outer, iid, out);
 697 }
 698
 699 static HRESULT WINAPI d3drm_texture2_AddDestroyCallback(IDirect3DRMTexture2 *iface,
 700         D3DRMOBJECTCALLBACK cb, void *ctx)
 701 {
 702     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 703
 704     TRACE("iface %p, cb %p, ctx %p\n", iface, cb, ctx);
 705
 706     return IDirect3DRMTexture3_AddDestroyCallback(&texture->IDirect3DRMTexture3_iface, cb, ctx);
 707 }
 708
 709 static HRESULT WINAPI d3drm_texture2_DeleteDestroyCallback(IDirect3DRMTexture2 *iface,
 710         D3DRMOBJECTCALLBACK cb, void *ctx)
 711 {
 712     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 713
 714     TRACE("iface %p, cb %p, ctx %p\n", iface, cb, ctx);
 715
 716     return IDirect3DRMTexture3_DeleteDestroyCallback(&texture->IDirect3DRMTexture3_iface, cb, ctx);
 717 }
 718
 719 static HRESULT WINAPI d3drm_texture2_SetAppData(IDirect3DRMTexture2 *iface, DWORD data)
 720 {
 721     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 722
 723     TRACE("iface %p, data %#lx.\n", iface, data);
 724
 725     return IDirect3DRMTexture3_SetAppData(&texture->IDirect3DRMTexture3_iface, data);
 726 }
 727
 728 static DWORD WINAPI d3drm_texture2_GetAppData(IDirect3DRMTexture2 *iface)
 729 {
 730     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 731
 732     TRACE("iface %p.\n", iface);
 733
 734     return IDirect3DRMTexture3_GetAppData(&texture->IDirect3DRMTexture3_iface);
 735 }
 736
 737 static HRESULT WINAPI d3drm_texture2_SetName(IDirect3DRMTexture2 *iface, const char *name)
 738 {
 739     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 740
 741     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 742
 743     return IDirect3DRMTexture3_SetName(&texture->IDirect3DRMTexture3_iface, name);
 744 }
 745
 746 static HRESULT WINAPI d3drm_texture2_GetName(IDirect3DRMTexture2 *iface, DWORD *size, char *name)
 747 {
 748     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 749
 750     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 751
 752     return IDirect3DRMTexture3_GetName(&texture->IDirect3DRMTexture3_iface, size, name);
 753 }
 754
 755 static HRESULT WINAPI d3drm_texture2_GetClassName(IDirect3DRMTexture2 *iface, DWORD *size, char *name)
 756 {
 757     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 758
 759     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 760
 761     return IDirect3DRMTexture3_GetClassName(&texture->IDirect3DRMTexture3_iface, size, name);
 762 }
 763
 764 static HRESULT WINAPI d3drm_texture2_InitFromFile(IDirect3DRMTexture2 *iface, const char *filename)
 765 {
 766     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 767
 768     TRACE("iface %p, filename %s.\n", iface, debugstr_a(filename));
 769
 770     return IDirect3DRMTexture3_InitFromFile(&texture->IDirect3DRMTexture3_iface, filename);
 771 }
 772
 773 static HRESULT WINAPI d3drm_texture2_InitFromSurface(IDirect3DRMTexture2 *iface,
 774         IDirectDrawSurface *surface)
 775 {
 776     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 777
 778     TRACE("iface %p, surface %p.\n", iface, surface);
 779
 780     return IDirect3DRMTexture3_InitFromSurface(&texture->IDirect3DRMTexture3_iface, surface);
 781 }
 782
 783 static HRESULT WINAPI d3drm_texture2_InitFromResource(IDirect3DRMTexture2 *iface, HRSRC resource)
 784 {
 785     FIXME("iface %p, resource %p stub!\n", iface, resource);
 786
 787     return E_NOTIMPL;
 788 }
 789
 790 static HRESULT WINAPI d3drm_texture2_Changed(IDirect3DRMTexture2 *iface, BOOL pixels, BOOL palette)
 791 {
 792     FIXME("iface %p, pixels %#x, palette %#x stub!\n", iface, pixels, palette);
 793
 794     return E_NOTIMPL;
 795 }
 796
 797 static HRESULT WINAPI d3drm_texture2_SetColors(IDirect3DRMTexture2 *iface, DWORD max_colors)
 798 {
 799     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 800
 801     TRACE("iface %p, max_colors %lu.\n", iface, max_colors);
 802
 803     return IDirect3DRMTexture3_SetColors(&texture->IDirect3DRMTexture3_iface, max_colors);
 804 }
 805
 806 static HRESULT WINAPI d3drm_texture2_SetShades(IDirect3DRMTexture2 *iface, DWORD max_shades)
 807 {
 808     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 809
 810     TRACE("iface %p, max_shades %lu.\n", iface, max_shades);
 811
 812     return IDirect3DRMTexture3_SetShades(&texture->IDirect3DRMTexture3_iface, max_shades);
 813 }
 814
 815 static HRESULT WINAPI d3drm_texture2_SetDecalSize(IDirect3DRMTexture2 *iface, D3DVALUE width, D3DVALUE height)
 816 {
 817     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 818
 819     TRACE("iface %p, width %.8e, height %.8e.\n", iface, width, height);
 820
 821     return IDirect3DRMTexture3_SetDecalSize(&texture->IDirect3DRMTexture3_iface, width, height);
 822 }
 823
 824 static HRESULT WINAPI d3drm_texture2_SetDecalOrigin(IDirect3DRMTexture2 *iface, LONG x, LONG y)
 825 {
 826     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 827
 828     TRACE("iface %p, x %ld, y %ld.\n", iface, x, y);
 829
 830     return IDirect3DRMTexture3_SetDecalOrigin(&texture->IDirect3DRMTexture3_iface, x, y);
 831 }
 832
 833 static HRESULT WINAPI d3drm_texture2_SetDecalScale(IDirect3DRMTexture2 *iface, DWORD scale)
 834 {
 835     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 836
 837     TRACE("iface %p, scale %lu.\n", iface, scale);
 838
 839     return IDirect3DRMTexture3_SetDecalScale(&texture->IDirect3DRMTexture3_iface, scale);
 840 }
 841
 842 static HRESULT WINAPI d3drm_texture2_SetDecalTransparency(IDirect3DRMTexture2 *iface, BOOL transparency)
 843 {
 844     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 845
 846     TRACE("iface %p, transparency %#x.\n", iface, transparency);
 847
 848     return IDirect3DRMTexture3_SetDecalTransparency(&texture->IDirect3DRMTexture3_iface, transparency);
 849 }
 850
 851 static HRESULT WINAPI d3drm_texture2_SetDecalTransparentColor(IDirect3DRMTexture2 *iface, D3DCOLOR color)
 852 {
 853     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 854
 855     TRACE("iface %p, color 0x%08lx.\n", iface, color);
 856
 857     return IDirect3DRMTexture3_SetDecalTransparentColor(&texture->IDirect3DRMTexture3_iface, color);
 858 }
 859
 860 static HRESULT WINAPI d3drm_texture2_GetDecalSize(IDirect3DRMTexture2 *iface, D3DVALUE *width, D3DVALUE *height)
 861 {
 862     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 863
 864     TRACE("iface %p, width %p, height %p.\n", iface, width, height);
 865
 866     return IDirect3DRMTexture3_GetDecalSize(&texture->IDirect3DRMTexture3_iface, width, height);
 867 }
 868
 869 static HRESULT WINAPI d3drm_texture2_GetDecalOrigin(IDirect3DRMTexture2 *iface, LONG *x, LONG *y)
 870 {
 871     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 872
 873     TRACE("iface %p, x %p, y %p.\n", iface, x, y);
 874
 875     return IDirect3DRMTexture3_GetDecalOrigin(&texture->IDirect3DRMTexture3_iface, x, y);
 876 }
 877
 878 static D3DRMIMAGE * WINAPI d3drm_texture2_GetImage(IDirect3DRMTexture2 *iface)
 879 {
 880     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 881
 882     TRACE("iface %p.\n", iface);
 883
 884     return IDirect3DRMTexture3_GetImage(&texture->IDirect3DRMTexture3_iface);
 885 }
 886
 887 static DWORD WINAPI d3drm_texture2_GetShades(IDirect3DRMTexture2 *iface)
 888 {
 889     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 890
 891     TRACE("iface %p.\n", iface);
 892
 893     return IDirect3DRMTexture3_GetShades(&texture->IDirect3DRMTexture3_iface);
 894 }
 895
 896 static DWORD WINAPI d3drm_texture2_GetColors(IDirect3DRMTexture2 *iface)
 897 {
 898     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 899
 900     TRACE("iface %p.\n", iface);
 901
 902     return IDirect3DRMTexture3_GetColors(&texture->IDirect3DRMTexture3_iface);
 903 }
 904
 905 static DWORD WINAPI d3drm_texture2_GetDecalScale(IDirect3DRMTexture2 *iface)
 906 {
 907     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 908
 909     TRACE("iface %p.\n", iface);
 910
 911     return IDirect3DRMTexture3_GetDecalScale(&texture->IDirect3DRMTexture3_iface);
 912 }
 913
 914 static BOOL WINAPI d3drm_texture2_GetDecalTransparency(IDirect3DRMTexture2 *iface)
 915 {
 916     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 917
 918     TRACE("iface %p.\n", iface);
 919
 920     return IDirect3DRMTexture3_GetDecalTransparency(&texture->IDirect3DRMTexture3_iface);
 921 }
 922
 923 static D3DCOLOR WINAPI d3drm_texture2_GetDecalTransparentColor(IDirect3DRMTexture2 *iface)
 924 {
 925     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 926
 927     TRACE("iface %p.\n", iface);
 928
 929     return IDirect3DRMTexture3_GetDecalTransparentColor(&texture->IDirect3DRMTexture3_iface);
 930 }
 931
 932 static HRESULT WINAPI d3drm_texture2_InitFromImage(IDirect3DRMTexture2 *iface, D3DRMIMAGE *image)
 933 {
 934     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 935
 936     TRACE("iface %p, image %p.\n", iface, image);
 937
 938     return IDirect3DRMTexture3_InitFromImage(&texture->IDirect3DRMTexture3_iface, image);
 939 }
 940
 941 static HRESULT WINAPI d3drm_texture2_InitFromResource2(IDirect3DRMTexture2 *iface,
 942         HMODULE module, const char *name, const char *type)
 943 {
 944     FIXME("iface %p, module %p, name %s, type %s stub!\n",
 945             iface, module, debugstr_a(name), debugstr_a(type));
 946
 947     return E_NOTIMPL;
 948 }
 949
 950 static HRESULT WINAPI d3drm_texture2_GenerateMIPMap(IDirect3DRMTexture2 *iface, DWORD flags)
 951 {
 952     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
 953
 954     TRACE("iface %p, flags %#lx.\n", iface, flags);
 955
 956     return IDirect3DRMTexture3_GenerateMIPMap(&texture->IDirect3DRMTexture3_iface, flags);
 957 }
 958
 959 static const struct IDirect3DRMTexture2Vtbl d3drm_texture2_vtbl =
 960 {
 961     d3drm_texture2_QueryInterface,
 962     d3drm_texture2_AddRef,
 963     d3drm_texture2_Release,
 964     d3drm_texture2_Clone,
 965     d3drm_texture2_AddDestroyCallback,
 966     d3drm_texture2_DeleteDestroyCallback,
 967     d3drm_texture2_SetAppData,
 968     d3drm_texture2_GetAppData,
 969     d3drm_texture2_SetName,
 970     d3drm_texture2_GetName,
 971     d3drm_texture2_GetClassName,
 972     d3drm_texture2_InitFromFile,
 973     d3drm_texture2_InitFromSurface,
 974     d3drm_texture2_InitFromResource,
 975     d3drm_texture2_Changed,
 976     d3drm_texture2_SetColors,
 977     d3drm_texture2_SetShades,
 978     d3drm_texture2_SetDecalSize,
 979     d3drm_texture2_SetDecalOrigin,
 980     d3drm_texture2_SetDecalScale,
 981     d3drm_texture2_SetDecalTransparency,
 982     d3drm_texture2_SetDecalTransparentColor,
 983     d3drm_texture2_GetDecalSize,
 984     d3drm_texture2_GetDecalOrigin,
 985     d3drm_texture2_GetImage,
 986     d3drm_texture2_GetShades,
 987     d3drm_texture2_GetColors,
 988     d3drm_texture2_GetDecalScale,
 989     d3drm_texture2_GetDecalTransparency,
 990     d3drm_texture2_GetDecalTransparentColor,
 991     d3drm_texture2_InitFromImage,
 992     d3drm_texture2_InitFromResource2,
 993     d3drm_texture2_GenerateMIPMap,
 994 };
 995
 996 static HRESULT WINAPI d3drm_texture3_QueryInterface(IDirect3DRMTexture3 *iface, REFIID riid, void **out)
 997 {
 998     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
 999
1000     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
1001
1002     if (IsEqualGUID(riid, &IID_IDirect3DRMTexture)
1003             || IsEqualGUID(riid, &IID_IDirect3DRMVisual)
1004             || IsEqualGUID(riid, &IID_IDirect3DRMObject)
1005             || IsEqualGUID(riid, &IID_IUnknown))
1006     {
1007         *out = &texture->IDirect3DRMTexture_iface;
1008     }
1009     else if (IsEqualGUID(riid, &IID_IDirect3DRMTexture2))
1010     {
1011         *out = &texture->IDirect3DRMTexture2_iface;
1012     }
1013     else if (IsEqualGUID(riid, &IID_IDirect3DRMTexture3))
1014     {
1015         *out = &texture->IDirect3DRMTexture3_iface;
1016     }
1017     else
1018     {
1019         *out = NULL;
1020         WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
1021         return CLASS_E_CLASSNOTAVAILABLE;
1022     }
1023
1024     IUnknown_AddRef((IUnknown *)*out);
1025     return S_OK;
1026 }
1027
1028 static ULONG WINAPI d3drm_texture3_AddRef(IDirect3DRMTexture3 *iface)
1029 {
1030     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1031     ULONG refcount = InterlockedIncrement(&texture->obj.ref);
1032
1033     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
1034
1035     return refcount;
1036 }
1037
1038 static ULONG WINAPI d3drm_texture3_Release(IDirect3DRMTexture3 *iface)
1039 {
1040     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1041     ULONG refcount = InterlockedDecrement(&texture->obj.ref);
1042
1043     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
1044
1045     if (!refcount)
1046         d3drm_texture_destroy(texture);
1047
1048     return refcount;
1049 }
1050
1051 static HRESULT WINAPI d3drm_texture3_Clone(IDirect3DRMTexture3 *iface,
1052         IUnknown *outer, REFIID iid, void **out)
1053 {
1054     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
1055
1056     return E_NOTIMPL;
1057 }
1058
1059 static HRESULT WINAPI d3drm_texture3_AddDestroyCallback(IDirect3DRMTexture3 *iface,
1060         D3DRMOBJECTCALLBACK cb, void *ctx)
1061 {
1062     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1063
1064     TRACE("iface %p, cb %p, ctx %p\n", iface, cb, ctx);
1065
1066     return d3drm_object_add_destroy_callback(&texture->obj, cb, ctx);
1067 }
1068
1069 static HRESULT WINAPI d3drm_texture3_DeleteDestroyCallback(IDirect3DRMTexture3 *iface,
1070         D3DRMOBJECTCALLBACK cb, void *ctx)
1071 {
1072     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1073
1074     TRACE("iface %p, cb %p, ctx %p\n", iface, cb, ctx);
1075
1076     return d3drm_object_delete_destroy_callback(&texture->obj, cb, ctx);
1077 }
1078
1079 static HRESULT WINAPI d3drm_texture3_SetAppData(IDirect3DRMTexture3 *iface, DWORD data)
1080 {
1081     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1082
1083     TRACE("iface %p, data %#lx.\n", iface, data);
1084
1085     texture->obj.appdata = data;
1086
1087     return D3DRM_OK;
1088 }
1089
1090 static DWORD WINAPI d3drm_texture3_GetAppData(IDirect3DRMTexture3 *iface)
1091 {
1092     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1093
1094     TRACE("iface %p.\n", iface);
1095
1096     return texture->obj.appdata;
1097 }
1098
1099 static HRESULT WINAPI d3drm_texture3_SetName(IDirect3DRMTexture3 *iface, const char *name)
1100 {
1101     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1102
1103     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1104
1105     return d3drm_object_set_name(&texture->obj, name);
1106 }
1107
1108 static HRESULT WINAPI d3drm_texture3_GetName(IDirect3DRMTexture3 *iface, DWORD *size, char *name)
1109 {
1110     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1111
1112     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
1113
1114     return d3drm_object_get_name(&texture->obj, size, name);
1115 }
1116
1117 static HRESULT WINAPI d3drm_texture3_GetClassName(IDirect3DRMTexture3 *iface, DWORD *size, char *name)
1118 {
1119     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1120
1121     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
1122
1123     return d3drm_object_get_class_name(&texture->obj, size, name);
1124 }
1125
1126 static HRESULT WINAPI d3drm_texture3_InitFromFile(IDirect3DRMTexture3 *iface, const char *filename)
1127 {
1128     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1129     D3DRMIMAGE *image;
1130     HRESULT hr;
1131
1132     TRACE("iface %p, filename %s.\n", iface, debugstr_a(filename));
1133
1134     if (FAILED(hr = d3drm_texture_load(texture, filename, TRUE, &image)))
1135         return hr;
1136
1137     return IDirect3DRMTexture3_InitFromImage(iface, image);
1138 }
1139
1140 static HRESULT WINAPI d3drm_texture3_InitFromSurface(IDirect3DRMTexture3 *iface,
1141         IDirectDrawSurface *surface)
1142 {
1143     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1144
1145     TRACE("iface %p, surface %p.\n", iface, surface);
1146
1147     if (!surface)
1148         return D3DRMERR_BADOBJECT;
1149
1150     /* d3drm intentionally leaks a reference to IDirect3DRM here if texture has already been initialized. */
1151     IDirect3DRM_AddRef(texture->d3drm);
1152
1153     if (texture->image || texture->surface)
1154         return D3DRMERR_BADOBJECT;
1155
1156     texture->surface = surface;
1157     IDirectDrawSurface_AddRef(texture->surface);
1158     return D3DRM_OK;
1159 }
1160
1161 static HRESULT WINAPI d3drm_texture3_InitFromResource(IDirect3DRMTexture3 *iface, HRSRC resource)
1162 {
1163     FIXME("iface %p, resource %p stub!\n", iface, resource);
1164
1165     return E_NOTIMPL;
1166 }
1167
1168 static HRESULT WINAPI d3drm_texture3_Changed(IDirect3DRMTexture3 *iface,
1169         DWORD flags, DWORD rect_count, RECT *rects)
1170 {
1171     FIXME("iface %p, flags %#lx, rect_count %lu, rects %p stub!\n", iface, flags, rect_count, rects);
1172
1173     return E_NOTIMPL;
1174 }
1175
1176 static HRESULT WINAPI d3drm_texture3_SetColors(IDirect3DRMTexture3 *iface, DWORD max_colors)
1177 {
1178     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1179     TRACE("iface %p, max_colors %lu\n", iface, max_colors);
1180
1181     texture->max_colors= max_colors;
1182
1183     return S_OK;
1184 }
1185
1186 static HRESULT WINAPI d3drm_texture3_SetShades(IDirect3DRMTexture3 *iface, DWORD max_shades)
1187 {
1188     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1189     TRACE("iface %p, max_shades %lu\n", iface, max_shades);
1190
1191     texture->max_shades = max_shades;
1192
1193     return S_OK;
1194 }
1195
1196 static HRESULT WINAPI d3drm_texture3_SetDecalSize(IDirect3DRMTexture3 *iface, D3DVALUE width, D3DVALUE height)
1197 {
1198     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1199
1200     TRACE("iface %p, width %.8e, height %.8e.\n", iface, width, height);
1201
1202     texture->decal_width = width;
1203     texture->decal_height = height;
1204
1205     return S_OK;
1206 }
1207
1208 static HRESULT WINAPI d3drm_texture3_SetDecalOrigin(IDirect3DRMTexture3 *iface, LONG x, LONG y)
1209 {
1210     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1211
1212     TRACE("iface %p, x %ld, y %ld\n", iface, x, y);
1213
1214     texture->decal_x = x;
1215     texture->decal_y = y;
1216
1217     return S_OK;
1218 }
1219
1220 static HRESULT WINAPI d3drm_texture3_SetDecalScale(IDirect3DRMTexture3 *iface, DWORD scale)
1221 {
1222     FIXME("iface %p, scale %lu stub!\n", iface, scale);
1223
1224     return E_NOTIMPL;
1225 }
1226
1227 static HRESULT WINAPI d3drm_texture3_SetDecalTransparency(IDirect3DRMTexture3 *iface, BOOL transparency)
1228 {
1229     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1230
1231     TRACE("iface %p, transparency %#x.\n", iface, transparency);
1232
1233     texture->transparency = transparency;
1234
1235     return S_OK;
1236 }
1237
1238 static HRESULT WINAPI d3drm_texture3_SetDecalTransparentColor(IDirect3DRMTexture3 *iface, D3DCOLOR color)
1239 {
1240     FIXME("iface %p, color 0x%08lx stub!\n", iface, color);
1241
1242     return E_NOTIMPL;
1243 }
1244
1245 static HRESULT WINAPI d3drm_texture3_GetDecalSize(IDirect3DRMTexture3 *iface, D3DVALUE *width, D3DVALUE *height)
1246 {
1247     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1248
1249     TRACE("iface %p, width %p, height %p.\n", iface, width, height);
1250
1251     *width = texture->decal_width;
1252     *height = texture->decal_height;
1253
1254     return S_OK;
1255 }
1256
1257 static HRESULT WINAPI d3drm_texture3_GetDecalOrigin(IDirect3DRMTexture3 *iface, LONG *x, LONG *y)
1258 {
1259     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1260
1261     TRACE("iface %p, x %p, y %p\n", iface, x, y);
1262
1263     *x = texture->decal_x;
1264     *y = texture->decal_y;
1265
1266     return S_OK;
1267 }
1268
1269 static D3DRMIMAGE * WINAPI d3drm_texture3_GetImage(IDirect3DRMTexture3 *iface)
1270 {
1271     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1272
1273     TRACE("iface %p.\n", iface);
1274
1275     return texture->image;
1276 }
1277
1278 static DWORD WINAPI d3drm_texture3_GetShades(IDirect3DRMTexture3 *iface)
1279 {
1280     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1281     TRACE("iface %p\n", iface);
1282     return texture->max_shades;
1283 }
1284
1285 static DWORD WINAPI d3drm_texture3_GetColors(IDirect3DRMTexture3 *iface)
1286 {
1287     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1288     TRACE("iface %p\n", iface);
1289     return texture->max_colors;
1290 }
1291
1292 static DWORD WINAPI d3drm_texture3_GetDecalScale(IDirect3DRMTexture3 *iface)
1293 {
1294     FIXME("iface %p stub!\n", iface);
1295
1296     return 0;
1297 }
1298
1299 static BOOL WINAPI d3drm_texture3_GetDecalTransparency(IDirect3DRMTexture3 *iface)
1300 {
1301     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1302
1303     TRACE("iface %p.\n", iface);
1304
1305     return texture->transparency;
1306 }
1307
1308 static D3DCOLOR WINAPI d3drm_texture3_GetDecalTransparentColor(IDirect3DRMTexture3 *iface)
1309 {
1310     FIXME("iface %p stub!\n", iface);
1311
1312     return 0;
1313 }
1314
1315 static HRESULT WINAPI d3drm_texture3_InitFromImage(IDirect3DRMTexture3 *iface, D3DRMIMAGE *image)
1316 {
1317     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1318
1319     TRACE("iface %p, image %p.\n", iface, image);
1320
1321     if (!d3drm_validate_image(image))
1322         return D3DRMERR_BADOBJECT;
1323
1324     /* d3drm intentionally leaks a reference to IDirect3DRM here if texture has already been initialized. */
1325     IDirect3DRM_AddRef(texture->d3drm);
1326
1327     if (texture->image || texture->surface)
1328         return D3DRMERR_BADOBJECT;
1329
1330     texture->image = image;
1331
1332     return D3DRM_OK;
1333 }
1334
1335 static HRESULT WINAPI d3drm_texture3_InitFromResource2(IDirect3DRMTexture3 *iface,
1336         HMODULE module, const char *name, const char *type)
1337 {
1338     FIXME("iface %p, module %p, name %s, type %s stub!\n",
1339             iface, module, debugstr_a(name), debugstr_a(type));
1340
1341     return E_NOTIMPL;
1342 }
1343
1344 static HRESULT WINAPI d3drm_texture3_GenerateMIPMap(IDirect3DRMTexture3 *iface, DWORD flags)
1345 {
1346     FIXME("iface %p, flags %#lx stub!\n", iface, flags);
1347
1348     return E_NOTIMPL;
1349 }
1350
1351 static HRESULT WINAPI d3drm_texture3_GetSurface(IDirect3DRMTexture3 *iface,
1352         DWORD flags, IDirectDrawSurface **surface)
1353 {
1354     struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
1355
1356     TRACE("iface %p, flags %#lx, surface %p.\n", iface, flags, surface);
1357
1358     if (flags)
1359         FIXME("unexpected flags %#lx.\n", flags);
1360
1361     if (!surface)
1362         return D3DRMERR_BADVALUE;
1363
1364     if (texture->image)
1365         return D3DRMERR_NOTCREATEDFROMDDS;
1366
1367     *surface = texture->surface;
1368     IDirectDrawSurface_AddRef(*surface);
1369
1370     return D3DRM_OK;
1371 }
1372
1373 static HRESULT WINAPI d3drm_texture3_SetCacheOptions(IDirect3DRMTexture3 *iface, LONG importance, DWORD flags)
1374 {
1375     FIXME("iface %p, importance %ld, flags %#lx stub!\n", iface, importance, flags);
1376
1377     return E_NOTIMPL;
1378 }
1379
1380 static HRESULT WINAPI d3drm_texture3_GetCacheOptions(IDirect3DRMTexture3 *iface,
1381         LONG *importance, DWORD *flags)
1382 {
1383     FIXME("iface %p, importance %p, flags %p stub!\n", iface, importance, flags);
1384
1385     return E_NOTIMPL;
1386 }
1387
1388 static HRESULT WINAPI d3drm_texture3_SetDownsampleCallback(IDirect3DRMTexture3 *iface,
1389         D3DRMDOWNSAMPLECALLBACK cb, void *ctx)
1390 {
1391     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1392
1393     return E_NOTIMPL;
1394 }
1395
1396 static HRESULT WINAPI d3drm_texture3_SetValidationCallback(IDirect3DRMTexture3 *iface,
1397         D3DRMVALIDATIONCALLBACK cb, void *ctx)
1398 {
1399     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1400
1401     return E_NOTIMPL;
1402 }
1403
1404 static const struct IDirect3DRMTexture3Vtbl d3drm_texture3_vtbl =
1405 {
1406     d3drm_texture3_QueryInterface,
1407     d3drm_texture3_AddRef,
1408     d3drm_texture3_Release,
1409     d3drm_texture3_Clone,
1410     d3drm_texture3_AddDestroyCallback,
1411     d3drm_texture3_DeleteDestroyCallback,
1412     d3drm_texture3_SetAppData,
1413     d3drm_texture3_GetAppData,
1414     d3drm_texture3_SetName,
1415     d3drm_texture3_GetName,
1416     d3drm_texture3_GetClassName,
1417     d3drm_texture3_InitFromFile,
1418     d3drm_texture3_InitFromSurface,
1419     d3drm_texture3_InitFromResource,
1420     d3drm_texture3_Changed,
1421     d3drm_texture3_SetColors,
1422     d3drm_texture3_SetShades,
1423     d3drm_texture3_SetDecalSize,
1424     d3drm_texture3_SetDecalOrigin,
1425     d3drm_texture3_SetDecalScale,
1426     d3drm_texture3_SetDecalTransparency,
1427     d3drm_texture3_SetDecalTransparentColor,
1428     d3drm_texture3_GetDecalSize,
1429     d3drm_texture3_GetDecalOrigin,
1430     d3drm_texture3_GetImage,
1431     d3drm_texture3_GetShades,
1432     d3drm_texture3_GetColors,
1433     d3drm_texture3_GetDecalScale,
1434     d3drm_texture3_GetDecalTransparency,
1435     d3drm_texture3_GetDecalTransparentColor,
1436     d3drm_texture3_InitFromImage,
1437     d3drm_texture3_InitFromResource2,
1438     d3drm_texture3_GenerateMIPMap,
1439     d3drm_texture3_GetSurface,
1440     d3drm_texture3_SetCacheOptions,
1441     d3drm_texture3_GetCacheOptions,
1442     d3drm_texture3_SetDownsampleCallback,
1443     d3drm_texture3_SetValidationCallback,
1444 };
1445
1446 HRESULT d3drm_texture_create(struct d3drm_texture **texture, IDirect3DRM *d3drm)
1447 {
1448     static const char classname[] = "Texture";
1449     struct d3drm_texture *object;
1450
1451     TRACE("texture %p.\n", texture);
1452
1453     if (!(object = calloc(1, sizeof(*object))))
1454         return E_OUTOFMEMORY;
1455
1456     object->IDirect3DRMTexture_iface.lpVtbl = &d3drm_texture1_vtbl;
1457     object->IDirect3DRMTexture2_iface.lpVtbl = &d3drm_texture2_vtbl;
1458     object->IDirect3DRMTexture3_iface.lpVtbl = &d3drm_texture3_vtbl;
1459     object->d3drm = d3drm;
1460     object->max_colors = 8;
1461     object->max_shades = 16;
1462     object->transparency = FALSE;
1463     object->decal_width = 1.0f;
1464     object->decal_height = 1.0f;
1465
1466     d3drm_object_init(&object->obj, classname);
1467
1468     *texture = object;
1469
1470     return D3DRM_OK;
1471 }