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