1 /* 2 * Copyright 2009 Tony Wasserka 3 * Copyright 2010 Christian Costa 4 * Copyright 2010 Owen Rudge for CodeWeavers 5 * Copyright 2010 Matteo Bruni for CodeWeavers 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 "config.h" 23 #include "wine/port.h" 24 25 #include "d3dx9_private.h" 26 27 WINE_DEFAULT_DEBUG_CHANNEL(d3dx); 28 29 /* Returns TRUE if num is a power of 2, FALSE if not, or if 0 */ 30 static BOOL is_pow2(UINT num) 31 { 32 return !(num & (num - 1)); 33 } 34 35 /* Returns the smallest power of 2 which is greater than or equal to num */ 36 static UINT make_pow2(UINT num) 37 { 38 UINT result = 1; 39 40 /* In the unlikely event somebody passes a large value, make sure we don't enter an infinite loop */ 41 if (num >= 0x80000000) 42 return 0x80000000; 43 44 while (result < num) 45 result <<= 1; 46 47 return result; 48 } 49 50 static HRESULT get_surface(D3DRESOURCETYPE type, struct IDirect3DBaseTexture9 *tex, 51 int face, UINT level, struct IDirect3DSurface9 **surf) 52 { 53 switch (type) 54 { 55 case D3DRTYPE_TEXTURE: 56 return IDirect3DTexture9_GetSurfaceLevel((IDirect3DTexture9*) tex, level, surf); 57 case D3DRTYPE_CUBETEXTURE: 58 return IDirect3DCubeTexture9_GetCubeMapSurface((IDirect3DCubeTexture9*) tex, face, level, surf); 59 default: 60 ERR("Unexpected texture type\n"); 61 return E_NOTIMPL; 62 } 63 } 64 65 HRESULT WINAPI D3DXFilterTexture(IDirect3DBaseTexture9 *texture, 66 const PALETTEENTRY *palette, 67 UINT srclevel, 68 DWORD filter) 69 { 70 UINT level; 71 HRESULT hr; 72 D3DRESOURCETYPE type; 73 74 TRACE("(%p, %p, %u, %#x)\n", texture, palette, srclevel, filter); 75 76 if (!texture) 77 return D3DERR_INVALIDCALL; 78 79 if ((filter & 0xFFFF) > D3DX_FILTER_BOX && filter != D3DX_DEFAULT) 80 return D3DERR_INVALIDCALL; 81 82 if (srclevel == D3DX_DEFAULT) 83 srclevel = 0; 84 else if (srclevel >= IDirect3DBaseTexture9_GetLevelCount(texture)) 85 return D3DERR_INVALIDCALL; 86 87 switch (type = IDirect3DBaseTexture9_GetType(texture)) 88 { 89 case D3DRTYPE_TEXTURE: 90 case D3DRTYPE_CUBETEXTURE: 91 { 92 IDirect3DSurface9 *topsurf, *mipsurf; 93 D3DSURFACE_DESC desc; 94 int i, numfaces; 95 96 if (type == D3DRTYPE_TEXTURE) 97 { 98 numfaces = 1; 99 IDirect3DTexture9_GetLevelDesc((IDirect3DTexture9*) texture, srclevel, &desc); 100 } 101 else 102 { 103 numfaces = 6; 104 IDirect3DCubeTexture9_GetLevelDesc((IDirect3DTexture9*) texture, srclevel, &desc); 105 } 106 107 if (filter == D3DX_DEFAULT) 108 { 109 if (is_pow2(desc.Width) && is_pow2(desc.Height)) 110 filter = D3DX_FILTER_BOX; 111 else 112 filter = D3DX_FILTER_BOX | D3DX_FILTER_DITHER; 113 } 114 115 for (i = 0; i < numfaces; i++) 116 { 117 level = srclevel + 1; 118 hr = get_surface(type, texture, i, srclevel, &topsurf); 119 120 if (FAILED(hr)) 121 return D3DERR_INVALIDCALL; 122 123 while (get_surface(type, texture, i, level, &mipsurf) == D3D_OK) 124 { 125 hr = D3DXLoadSurfaceFromSurface(mipsurf, palette, NULL, topsurf, palette, NULL, filter, 0); 126 IDirect3DSurface9_Release(topsurf); 127 topsurf = mipsurf; 128 129 if (FAILED(hr)) 130 break; 131 132 level++; 133 } 134 135 IDirect3DSurface9_Release(topsurf); 136 if (FAILED(hr)) 137 return hr; 138 } 139 140 return D3D_OK; 141 } 142 143 case D3DRTYPE_VOLUMETEXTURE: 144 { 145 D3DVOLUME_DESC desc; 146 int level, level_count; 147 IDirect3DVolume9 *top_volume, *mip_volume; 148 IDirect3DVolumeTexture9 *volume_texture = (IDirect3DVolumeTexture9*) texture; 149 150 IDirect3DVolumeTexture9_GetLevelDesc(volume_texture, srclevel, &desc); 151 152 if (filter == D3DX_DEFAULT) 153 { 154 if (is_pow2(desc.Width) && is_pow2(desc.Height) && is_pow2(desc.Depth)) 155 filter = D3DX_FILTER_BOX; 156 else 157 filter = D3DX_FILTER_BOX | D3DX_FILTER_DITHER; 158 } 159 160 hr = IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, srclevel, &top_volume); 161 if (FAILED(hr)) 162 return hr; 163 164 level_count = IDirect3DVolumeTexture9_GetLevelCount(volume_texture); 165 for (level = srclevel + 1; level < level_count; level++) 166 { 167 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, level, &mip_volume); 168 hr = D3DXLoadVolumeFromVolume(mip_volume, palette, NULL, top_volume, palette, NULL, filter, 0); 169 IDirect3DVolume9_Release(top_volume); 170 top_volume = mip_volume; 171 172 if (FAILED(hr)) 173 break; 174 } 175 176 IDirect3DVolume9_Release(top_volume); 177 if (FAILED(hr)) 178 return hr; 179 180 return D3D_OK; 181 } 182 183 default: 184 return D3DERR_INVALIDCALL; 185 } 186 } 187 188 static D3DFORMAT get_luminance_replacement_format(D3DFORMAT format) 189 { 190 static const struct 191 { 192 D3DFORMAT luminance_format; 193 D3DFORMAT replacement_format; 194 } luminance_replacements[] = 195 { 196 {D3DFMT_L8, D3DFMT_X8R8G8B8}, 197 {D3DFMT_A8L8, D3DFMT_A8R8G8B8}, 198 {D3DFMT_A4L4, D3DFMT_A4R4G4B4}, 199 {D3DFMT_L16, D3DFMT_A16B16G16R16} 200 }; 201 unsigned int i; 202 203 for (i = 0; i < ARRAY_SIZE(luminance_replacements); ++i) 204 if (format == luminance_replacements[i].luminance_format) 205 return luminance_replacements[i].replacement_format; 206 return format; 207 } 208 209 HRESULT WINAPI D3DXCheckTextureRequirements(struct IDirect3DDevice9 *device, UINT *width, UINT *height, 210 UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool) 211 { 212 UINT w = (width && *width) ? *width : 1; 213 UINT h = (height && *height) ? *height : 1; 214 D3DCAPS9 caps; 215 D3DDEVICE_CREATION_PARAMETERS params; 216 IDirect3D9 *d3d = NULL; 217 D3DDISPLAYMODE mode; 218 HRESULT hr; 219 D3DFORMAT usedformat = D3DFMT_UNKNOWN; 220 const struct pixel_format_desc *fmt; 221 222 TRACE("(%p, %p, %p, %p, %u, %p, %u)\n", device, width, height, miplevels, usage, format, pool); 223 224 if (!device) 225 return D3DERR_INVALIDCALL; 226 227 /* usage */ 228 if (usage == D3DX_DEFAULT) 229 usage = 0; 230 if (usage & (D3DUSAGE_WRITEONLY | D3DUSAGE_DONOTCLIP | D3DUSAGE_POINTS | D3DUSAGE_RTPATCHES | D3DUSAGE_NPATCHES)) 231 return D3DERR_INVALIDCALL; 232 233 /* pool */ 234 if ((pool != D3DPOOL_DEFAULT) && (pool != D3DPOOL_MANAGED) && (pool != D3DPOOL_SYSTEMMEM) && (pool != D3DPOOL_SCRATCH)) 235 return D3DERR_INVALIDCALL; 236 237 /* format */ 238 if (format) 239 { 240 TRACE("Requested format %x\n", *format); 241 usedformat = *format; 242 } 243 244 hr = IDirect3DDevice9_GetDirect3D(device, &d3d); 245 246 if (FAILED(hr)) 247 goto cleanup; 248 249 hr = IDirect3DDevice9_GetCreationParameters(device, ¶ms); 250 251 if (FAILED(hr)) 252 goto cleanup; 253 254 hr = IDirect3DDevice9_GetDisplayMode(device, 0, &mode); 255 256 if (FAILED(hr)) 257 goto cleanup; 258 259 if ((usedformat == D3DFMT_UNKNOWN) || (usedformat == D3DX_DEFAULT)) 260 usedformat = D3DFMT_A8R8G8B8; 261 262 fmt = get_format_info(usedformat); 263 264 hr = IDirect3D9_CheckDeviceFormat(d3d, params.AdapterOrdinal, params.DeviceType, mode.Format, 265 usage, D3DRTYPE_TEXTURE, usedformat); 266 if (FAILED(hr)) 267 { 268 BOOL allow_24bits; 269 int bestscore = INT_MIN, i = 0, j; 270 unsigned int channels; 271 const struct pixel_format_desc *curfmt, *bestfmt = NULL; 272 273 TRACE("Requested format is not supported, looking for a fallback.\n"); 274 275 if (!fmt) 276 { 277 FIXME("Pixel format %x not handled\n", usedformat); 278 goto cleanup; 279 } 280 fmt = get_format_info(get_luminance_replacement_format(usedformat)); 281 282 allow_24bits = fmt->bytes_per_pixel == 3; 283 channels = !!fmt->bits[0] + !!fmt->bits[1] + !!fmt->bits[2] + !!fmt->bits[3]; 284 usedformat = D3DFMT_UNKNOWN; 285 286 while ((curfmt = get_format_info_idx(i))) 287 { 288 unsigned int curchannels = !!curfmt->bits[0] + !!curfmt->bits[1] 289 + !!curfmt->bits[2] + !!curfmt->bits[3]; 290 int score; 291 292 i++; 293 294 if (curchannels < channels) 295 continue; 296 if (curfmt->bytes_per_pixel == 3 && !allow_24bits) 297 continue; 298 299 hr = IDirect3D9_CheckDeviceFormat(d3d, params.AdapterOrdinal, params.DeviceType, 300 mode.Format, usage, D3DRTYPE_TEXTURE, curfmt->format); 301 if (FAILED(hr)) 302 continue; 303 304 /* This format can be used, let's evaluate it. 305 Weights chosen quite arbitrarily... */ 306 score = 512 * (curfmt->type == fmt->type); 307 score -= 32 * (curchannels - channels); 308 309 for (j = 0; j < 4; j++) 310 { 311 int diff = curfmt->bits[j] - fmt->bits[j]; 312 score -= (diff < 0 ? -diff * 8 : diff) * (j == 0 ? 1 : 2); 313 } 314 315 if (score > bestscore) 316 { 317 bestscore = score; 318 usedformat = curfmt->format; 319 bestfmt = curfmt; 320 } 321 } 322 fmt = bestfmt; 323 hr = D3D_OK; 324 } 325 326 if (FAILED(IDirect3DDevice9_GetDeviceCaps(device, &caps))) 327 return D3DERR_INVALIDCALL; 328 329 if ((w == D3DX_DEFAULT) && (h == D3DX_DEFAULT)) 330 w = h = 256; 331 else if (w == D3DX_DEFAULT) 332 w = (height ? h : 256); 333 else if (h == D3DX_DEFAULT) 334 h = (width ? w : 256); 335 336 if (fmt->block_width != 1 || fmt->block_height != 1) 337 { 338 if (w % fmt->block_width) 339 w += fmt->block_width - w % fmt->block_width; 340 if (h % fmt->block_height) 341 h += fmt->block_height - h % fmt->block_height; 342 } 343 344 if ((caps.TextureCaps & D3DPTEXTURECAPS_POW2) && (!is_pow2(w))) 345 w = make_pow2(w); 346 347 if (w > caps.MaxTextureWidth) 348 w = caps.MaxTextureWidth; 349 350 if ((caps.TextureCaps & D3DPTEXTURECAPS_POW2) && (!is_pow2(h))) 351 h = make_pow2(h); 352 353 if (h > caps.MaxTextureHeight) 354 h = caps.MaxTextureHeight; 355 356 if (caps.TextureCaps & D3DPTEXTURECAPS_SQUAREONLY) 357 { 358 if (w > h) 359 h = w; 360 else 361 w = h; 362 } 363 364 if (width) 365 *width = w; 366 367 if (height) 368 *height = h; 369 370 if (miplevels && (usage & D3DUSAGE_AUTOGENMIPMAP)) 371 { 372 if (*miplevels > 1) 373 *miplevels = 0; 374 } 375 else if (miplevels) 376 { 377 UINT max_mipmaps = 1; 378 379 if (!width && !height) 380 max_mipmaps = 9; /* number of mipmaps in a 256x256 texture */ 381 else 382 { 383 UINT max_dimen = max(w, h); 384 385 while (max_dimen > 1) 386 { 387 max_dimen >>= 1; 388 max_mipmaps++; 389 } 390 } 391 392 if (*miplevels == 0 || *miplevels > max_mipmaps) 393 *miplevels = max_mipmaps; 394 } 395 396 cleanup: 397 398 if (d3d) 399 IDirect3D9_Release(d3d); 400 401 if (FAILED(hr)) 402 return hr; 403 404 if (usedformat == D3DFMT_UNKNOWN) 405 { 406 WARN("Couldn't find a suitable pixel format\n"); 407 return D3DERR_NOTAVAILABLE; 408 } 409 410 TRACE("Format chosen: %x\n", usedformat); 411 if (format) 412 *format = usedformat; 413 414 return D3D_OK; 415 } 416 417 HRESULT WINAPI D3DXCheckCubeTextureRequirements(struct IDirect3DDevice9 *device, UINT *size, 418 UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool) 419 { 420 D3DCAPS9 caps; 421 UINT s = (size && *size) ? *size : 256; 422 HRESULT hr; 423 424 TRACE("(%p, %p, %p, %u, %p, %u)\n", device, size, miplevels, usage, format, pool); 425 426 if (s == D3DX_DEFAULT) 427 s = 256; 428 429 if (!device || FAILED(IDirect3DDevice9_GetDeviceCaps(device, &caps))) 430 return D3DERR_INVALIDCALL; 431 432 if (!(caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)) 433 return D3DERR_NOTAVAILABLE; 434 435 /* ensure width/height is power of 2 */ 436 if ((caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2) && (!is_pow2(s))) 437 s = make_pow2(s); 438 439 hr = D3DXCheckTextureRequirements(device, &s, &s, miplevels, usage, format, pool); 440 441 if (!(caps.TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP)) 442 { 443 if(miplevels) 444 *miplevels = 1; 445 } 446 447 if (size) 448 *size = s; 449 450 return hr; 451 } 452 453 HRESULT WINAPI D3DXCheckVolumeTextureRequirements(struct IDirect3DDevice9 *device, UINT *width, UINT *height, 454 UINT *depth, UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool) 455 { 456 D3DCAPS9 caps; 457 UINT w = width ? *width : D3DX_DEFAULT; 458 UINT h = height ? *height : D3DX_DEFAULT; 459 UINT d = (depth && *depth) ? *depth : 1; 460 HRESULT hr; 461 462 TRACE("(%p, %p, %p, %p, %p, %u, %p, %u)\n", device, width, height, depth, miplevels, 463 usage, format, pool); 464 465 if (!device || FAILED(IDirect3DDevice9_GetDeviceCaps(device, &caps))) 466 return D3DERR_INVALIDCALL; 467 468 if (!(caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)) 469 return D3DERR_NOTAVAILABLE; 470 471 hr = D3DXCheckTextureRequirements(device, &w, &h, NULL, usage, format, pool); 472 if (d == D3DX_DEFAULT) 473 d = 1; 474 475 /* ensure width/height is power of 2 */ 476 if ((caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP_POW2) && 477 (!is_pow2(w) || !is_pow2(h) || !is_pow2(d))) 478 { 479 w = make_pow2(w); 480 h = make_pow2(h); 481 d = make_pow2(d); 482 } 483 484 if (w > caps.MaxVolumeExtent) 485 w = caps.MaxVolumeExtent; 486 if (h > caps.MaxVolumeExtent) 487 h = caps.MaxVolumeExtent; 488 if (d > caps.MaxVolumeExtent) 489 d = caps.MaxVolumeExtent; 490 491 if (miplevels) 492 { 493 if (!(caps.TextureCaps & D3DPTEXTURECAPS_MIPVOLUMEMAP)) 494 *miplevels = 1; 495 else if ((usage & D3DUSAGE_AUTOGENMIPMAP)) 496 { 497 if (*miplevels > 1) 498 *miplevels = 0; 499 } 500 else 501 { 502 UINT max_mipmaps = 1; 503 UINT max_dimen = max(max(w, h), d); 504 505 while (max_dimen > 1) 506 { 507 max_dimen >>= 1; 508 max_mipmaps++; 509 } 510 511 if (*miplevels == 0 || *miplevels > max_mipmaps) 512 *miplevels = max_mipmaps; 513 } 514 } 515 516 if (width) 517 *width = w; 518 if (height) 519 *height = h; 520 if (depth) 521 *depth = d; 522 523 return hr; 524 } 525 526 HRESULT WINAPI D3DXCreateTexture(struct IDirect3DDevice9 *device, UINT width, UINT height, 527 UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DTexture9 **texture) 528 { 529 HRESULT hr; 530 531 TRACE("device %p, width %u, height %u, miplevels %u, usage %#x, format %#x, pool %#x, texture %p.\n", 532 device, width, height, miplevels, usage, format, pool, texture); 533 534 if (!device || !texture) 535 return D3DERR_INVALIDCALL; 536 537 if (FAILED(hr = D3DXCheckTextureRequirements(device, &width, &height, &miplevels, usage, &format, pool))) 538 return hr; 539 540 return IDirect3DDevice9_CreateTexture(device, width, height, miplevels, usage, format, pool, texture, NULL); 541 } 542 543 static D3DFORMAT get_alpha_replacement_format(D3DFORMAT format) 544 { 545 static const struct 546 { 547 D3DFORMAT orig_format; 548 D3DFORMAT replacement_format; 549 } 550 replacement_formats[] = 551 { 552 {D3DFMT_X8R8G8B8, D3DFMT_A8R8G8B8}, 553 {D3DFMT_X1R5G5B5, D3DFMT_A1R5G5B5}, 554 {D3DFMT_X4R4G4B4, D3DFMT_A4R4G4B4}, 555 {D3DFMT_X8B8G8R8, D3DFMT_A8B8G8R8}, 556 {D3DFMT_L8, D3DFMT_A8L8}, 557 }; 558 unsigned int i; 559 560 for (i = 0; i < ARRAY_SIZE(replacement_formats); ++i) 561 if (replacement_formats[i].orig_format == format) 562 return replacement_formats[i].replacement_format; 563 return format; 564 } 565 566 HRESULT WINAPI D3DXCreateTextureFromFileInMemoryEx(struct IDirect3DDevice9 *device, const void *srcdata, 567 UINT srcdatasize, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, 568 D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, 569 PALETTEENTRY *palette, struct IDirect3DTexture9 **texture) 570 { 571 IDirect3DTexture9 **texptr; 572 IDirect3DTexture9 *buftex; 573 IDirect3DSurface9 *surface; 574 BOOL dynamic_texture, format_specified = FALSE; 575 D3DXIMAGE_INFO imginfo; 576 UINT loaded_miplevels, skip_levels; 577 D3DCAPS9 caps; 578 HRESULT hr; 579 580 TRACE("device %p, srcdata %p, srcdatasize %u, width %u, height %u, miplevels %u," 581 " usage %#x, format %#x, pool %#x, filter %#x, mipfilter %#x, colorkey %#x," 582 " srcinfo %p, palette %p, texture %p.\n", 583 device, srcdata, srcdatasize, width, height, miplevels, usage, format, pool, 584 filter, mipfilter, colorkey, srcinfo, palette, texture); 585 586 /* check for invalid parameters */ 587 if (!device || !texture || !srcdata || !srcdatasize) 588 return D3DERR_INVALIDCALL; 589 590 hr = D3DXGetImageInfoFromFileInMemory(srcdata, srcdatasize, &imginfo); 591 if (FAILED(hr)) 592 { 593 FIXME("Unrecognized file format, returning failure.\n"); 594 *texture = NULL; 595 return hr; 596 } 597 598 /* handle default values */ 599 if (width == 0 || width == D3DX_DEFAULT_NONPOW2) 600 width = imginfo.Width; 601 602 if (height == 0 || height == D3DX_DEFAULT_NONPOW2) 603 height = imginfo.Height; 604 605 if (width == D3DX_DEFAULT) 606 width = make_pow2(imginfo.Width); 607 608 if (height == D3DX_DEFAULT) 609 height = make_pow2(imginfo.Height); 610 611 if (format == D3DFMT_UNKNOWN || format == D3DX_DEFAULT) 612 format = imginfo.Format; 613 else 614 format_specified = TRUE; 615 616 if (width == D3DX_FROM_FILE) 617 { 618 width = imginfo.Width; 619 } 620 621 if (height == D3DX_FROM_FILE) 622 { 623 height = imginfo.Height; 624 } 625 626 if (format == D3DFMT_FROM_FILE) 627 { 628 format = imginfo.Format; 629 } 630 631 if (miplevels == D3DX_FROM_FILE) 632 { 633 miplevels = imginfo.MipLevels; 634 } 635 636 skip_levels = mipfilter != D3DX_DEFAULT ? mipfilter >> D3DX_SKIP_DDS_MIP_LEVELS_SHIFT : 0; 637 if (skip_levels && imginfo.MipLevels > skip_levels) 638 { 639 TRACE("Skipping the first %u (of %u) levels of a DDS mipmapped texture.\n", 640 skip_levels, imginfo.MipLevels); 641 TRACE("Texture level 0 dimensions are %ux%u.\n", imginfo.Width, imginfo.Height); 642 width >>= skip_levels; 643 height >>= skip_levels; 644 miplevels -= skip_levels; 645 } 646 else 647 { 648 skip_levels = 0; 649 } 650 651 /* fix texture creation parameters */ 652 hr = D3DXCheckTextureRequirements(device, &width, &height, &miplevels, usage, &format, pool); 653 if (FAILED(hr)) 654 { 655 FIXME("Couldn't find suitable texture parameters.\n"); 656 *texture = NULL; 657 return hr; 658 } 659 660 if (colorkey && !format_specified) 661 format = get_alpha_replacement_format(format); 662 663 if (imginfo.MipLevels < miplevels && (D3DFMT_DXT1 <= imginfo.Format && imginfo.Format <= D3DFMT_DXT5)) 664 { 665 FIXME("Generation of mipmaps for compressed pixel formats is not implemented yet.\n"); 666 miplevels = imginfo.MipLevels; 667 } 668 if (imginfo.ResourceType == D3DRTYPE_VOLUMETEXTURE 669 && D3DFMT_DXT1 <= imginfo.Format && imginfo.Format <= D3DFMT_DXT5 && miplevels > 1) 670 { 671 FIXME("Generation of mipmaps for compressed pixel formats is not implemented yet.\n"); 672 miplevels = 1; 673 } 674 675 if (FAILED(IDirect3DDevice9_GetDeviceCaps(device, &caps))) 676 return D3DERR_INVALIDCALL; 677 678 /* Create the to-be-filled texture */ 679 dynamic_texture = (caps.Caps2 & D3DCAPS2_DYNAMICTEXTURES) && (usage & D3DUSAGE_DYNAMIC); 680 if (pool == D3DPOOL_DEFAULT && !dynamic_texture) 681 { 682 hr = D3DXCreateTexture(device, width, height, miplevels, 0, format, D3DPOOL_SYSTEMMEM, &buftex); 683 texptr = &buftex; 684 } 685 else 686 { 687 hr = D3DXCreateTexture(device, width, height, miplevels, usage, format, pool, texture); 688 texptr = texture; 689 } 690 691 if (FAILED(hr)) 692 { 693 FIXME("Texture creation failed.\n"); 694 *texture = NULL; 695 return hr; 696 } 697 698 TRACE("Texture created correctly. Now loading the texture data into it.\n"); 699 if (imginfo.ImageFileFormat != D3DXIFF_DDS) 700 { 701 IDirect3DTexture9_GetSurfaceLevel(*texptr, 0, &surface); 702 hr = D3DXLoadSurfaceFromFileInMemory(surface, palette, NULL, srcdata, srcdatasize, NULL, filter, colorkey, NULL); 703 IDirect3DSurface9_Release(surface); 704 loaded_miplevels = min(IDirect3DTexture9_GetLevelCount(*texptr), imginfo.MipLevels); 705 } 706 else 707 { 708 hr = load_texture_from_dds(*texptr, srcdata, palette, filter, colorkey, &imginfo, skip_levels, 709 &loaded_miplevels); 710 } 711 712 if (FAILED(hr)) 713 { 714 FIXME("Texture loading failed.\n"); 715 IDirect3DTexture9_Release(*texptr); 716 *texture = NULL; 717 return hr; 718 } 719 720 hr = D3DXFilterTexture((IDirect3DBaseTexture9*) *texptr, palette, loaded_miplevels - 1, mipfilter); 721 if (FAILED(hr)) 722 { 723 FIXME("Texture filtering failed.\n"); 724 IDirect3DTexture9_Release(*texptr); 725 *texture = NULL; 726 return hr; 727 } 728 729 /* Move the data to the actual texture if necessary */ 730 if (texptr == &buftex) 731 { 732 hr = D3DXCreateTexture(device, width, height, miplevels, usage, format, pool, texture); 733 734 if (FAILED(hr)) 735 { 736 IDirect3DTexture9_Release(buftex); 737 *texture = NULL; 738 return hr; 739 } 740 741 IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9*)buftex, (IDirect3DBaseTexture9*)(*texture)); 742 IDirect3DTexture9_Release(buftex); 743 } 744 745 if (srcinfo) 746 *srcinfo = imginfo; 747 748 return D3D_OK; 749 } 750 751 HRESULT WINAPI D3DXCreateTextureFromFileInMemory(struct IDirect3DDevice9 *device, 752 const void *srcdata, UINT srcdatasize, struct IDirect3DTexture9 **texture) 753 { 754 TRACE("(%p, %p, %d, %p)\n", device, srcdata, srcdatasize, texture); 755 756 return D3DXCreateTextureFromFileInMemoryEx(device, srcdata, srcdatasize, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, 757 D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture); 758 } 759 760 HRESULT WINAPI D3DXCreateTextureFromFileExW(struct IDirect3DDevice9 *device, const WCHAR *srcfile, 761 UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, 762 D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, 763 PALETTEENTRY *palette, struct IDirect3DTexture9 **texture) 764 { 765 void *buffer; 766 HRESULT hr; 767 DWORD size; 768 769 TRACE("device %p, srcfile %s, width %u, height %u, miplevels %u, usage %#x, format %#x, " 770 "pool %#x, filter %#x, mipfilter %#x, colorkey 0x%08x, srcinfo %p, palette %p, texture %p.\n", 771 device, debugstr_w(srcfile), width, height, miplevels, usage, format, 772 pool, filter, mipfilter, colorkey, srcinfo, palette, texture); 773 774 if (!srcfile) 775 return D3DERR_INVALIDCALL; 776 777 hr = map_view_of_file(srcfile, &buffer, &size); 778 if (FAILED(hr)) 779 return D3DXERR_INVALIDDATA; 780 781 hr = D3DXCreateTextureFromFileInMemoryEx(device, buffer, size, width, height, miplevels, usage, format, pool, 782 filter, mipfilter, colorkey, srcinfo, palette, texture); 783 784 UnmapViewOfFile(buffer); 785 786 return hr; 787 } 788 789 HRESULT WINAPI D3DXCreateTextureFromFileExA(struct IDirect3DDevice9 *device, const char *srcfile, 790 UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, 791 D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, 792 PALETTEENTRY *palette, struct IDirect3DTexture9 **texture) 793 { 794 WCHAR *widename; 795 HRESULT hr; 796 DWORD len; 797 798 TRACE("device %p, srcfile %s, width %u, height %u, miplevels %u, usage %#x, format %#x, " 799 "pool %#x, filter %#x, mipfilter %#x, colorkey 0x%08x, srcinfo %p, palette %p, texture %p.\n", 800 device, debugstr_a(srcfile), width, height, miplevels, usage, format, 801 pool, filter, mipfilter, colorkey, srcinfo, palette, texture); 802 803 if (!device || !srcfile || !texture) 804 return D3DERR_INVALIDCALL; 805 806 len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0); 807 widename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*widename)); 808 MultiByteToWideChar(CP_ACP, 0, srcfile, -1, widename, len); 809 810 hr = D3DXCreateTextureFromFileExW(device, widename, width, height, miplevels, 811 usage, format, pool, filter, mipfilter, 812 colorkey, srcinfo, palette, texture); 813 814 HeapFree(GetProcessHeap(), 0, widename); 815 return hr; 816 } 817 818 HRESULT WINAPI D3DXCreateTextureFromFileA(struct IDirect3DDevice9 *device, 819 const char *srcfile, struct IDirect3DTexture9 **texture) 820 { 821 TRACE("(%p, %s, %p)\n", device, debugstr_a(srcfile), texture); 822 823 return D3DXCreateTextureFromFileExA(device, srcfile, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, 824 D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture); 825 } 826 827 HRESULT WINAPI D3DXCreateTextureFromFileW(struct IDirect3DDevice9 *device, 828 const WCHAR *srcfile, struct IDirect3DTexture9 **texture) 829 { 830 TRACE("(%p, %s, %p)\n", device, debugstr_w(srcfile), texture); 831 832 return D3DXCreateTextureFromFileExW(device, srcfile, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, 833 D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture); 834 } 835 836 837 HRESULT WINAPI D3DXCreateTextureFromResourceA(struct IDirect3DDevice9 *device, 838 HMODULE srcmodule, const char *resource, struct IDirect3DTexture9 **texture) 839 { 840 TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(resource)); 841 842 return D3DXCreateTextureFromResourceExA(device, srcmodule, resource, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, 843 D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture); 844 } 845 846 HRESULT WINAPI D3DXCreateTextureFromResourceW(struct IDirect3DDevice9 *device, 847 HMODULE srcmodule, const WCHAR *resource, struct IDirect3DTexture9 **texture) 848 { 849 TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(resource)); 850 851 return D3DXCreateTextureFromResourceExW(device, srcmodule, resource, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, 852 D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture); 853 } 854 855 HRESULT WINAPI D3DXCreateTextureFromResourceExA(struct IDirect3DDevice9 *device, HMODULE srcmodule, 856 const char *resource, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, 857 D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, 858 PALETTEENTRY *palette, struct IDirect3DTexture9 **texture) 859 { 860 HRSRC resinfo; 861 void *buffer; 862 DWORD size; 863 864 TRACE("device %p, srcmodule %p, resource %s, width %u, height %u, miplevels %u, usage %#x, format %#x, " 865 "pool %#x, filter %#x, mipfilter %#x, colorkey 0x%08x, srcinfo %p, palette %p, texture %p.\n", 866 device, srcmodule, debugstr_a(resource), width, height, miplevels, usage, format, 867 pool, filter, mipfilter, colorkey, srcinfo, palette, texture); 868 869 if (!device || !texture) 870 return D3DERR_INVALIDCALL; 871 872 if (!(resinfo = FindResourceA(srcmodule, resource, (const char *)RT_RCDATA)) 873 /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */ 874 && !(resinfo = FindResourceA(srcmodule, resource, (const char *)RT_BITMAP))) 875 return D3DXERR_INVALIDDATA; 876 877 if (FAILED(load_resource_into_memory(srcmodule, resinfo, &buffer, &size))) 878 return D3DXERR_INVALIDDATA; 879 880 return D3DXCreateTextureFromFileInMemoryEx(device, buffer, size, width, height, miplevels, 881 usage, format, pool, filter, mipfilter, colorkey, srcinfo, palette, texture); 882 } 883 884 HRESULT WINAPI D3DXCreateTextureFromResourceExW(struct IDirect3DDevice9 *device, HMODULE srcmodule, 885 const WCHAR *resource, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, 886 D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, 887 PALETTEENTRY *palette, struct IDirect3DTexture9 **texture) 888 { 889 HRSRC resinfo; 890 void *buffer; 891 DWORD size; 892 893 TRACE("device %p, srcmodule %p, resource %s, width %u, height %u, miplevels %u, usage %#x, format %#x, " 894 "pool %#x, filter %#x, mipfilter %#x, colorkey 0x%08x, srcinfo %p, palette %p, texture %p.\n", 895 device, srcmodule, debugstr_w(resource), width, height, miplevels, usage, format, 896 pool, filter, mipfilter, colorkey, srcinfo, palette, texture); 897 898 if (!device || !texture) 899 return D3DERR_INVALIDCALL; 900 901 if (!(resinfo = FindResourceW(srcmodule, resource, (const WCHAR *)RT_RCDATA)) 902 /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */ 903 && !(resinfo = FindResourceW(srcmodule, resource, (const WCHAR *)RT_BITMAP))) 904 return D3DXERR_INVALIDDATA; 905 906 if (FAILED(load_resource_into_memory(srcmodule, resinfo, &buffer, &size))) 907 return D3DXERR_INVALIDDATA; 908 909 return D3DXCreateTextureFromFileInMemoryEx(device, buffer, size, width, height, miplevels, 910 usage, format, pool, filter, mipfilter, colorkey, srcinfo, palette, texture); 911 } 912 913 HRESULT WINAPI D3DXCreateCubeTexture(struct IDirect3DDevice9 *device, UINT size, UINT miplevels, 914 DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DCubeTexture9 **texture) 915 { 916 HRESULT hr; 917 918 TRACE("(%p, %u, %u, %#x, %#x, %#x, %p)\n", device, size, miplevels, usage, format, 919 pool, texture); 920 921 if (!device || !texture) 922 return D3DERR_INVALIDCALL; 923 924 hr = D3DXCheckCubeTextureRequirements(device, &size, &miplevels, usage, &format, pool); 925 926 if (FAILED(hr)) 927 { 928 TRACE("D3DXCheckCubeTextureRequirements failed\n"); 929 return hr; 930 } 931 932 return IDirect3DDevice9_CreateCubeTexture(device, size, miplevels, usage, format, pool, texture, NULL); 933 } 934 935 HRESULT WINAPI D3DXCreateCubeTextureFromFileInMemory(struct IDirect3DDevice9 *device, 936 const void *data, UINT datasize, struct IDirect3DCubeTexture9 **texture) 937 { 938 TRACE("(%p, %p, %u, %p)\n", device, data, datasize, texture); 939 940 return D3DXCreateCubeTextureFromFileInMemoryEx(device, data, datasize, D3DX_DEFAULT, D3DX_DEFAULT, 941 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture); 942 } 943 944 HRESULT WINAPI D3DXCreateVolumeTexture(struct IDirect3DDevice9 *device, UINT width, UINT height, UINT depth, 945 UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DVolumeTexture9 **texture) 946 { 947 HRESULT hr; 948 949 TRACE("(%p, %u, %u, %u, %u, %#x, %#x, %#x, %p)\n", device, width, height, depth, 950 miplevels, usage, format, pool, texture); 951 952 if (!device || !texture) 953 return D3DERR_INVALIDCALL; 954 955 hr = D3DXCheckVolumeTextureRequirements(device, &width, &height, &depth, 956 &miplevels, usage, &format, pool); 957 958 if (FAILED(hr)) 959 { 960 TRACE("D3DXCheckVolumeTextureRequirements failed\n"); 961 return hr; 962 } 963 964 return IDirect3DDevice9_CreateVolumeTexture(device, width, height, depth, miplevels, 965 usage, format, pool, texture, NULL); 966 } 967 968 HRESULT WINAPI D3DXCreateVolumeTextureFromFileA(IDirect3DDevice9 *device, 969 const char *filename, 970 IDirect3DVolumeTexture9 **volume_texture) 971 { 972 int len; 973 HRESULT hr; 974 void *data; 975 DWORD data_size; 976 WCHAR *filenameW; 977 978 TRACE("(%p, %s, %p): relay\n", 979 device, debugstr_a(filename), volume_texture); 980 981 if (!filename) return D3DERR_INVALIDCALL; 982 983 len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0); 984 filenameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); 985 if (!filenameW) return E_OUTOFMEMORY; 986 MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, len); 987 988 hr = map_view_of_file(filenameW, &data, &data_size); 989 HeapFree(GetProcessHeap(), 0, filenameW); 990 if (FAILED(hr)) return D3DXERR_INVALIDDATA; 991 992 hr = D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 993 D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, volume_texture); 994 995 UnmapViewOfFile(data); 996 return hr; 997 } 998 999 HRESULT WINAPI D3DXCreateVolumeTextureFromFileW(IDirect3DDevice9 *device, 1000 const WCHAR *filename, 1001 IDirect3DVolumeTexture9 **volume_texture) 1002 { 1003 HRESULT hr; 1004 void *data; 1005 DWORD data_size; 1006 1007 TRACE("(%p, %s, %p): relay\n", 1008 device, debugstr_w(filename), volume_texture); 1009 1010 if (!filename) return D3DERR_INVALIDCALL; 1011 1012 hr = map_view_of_file(filename, &data, &data_size); 1013 if (FAILED(hr)) return D3DXERR_INVALIDDATA; 1014 1015 hr = D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 1016 D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, volume_texture); 1017 1018 UnmapViewOfFile(data); 1019 return hr; 1020 } 1021 1022 HRESULT WINAPI D3DXCreateVolumeTextureFromFileExA(IDirect3DDevice9 *device, 1023 const char *filename, 1024 UINT width, 1025 UINT height, 1026 UINT depth, 1027 UINT mip_levels, 1028 DWORD usage, 1029 D3DFORMAT format, 1030 D3DPOOL pool, 1031 DWORD filter, 1032 DWORD mip_filter, 1033 D3DCOLOR color_key, 1034 D3DXIMAGE_INFO *src_info, 1035 PALETTEENTRY *palette, 1036 IDirect3DVolumeTexture9 **volume_texture) 1037 { 1038 int len; 1039 HRESULT hr; 1040 WCHAR *filenameW; 1041 void *data; 1042 DWORD data_size; 1043 1044 TRACE("(%p, %s, %u, %u, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p): relay\n", 1045 device, debugstr_a(filename), width, height, depth, mip_levels, 1046 usage, format, pool, filter, mip_filter, color_key, src_info, 1047 palette, volume_texture); 1048 1049 if (!filename) return D3DERR_INVALIDCALL; 1050 1051 len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0); 1052 filenameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); 1053 if (!filenameW) return E_OUTOFMEMORY; 1054 MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, len); 1055 1056 hr = map_view_of_file(filenameW, &data, &data_size); 1057 HeapFree(GetProcessHeap(), 0, filenameW); 1058 if (FAILED(hr)) return D3DXERR_INVALIDDATA; 1059 1060 hr = D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, width, height, depth, 1061 mip_levels, usage, format, pool, filter, mip_filter, color_key, src_info, palette, 1062 volume_texture); 1063 1064 UnmapViewOfFile(data); 1065 return hr; 1066 } 1067 1068 HRESULT WINAPI D3DXCreateVolumeTextureFromFileExW(IDirect3DDevice9 *device, 1069 const WCHAR *filename, 1070 UINT width, 1071 UINT height, 1072 UINT depth, 1073 UINT mip_levels, 1074 DWORD usage, 1075 D3DFORMAT format, 1076 D3DPOOL pool, 1077 DWORD filter, 1078 DWORD mip_filter, 1079 D3DCOLOR color_key, 1080 D3DXIMAGE_INFO *src_info, 1081 PALETTEENTRY *palette, 1082 IDirect3DVolumeTexture9 **volume_texture) 1083 { 1084 HRESULT hr; 1085 void *data; 1086 DWORD data_size; 1087 1088 TRACE("(%p, %s, %u, %u, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p): relay\n", 1089 device, debugstr_w(filename), width, height, depth, mip_levels, 1090 usage, format, pool, filter, mip_filter, color_key, src_info, 1091 palette, volume_texture); 1092 1093 if (!filename) return D3DERR_INVALIDCALL; 1094 1095 hr = map_view_of_file(filename, &data, &data_size); 1096 if (FAILED(hr)) return D3DXERR_INVALIDDATA; 1097 1098 hr = D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, width, height, depth, 1099 mip_levels, usage, format, pool, filter, mip_filter, color_key, src_info, palette, 1100 volume_texture); 1101 1102 UnmapViewOfFile(data); 1103 return hr; 1104 } 1105 1106 HRESULT WINAPI D3DXCreateVolumeTextureFromFileInMemory(IDirect3DDevice9 *device, 1107 const void *data, 1108 UINT data_size, 1109 IDirect3DVolumeTexture9 **volume_texture) 1110 { 1111 TRACE("(%p, %p, %u, %p): relay\n", device, data, data_size, volume_texture); 1112 1113 return D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT, 1114 D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 1115 0, NULL, NULL, volume_texture); 1116 } 1117 1118 HRESULT WINAPI D3DXCreateVolumeTextureFromFileInMemoryEx(IDirect3DDevice9 *device, 1119 const void *data, 1120 UINT data_size, 1121 UINT width, 1122 UINT height, 1123 UINT depth, 1124 UINT mip_levels, 1125 DWORD usage, 1126 D3DFORMAT format, 1127 D3DPOOL pool, 1128 DWORD filter, 1129 DWORD mip_filter, 1130 D3DCOLOR color_key, 1131 D3DXIMAGE_INFO *info, 1132 PALETTEENTRY *palette, 1133 IDirect3DVolumeTexture9 **volume_texture) 1134 { 1135 HRESULT hr; 1136 D3DCAPS9 caps; 1137 D3DXIMAGE_INFO image_info; 1138 BOOL dynamic_texture; 1139 BOOL file_width = FALSE; 1140 BOOL file_height = FALSE; 1141 BOOL file_depth = FALSE; 1142 BOOL file_format = FALSE; 1143 BOOL file_mip_levels = FALSE; 1144 IDirect3DVolumeTexture9 *tex, *buftex; 1145 1146 TRACE("(%p, %p, %u, %u, %u, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p)\n", 1147 device, data, data_size, width, height, depth, mip_levels, usage, format, pool, 1148 filter, mip_filter, color_key, info, palette, volume_texture); 1149 1150 if (!device || !data || !data_size || !volume_texture) 1151 return D3DERR_INVALIDCALL; 1152 1153 hr = D3DXGetImageInfoFromFileInMemory(data, data_size, &image_info); 1154 if (FAILED(hr)) return hr; 1155 1156 if (image_info.ImageFileFormat != D3DXIFF_DDS) 1157 return D3DXERR_INVALIDDATA; 1158 1159 if (width == 0 || width == D3DX_DEFAULT_NONPOW2) 1160 width = image_info.Width; 1161 if (width == D3DX_DEFAULT) 1162 width = make_pow2(image_info.Width); 1163 1164 if (height == 0 || height == D3DX_DEFAULT_NONPOW2) 1165 height = image_info.Height; 1166 if (height == D3DX_DEFAULT) 1167 height = make_pow2(image_info.Height); 1168 1169 if (depth == 0 || depth == D3DX_DEFAULT_NONPOW2) 1170 depth = image_info.Depth; 1171 if (depth == D3DX_DEFAULT) 1172 depth = make_pow2(image_info.Depth); 1173 1174 if (format == D3DFMT_UNKNOWN || format == D3DX_DEFAULT) 1175 format = image_info.Format; 1176 1177 if (width == D3DX_FROM_FILE) 1178 { 1179 file_width = TRUE; 1180 width = image_info.Width; 1181 } 1182 1183 if (height == D3DX_FROM_FILE) 1184 { 1185 file_height = TRUE; 1186 height = image_info.Height; 1187 } 1188 1189 if (depth == D3DX_FROM_FILE) 1190 { 1191 file_depth = TRUE; 1192 depth = image_info.Depth; 1193 } 1194 1195 if (format == D3DFMT_FROM_FILE) 1196 { 1197 file_format = TRUE; 1198 format = image_info.Format; 1199 } 1200 1201 if (mip_levels == D3DX_FROM_FILE) 1202 { 1203 file_mip_levels = TRUE; 1204 mip_levels = image_info.MipLevels; 1205 } 1206 1207 hr = D3DXCheckVolumeTextureRequirements(device, &width, &height, &depth, &mip_levels, usage, &format, pool); 1208 if (FAILED(hr)) return hr; 1209 1210 if ((file_width && width != image_info.Width) 1211 || (file_height && height != image_info.Height) 1212 || (file_depth && depth != image_info.Depth) 1213 || (file_format && format != image_info.Format) 1214 || (file_mip_levels && mip_levels != image_info.MipLevels)) 1215 return D3DERR_NOTAVAILABLE; 1216 1217 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps); 1218 if (FAILED(hr)) 1219 return D3DERR_INVALIDCALL; 1220 1221 if (mip_levels > image_info.MipLevels) 1222 { 1223 FIXME("Generation of mipmaps for volume textures is not implemented yet.\n"); 1224 mip_levels = image_info.MipLevels; 1225 } 1226 1227 dynamic_texture = (caps.Caps2 & D3DCAPS2_DYNAMICTEXTURES) && (usage & D3DUSAGE_DYNAMIC); 1228 if (pool == D3DPOOL_DEFAULT && !dynamic_texture) 1229 { 1230 hr = D3DXCreateVolumeTexture(device, width, height, depth, mip_levels, usage, format, D3DPOOL_SYSTEMMEM, &buftex); 1231 tex = buftex; 1232 } 1233 else 1234 { 1235 hr = D3DXCreateVolumeTexture(device, width, height, depth, mip_levels, usage, format, pool, &tex); 1236 buftex = NULL; 1237 } 1238 1239 if (FAILED(hr)) return hr; 1240 1241 hr = load_volume_texture_from_dds(tex, data, palette, filter, color_key, &image_info); 1242 if (FAILED(hr)) 1243 { 1244 IDirect3DVolumeTexture9_Release(tex); 1245 return hr; 1246 } 1247 1248 if (buftex) 1249 { 1250 hr = D3DXCreateVolumeTexture(device, width, height, depth, mip_levels, usage, format, pool, &tex); 1251 if (FAILED(hr)) 1252 { 1253 IDirect3DVolumeTexture9_Release(buftex); 1254 return hr; 1255 } 1256 1257 IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)buftex, (IDirect3DBaseTexture9 *)tex); 1258 IDirect3DVolumeTexture9_Release(buftex); 1259 } 1260 1261 if (info) 1262 *info = image_info; 1263 1264 *volume_texture = tex; 1265 return D3D_OK; 1266 } 1267 1268 static inline void fill_texture(const struct pixel_format_desc *format, BYTE *pos, const D3DXVECTOR4 *value) 1269 { 1270 DWORD c; 1271 1272 for (c = 0; c < format->bytes_per_pixel; c++) 1273 pos[c] = 0; 1274 1275 for (c = 0; c < 4; c++) 1276 { 1277 float comp_value; 1278 DWORD i, v = 0, mask32 = format->bits[c] == 32 ? ~0U : ((1 << format->bits[c]) - 1); 1279 1280 switch (c) 1281 { 1282 case 0: /* Alpha */ 1283 comp_value = value->w; 1284 break; 1285 case 1: /* Red */ 1286 comp_value = value->x; 1287 break; 1288 case 2: /* Green */ 1289 comp_value = value->y; 1290 break; 1291 case 3: /* Blue */ 1292 comp_value = value->z; 1293 break; 1294 } 1295 1296 if (format->type == FORMAT_ARGBF16) 1297 v = float_32_to_16(comp_value); 1298 else if (format->type == FORMAT_ARGBF) 1299 v = *(DWORD *)&comp_value; 1300 else if (format->type == FORMAT_ARGB) 1301 v = comp_value * ((1 << format->bits[c]) - 1) + 0.5f; 1302 else 1303 FIXME("Unhandled format type %#x\n", format->type); 1304 1305 for (i = 0; i < format->bits[c] + format->shift[c]; i += 8) 1306 { 1307 BYTE byte, mask; 1308 1309 if (format->shift[c] > i) 1310 { 1311 mask = mask32 << (format->shift[c] - i); 1312 byte = (v << (format->shift[c] - i)) & mask; 1313 } 1314 else 1315 { 1316 mask = mask32 >> (i - format->shift[c]); 1317 byte = (v >> (i - format->shift[c])) & mask; 1318 } 1319 pos[i / 8] |= byte; 1320 } 1321 } 1322 } 1323 1324 HRESULT WINAPI D3DXFillTexture(struct IDirect3DTexture9 *texture, LPD3DXFILL2D function, void *funcdata) 1325 { 1326 IDirect3DSurface9 *surface, *temp_surface; 1327 DWORD miplevels; 1328 DWORD m, x, y; 1329 D3DSURFACE_DESC desc; 1330 D3DLOCKED_RECT lock_rect; 1331 D3DXVECTOR4 value; 1332 D3DXVECTOR2 coord, size; 1333 const struct pixel_format_desc *format; 1334 BYTE *data; 1335 HRESULT hr; 1336 1337 TRACE("texture %p, function %p, funcdata %p.\n", texture, function, funcdata); 1338 1339 if (!texture || !function) 1340 return D3DERR_INVALIDCALL; 1341 1342 miplevels = IDirect3DBaseTexture9_GetLevelCount(texture); 1343 1344 for (m = 0; m < miplevels; m++) 1345 { 1346 if (FAILED(hr = IDirect3DTexture9_GetLevelDesc(texture, m, &desc))) 1347 return hr; 1348 1349 format = get_format_info(desc.Format); 1350 if (format->type != FORMAT_ARGB && format->type != FORMAT_ARGBF16 && format->type != FORMAT_ARGBF) 1351 { 1352 FIXME("Unsupported texture format %#x.\n", desc.Format); 1353 return D3DERR_INVALIDCALL; 1354 } 1355 1356 if (FAILED(hr = IDirect3DTexture9_GetSurfaceLevel(texture, m, &surface))) 1357 return hr; 1358 if (FAILED(hr = lock_surface(surface, &lock_rect, &temp_surface, TRUE))) 1359 { 1360 IDirect3DSurface9_Release(surface); 1361 return hr; 1362 } 1363 1364 size.x = 1.0f / desc.Width; 1365 size.y = 1.0f / desc.Height; 1366 1367 data = lock_rect.pBits; 1368 1369 for (y = 0; y < desc.Height; y++) 1370 { 1371 /* The callback function expects the coordinates of the center 1372 of the texel */ 1373 coord.y = (y + 0.5f) / desc.Height; 1374 1375 for (x = 0; x < desc.Width; x++) 1376 { 1377 coord.x = (x + 0.5f) / desc.Width; 1378 1379 function(&value, &coord, &size, funcdata); 1380 1381 fill_texture(format, data + y * lock_rect.Pitch + x * format->bytes_per_pixel, &value); 1382 } 1383 } 1384 if (FAILED(hr = unlock_surface(surface, &lock_rect, temp_surface, TRUE))) 1385 { 1386 IDirect3DSurface9_Release(surface); 1387 return hr; 1388 } 1389 IDirect3DSurface9_Release(surface); 1390 } 1391 1392 return D3D_OK; 1393 } 1394 1395 HRESULT WINAPI D3DXFillTextureTX(struct IDirect3DTexture9 *texture, ID3DXTextureShader *texture_shader) 1396 { 1397 FIXME("texture %p, texture_shader %p stub.\n", texture, texture_shader); 1398 return E_NOTIMPL; 1399 } 1400 1401 HRESULT WINAPI D3DXCreateCubeTextureFromFileInMemoryEx(IDirect3DDevice9 *device, 1402 const void *src_data, 1403 UINT src_data_size, 1404 UINT size, 1405 UINT mip_levels, 1406 DWORD usage, 1407 D3DFORMAT format, 1408 D3DPOOL pool, 1409 DWORD filter, 1410 DWORD mip_filter, 1411 D3DCOLOR color_key, 1412 D3DXIMAGE_INFO *src_info, 1413 PALETTEENTRY *palette, 1414 IDirect3DCubeTexture9 **cube_texture) 1415 { 1416 HRESULT hr; 1417 D3DCAPS9 caps; 1418 UINT loaded_miplevels; 1419 D3DXIMAGE_INFO img_info; 1420 BOOL dynamic_texture; 1421 BOOL file_size = FALSE; 1422 BOOL file_format = FALSE; 1423 BOOL file_mip_levels = FALSE; 1424 IDirect3DCubeTexture9 *tex, *buftex; 1425 1426 TRACE("(%p, %p, %u, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p)\n", device, 1427 src_data, src_data_size, size, mip_levels, usage, format, pool, filter, mip_filter, 1428 color_key, src_info, palette, cube_texture); 1429 1430 if (!device || !cube_texture || !src_data || !src_data_size) 1431 return D3DERR_INVALIDCALL; 1432 1433 hr = D3DXGetImageInfoFromFileInMemory(src_data, src_data_size, &img_info); 1434 if (FAILED(hr)) 1435 return hr; 1436 1437 if (img_info.ImageFileFormat != D3DXIFF_DDS) 1438 return D3DXERR_INVALIDDATA; 1439 1440 if (img_info.Width != img_info.Height) 1441 return D3DXERR_INVALIDDATA; 1442 1443 if (size == 0 || size == D3DX_DEFAULT_NONPOW2) 1444 size = img_info.Width; 1445 if (size == D3DX_DEFAULT) 1446 size = make_pow2(img_info.Width); 1447 1448 if (format == D3DFMT_UNKNOWN || format == D3DX_DEFAULT) 1449 format = img_info.Format; 1450 1451 if (size == D3DX_FROM_FILE) 1452 { 1453 file_size = TRUE; 1454 size = img_info.Width; 1455 } 1456 1457 if (format == D3DFMT_FROM_FILE) 1458 { 1459 file_format = TRUE; 1460 format = img_info.Format; 1461 } 1462 1463 if (mip_levels == D3DX_FROM_FILE) 1464 { 1465 file_mip_levels = TRUE; 1466 mip_levels = img_info.MipLevels; 1467 } 1468 1469 hr = D3DXCheckCubeTextureRequirements(device, &size, &mip_levels, usage, &format, pool); 1470 if (FAILED(hr)) 1471 return hr; 1472 1473 if ((file_size && size != img_info.Width) 1474 || (file_format && format != img_info.Format) 1475 || (file_mip_levels && mip_levels != img_info.MipLevels)) 1476 return D3DERR_NOTAVAILABLE; 1477 1478 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps); 1479 if (FAILED(hr)) 1480 return D3DERR_INVALIDCALL; 1481 1482 if (mip_levels > img_info.MipLevels && (D3DFMT_DXT1 <= img_info.Format && img_info.Format <= D3DFMT_DXT5)) 1483 { 1484 FIXME("Generation of mipmaps for compressed pixel formats is not supported yet.\n"); 1485 mip_levels = img_info.MipLevels; 1486 } 1487 1488 dynamic_texture = (caps.Caps2 & D3DCAPS2_DYNAMICTEXTURES) && (usage & D3DUSAGE_DYNAMIC); 1489 if (pool == D3DPOOL_DEFAULT && !dynamic_texture) 1490 { 1491 hr = D3DXCreateCubeTexture(device, size, mip_levels, usage, format, D3DPOOL_SYSTEMMEM, &buftex); 1492 tex = buftex; 1493 } 1494 else 1495 { 1496 hr = D3DXCreateCubeTexture(device, size, mip_levels, usage, format, pool, &tex); 1497 buftex = NULL; 1498 } 1499 if (FAILED(hr)) 1500 return hr; 1501 1502 hr = load_cube_texture_from_dds(tex, src_data, palette, filter, color_key, &img_info); 1503 if (FAILED(hr)) 1504 { 1505 IDirect3DCubeTexture9_Release(tex); 1506 return hr; 1507 } 1508 1509 loaded_miplevels = min(IDirect3DCubeTexture9_GetLevelCount(tex), img_info.MipLevels); 1510 hr = D3DXFilterTexture((IDirect3DBaseTexture9*) tex, palette, loaded_miplevels - 1, mip_filter); 1511 if (FAILED(hr)) 1512 { 1513 IDirect3DCubeTexture9_Release(tex); 1514 return hr; 1515 } 1516 1517 if (buftex) 1518 { 1519 hr = D3DXCreateCubeTexture(device, size, mip_levels, usage, format, pool, &tex); 1520 if (FAILED(hr)) 1521 { 1522 IDirect3DCubeTexture9_Release(buftex); 1523 return hr; 1524 } 1525 1526 IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)buftex, (IDirect3DBaseTexture9 *)tex); 1527 IDirect3DCubeTexture9_Release(buftex); 1528 } 1529 1530 if (src_info) 1531 *src_info = img_info; 1532 1533 *cube_texture = tex; 1534 return D3D_OK; 1535 } 1536 1537 1538 HRESULT WINAPI D3DXCreateCubeTextureFromFileA(IDirect3DDevice9 *device, 1539 const char *src_filename, 1540 IDirect3DCubeTexture9 **cube_texture) 1541 { 1542 int len; 1543 HRESULT hr; 1544 WCHAR *filename; 1545 void *data; 1546 DWORD data_size; 1547 1548 TRACE("(%p, %s, %p): relay\n", device, wine_dbgstr_a(src_filename), cube_texture); 1549 1550 if (!src_filename) return D3DERR_INVALIDCALL; 1551 1552 len = MultiByteToWideChar(CP_ACP, 0, src_filename, -1, NULL, 0); 1553 filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); 1554 if (!filename) return E_OUTOFMEMORY; 1555 MultiByteToWideChar(CP_ACP, 0, src_filename, -1, filename, len); 1556 1557 hr = map_view_of_file(filename, &data, &data_size); 1558 if (FAILED(hr)) 1559 { 1560 HeapFree(GetProcessHeap(), 0, filename); 1561 return D3DXERR_INVALIDDATA; 1562 } 1563 1564 hr = D3DXCreateCubeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT, 1565 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, cube_texture); 1566 1567 UnmapViewOfFile(data); 1568 HeapFree(GetProcessHeap(), 0, filename); 1569 return hr; 1570 } 1571 1572 HRESULT WINAPI D3DXCreateCubeTextureFromFileW(IDirect3DDevice9 *device, 1573 const WCHAR *src_filename, 1574 IDirect3DCubeTexture9 **cube_texture) 1575 { 1576 HRESULT hr; 1577 void *data; 1578 DWORD data_size; 1579 1580 TRACE("(%p, %s, %p): relay\n", device, wine_dbgstr_w(src_filename), cube_texture); 1581 1582 hr = map_view_of_file(src_filename, &data, &data_size); 1583 if (FAILED(hr)) return D3DXERR_INVALIDDATA; 1584 1585 hr = D3DXCreateCubeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT, 1586 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, cube_texture); 1587 1588 UnmapViewOfFile(data); 1589 return hr; 1590 } 1591 1592 HRESULT WINAPI D3DXCreateCubeTextureFromFileExA(IDirect3DDevice9 *device, 1593 const char *src_filename, 1594 UINT size, 1595 UINT mip_levels, 1596 DWORD usage, 1597 D3DFORMAT format, 1598 D3DPOOL pool, 1599 DWORD filter, 1600 DWORD mip_filter, 1601 D3DCOLOR color_key, 1602 D3DXIMAGE_INFO *image_info, 1603 PALETTEENTRY *palette, 1604 IDirect3DCubeTexture9 **cube_texture) 1605 { 1606 int len; 1607 HRESULT hr; 1608 WCHAR *filename; 1609 void *data; 1610 DWORD data_size; 1611 1612 TRACE("(%p, %s, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p): relay\n", 1613 device, wine_dbgstr_a(src_filename), size, mip_levels, usage, format, 1614 pool, filter, mip_filter, color_key, image_info, palette, cube_texture); 1615 1616 if (!src_filename) return D3DERR_INVALIDCALL; 1617 1618 len = MultiByteToWideChar(CP_ACP, 0, src_filename, -1, NULL, 0); 1619 filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); 1620 if (!filename) return E_OUTOFMEMORY; 1621 MultiByteToWideChar(CP_ACP, 0, src_filename, -1, filename, len); 1622 1623 hr = map_view_of_file(filename, &data, &data_size); 1624 if (FAILED(hr)) 1625 { 1626 HeapFree(GetProcessHeap(), 0, filename); 1627 return D3DXERR_INVALIDDATA; 1628 } 1629 1630 hr = D3DXCreateCubeTextureFromFileInMemoryEx(device, data, data_size, size, mip_levels, 1631 usage, format, pool, filter, mip_filter, color_key, image_info, palette, cube_texture); 1632 1633 UnmapViewOfFile(data); 1634 HeapFree(GetProcessHeap(), 0, filename); 1635 return hr; 1636 } 1637 1638 HRESULT WINAPI D3DXCreateCubeTextureFromFileExW(IDirect3DDevice9 *device, 1639 const WCHAR *src_filename, 1640 UINT size, 1641 UINT mip_levels, 1642 DWORD usage, 1643 D3DFORMAT format, 1644 D3DPOOL pool, 1645 DWORD filter, 1646 DWORD mip_filter, 1647 D3DCOLOR color_key, 1648 D3DXIMAGE_INFO *image_info, 1649 PALETTEENTRY *palette, 1650 IDirect3DCubeTexture9 **cube_texture) 1651 { 1652 HRESULT hr; 1653 void *data; 1654 DWORD data_size; 1655 1656 TRACE("(%p, %s, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p): relay\n", 1657 device, wine_dbgstr_w(src_filename), size, mip_levels, usage, format, 1658 pool, filter, mip_filter, color_key, image_info, palette, cube_texture); 1659 1660 hr = map_view_of_file(src_filename, &data, &data_size); 1661 if (FAILED(hr)) return D3DXERR_INVALIDDATA; 1662 1663 hr = D3DXCreateCubeTextureFromFileInMemoryEx(device, data, data_size, size, mip_levels, 1664 usage, format, pool, filter, mip_filter, color_key, image_info, palette, cube_texture); 1665 1666 UnmapViewOfFile(data); 1667 return hr; 1668 } 1669 1670 enum cube_coord 1671 { 1672 XCOORD = 0, 1673 XCOORDINV = 1, 1674 YCOORD = 2, 1675 YCOORDINV = 3, 1676 ZERO = 4, 1677 ONE = 5 1678 }; 1679 1680 static float get_cube_coord(enum cube_coord coord, unsigned int x, unsigned int y, unsigned int size) 1681 { 1682 switch (coord) 1683 { 1684 case XCOORD: 1685 return x + 0.5f; 1686 case XCOORDINV: 1687 return size - x - 0.5f; 1688 case YCOORD: 1689 return y + 0.5f; 1690 case YCOORDINV: 1691 return size - y - 0.5f; 1692 case ZERO: 1693 return 0.0f; 1694 case ONE: 1695 return size; 1696 default: 1697 ERR("Unexpected coordinate value\n"); 1698 return 0.0f; 1699 } 1700 } 1701 1702 HRESULT WINAPI D3DXFillCubeTexture(struct IDirect3DCubeTexture9 *texture, LPD3DXFILL3D function, void *funcdata) 1703 { 1704 DWORD miplevels; 1705 DWORD m, x, y, f; 1706 D3DSURFACE_DESC desc; 1707 D3DLOCKED_RECT lock_rect; 1708 D3DXVECTOR4 value; 1709 D3DXVECTOR3 coord, size; 1710 const struct pixel_format_desc *format; 1711 BYTE *data; 1712 static const enum cube_coord coordmap[6][3] = 1713 { 1714 {ONE, YCOORDINV, XCOORDINV}, 1715 {ZERO, YCOORDINV, XCOORD}, 1716 {XCOORD, ONE, YCOORD}, 1717 {XCOORD, ZERO, YCOORDINV}, 1718 {XCOORD, YCOORDINV, ONE}, 1719 {XCOORDINV, YCOORDINV, ZERO} 1720 }; 1721 1722 if (texture == NULL || function == NULL) 1723 return D3DERR_INVALIDCALL; 1724 1725 miplevels = IDirect3DBaseTexture9_GetLevelCount(texture); 1726 1727 for (m = 0; m < miplevels; m++) 1728 { 1729 if (FAILED(IDirect3DCubeTexture9_GetLevelDesc(texture, m, &desc))) 1730 return D3DERR_INVALIDCALL; 1731 1732 format = get_format_info(desc.Format); 1733 if (format->type != FORMAT_ARGB && format->type != FORMAT_ARGBF16 && format->type != FORMAT_ARGBF) 1734 { 1735 FIXME("Unsupported texture format %#x\n", desc.Format); 1736 return D3DERR_INVALIDCALL; 1737 } 1738 1739 for (f = 0; f < 6; f++) 1740 { 1741 if (FAILED(IDirect3DCubeTexture9_LockRect(texture, f, m, &lock_rect, NULL, D3DLOCK_DISCARD))) 1742 return D3DERR_INVALIDCALL; 1743 1744 size.x = (f == 0) || (f == 1) ? 0.0f : 2.0f / desc.Width; 1745 size.y = (f == 2) || (f == 3) ? 0.0f : 2.0f / desc.Width; 1746 size.z = (f == 4) || (f == 5) ? 0.0f : 2.0f / desc.Width; 1747 1748 data = lock_rect.pBits; 1749 1750 for (y = 0; y < desc.Height; y++) 1751 { 1752 for (x = 0; x < desc.Width; x++) 1753 { 1754 coord.x = get_cube_coord(coordmap[f][0], x, y, desc.Width) / desc.Width * 2.0f - 1.0f; 1755 coord.y = get_cube_coord(coordmap[f][1], x, y, desc.Width) / desc.Width * 2.0f - 1.0f; 1756 coord.z = get_cube_coord(coordmap[f][2], x, y, desc.Width) / desc.Width * 2.0f - 1.0f; 1757 1758 function(&value, &coord, &size, funcdata); 1759 1760 fill_texture(format, data + y * lock_rect.Pitch + x * format->bytes_per_pixel, &value); 1761 } 1762 } 1763 IDirect3DCubeTexture9_UnlockRect(texture, f, m); 1764 } 1765 } 1766 1767 return D3D_OK; 1768 } 1769 1770 HRESULT WINAPI D3DXFillCubeTextureTX(struct IDirect3DCubeTexture9 *texture, ID3DXTextureShader *texture_shader) 1771 { 1772 FIXME("texture %p, texture_shader %p stub.\n", texture, texture_shader); 1773 return E_NOTIMPL; 1774 } 1775 1776 HRESULT WINAPI D3DXFillVolumeTexture(struct IDirect3DVolumeTexture9 *texture, LPD3DXFILL3D function, void *funcdata) 1777 { 1778 DWORD miplevels; 1779 DWORD m, x, y, z; 1780 D3DVOLUME_DESC desc; 1781 D3DLOCKED_BOX lock_box; 1782 D3DXVECTOR4 value; 1783 D3DXVECTOR3 coord, size; 1784 const struct pixel_format_desc *format; 1785 BYTE *data; 1786 1787 if (texture == NULL || function == NULL) 1788 return D3DERR_INVALIDCALL; 1789 1790 miplevels = IDirect3DBaseTexture9_GetLevelCount(texture); 1791 1792 for (m = 0; m < miplevels; m++) 1793 { 1794 if (FAILED(IDirect3DVolumeTexture9_GetLevelDesc(texture, m, &desc))) 1795 return D3DERR_INVALIDCALL; 1796 1797 format = get_format_info(desc.Format); 1798 if (format->type != FORMAT_ARGB && format->type != FORMAT_ARGBF16 && format->type != FORMAT_ARGBF) 1799 { 1800 FIXME("Unsupported texture format %#x\n", desc.Format); 1801 return D3DERR_INVALIDCALL; 1802 } 1803 1804 if (FAILED(IDirect3DVolumeTexture9_LockBox(texture, m, &lock_box, NULL, D3DLOCK_DISCARD))) 1805 return D3DERR_INVALIDCALL; 1806 1807 size.x = 1.0f / desc.Width; 1808 size.y = 1.0f / desc.Height; 1809 size.z = 1.0f / desc.Depth; 1810 1811 data = lock_box.pBits; 1812 1813 for (z = 0; z < desc.Depth; z++) 1814 { 1815 /* The callback function expects the coordinates of the center 1816 of the texel */ 1817 coord.z = (z + 0.5f) / desc.Depth; 1818 1819 for (y = 0; y < desc.Height; y++) 1820 { 1821 coord.y = (y + 0.5f) / desc.Height; 1822 1823 for (x = 0; x < desc.Width; x++) 1824 { 1825 coord.x = (x + 0.5f) / desc.Width; 1826 1827 function(&value, &coord, &size, funcdata); 1828 1829 fill_texture(format, data + z * lock_box.SlicePitch + y * lock_box.RowPitch 1830 + x * format->bytes_per_pixel, &value); 1831 } 1832 } 1833 } 1834 IDirect3DVolumeTexture9_UnlockBox(texture, m); 1835 } 1836 1837 return D3D_OK; 1838 } 1839 1840 HRESULT WINAPI D3DXFillVolumeTextureTX(struct IDirect3DVolumeTexture9 *texture, ID3DXTextureShader *texture_shader) 1841 { 1842 FIXME("texture %p, texture_shader %p stub.\n", texture, texture_shader); 1843 return E_NOTIMPL; 1844 } 1845 1846 HRESULT WINAPI D3DXSaveTextureToFileA(const char *dst_filename, D3DXIMAGE_FILEFORMAT file_format, 1847 IDirect3DBaseTexture9 *src_texture, const PALETTEENTRY *src_palette) 1848 { 1849 int len; 1850 WCHAR *filename; 1851 HRESULT hr; 1852 ID3DXBuffer *buffer; 1853 1854 TRACE("(%s, %#x, %p, %p): relay\n", 1855 wine_dbgstr_a(dst_filename), file_format, src_texture, src_palette); 1856 1857 if (!dst_filename) return D3DERR_INVALIDCALL; 1858 1859 len = MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, NULL, 0); 1860 filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); 1861 if (!filename) return E_OUTOFMEMORY; 1862 MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, filename, len); 1863 1864 hr = D3DXSaveTextureToFileInMemory(&buffer, file_format, src_texture, src_palette); 1865 if (SUCCEEDED(hr)) 1866 { 1867 hr = write_buffer_to_file(filename, buffer); 1868 ID3DXBuffer_Release(buffer); 1869 } 1870 1871 HeapFree(GetProcessHeap(), 0, filename); 1872 return hr; 1873 } 1874 1875 HRESULT WINAPI D3DXSaveTextureToFileW(const WCHAR *dst_filename, D3DXIMAGE_FILEFORMAT file_format, 1876 IDirect3DBaseTexture9 *src_texture, const PALETTEENTRY *src_palette) 1877 { 1878 HRESULT hr; 1879 ID3DXBuffer *buffer; 1880 1881 TRACE("(%s, %#x, %p, %p): relay\n", 1882 wine_dbgstr_w(dst_filename), file_format, src_texture, src_palette); 1883 1884 if (!dst_filename) return D3DERR_INVALIDCALL; 1885 1886 hr = D3DXSaveTextureToFileInMemory(&buffer, file_format, src_texture, src_palette); 1887 if (SUCCEEDED(hr)) 1888 { 1889 hr = write_buffer_to_file(dst_filename, buffer); 1890 ID3DXBuffer_Release(buffer); 1891 } 1892 1893 return hr; 1894 } 1895 1896 HRESULT WINAPI D3DXSaveTextureToFileInMemory(ID3DXBuffer **dst_buffer, D3DXIMAGE_FILEFORMAT file_format, 1897 IDirect3DBaseTexture9 *src_texture, const PALETTEENTRY *src_palette) 1898 { 1899 HRESULT hr; 1900 D3DRESOURCETYPE type; 1901 IDirect3DSurface9 *surface; 1902 1903 TRACE("(%p, %#x, %p, %p)\n", 1904 dst_buffer, file_format, src_texture, src_palette); 1905 1906 if (!dst_buffer || !src_texture) return D3DERR_INVALIDCALL; 1907 1908 if (file_format == D3DXIFF_DDS) 1909 return save_dds_texture_to_memory(dst_buffer, src_texture, src_palette); 1910 1911 type = IDirect3DBaseTexture9_GetType(src_texture); 1912 switch (type) 1913 { 1914 case D3DRTYPE_TEXTURE: 1915 case D3DRTYPE_CUBETEXTURE: 1916 hr = get_surface(type, src_texture, D3DCUBEMAP_FACE_POSITIVE_X, 0, &surface); 1917 break; 1918 case D3DRTYPE_VOLUMETEXTURE: 1919 FIXME("Volume textures aren't supported yet\n"); 1920 return E_NOTIMPL; 1921 default: 1922 return D3DERR_INVALIDCALL; 1923 } 1924 1925 if (SUCCEEDED(hr)) 1926 { 1927 hr = D3DXSaveSurfaceToFileInMemory(dst_buffer, file_format, surface, src_palette, NULL); 1928 IDirect3DSurface9_Release(surface); 1929 } 1930 1931 return hr; 1932 } 1933 1934 HRESULT WINAPI D3DXComputeNormalMap(IDirect3DTexture9 *texture, IDirect3DTexture9 *src_texture, 1935 const PALETTEENTRY *src_palette, DWORD flags, DWORD channel, float amplitude) 1936 { 1937 FIXME("texture %p, src_texture %p, src_palette %p, flags %#x, channel %u, amplitude %.8e stub.\n", 1938 texture, src_texture, src_palette, flags, channel, amplitude); 1939 1940 return D3D_OK; 1941 } 1942