d3dx9tex.h 40.1 KB
Newer Older
Tony Wasserka's avatar
Tony Wasserka committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
/*
 * Copyright (C) 2008 Tony Wasserka
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include <d3dx9.h>

#ifndef __WINE_D3DX9TEX_H
#define __WINE_D3DX9TEX_H

/**********************************************
 ***************** Definitions ****************
 **********************************************/
#define D3DX_FILTER_NONE                 0x00000001
#define D3DX_FILTER_POINT                0x00000002
#define D3DX_FILTER_LINEAR               0x00000003
#define D3DX_FILTER_TRIANGLE             0x00000004
#define D3DX_FILTER_BOX                  0x00000005
#define D3DX_FILTER_MIRROR_U             0x00010000
#define D3DX_FILTER_MIRROR_V             0x00020000
#define D3DX_FILTER_MIRROR_W             0x00040000
#define D3DX_FILTER_MIRROR               0x00070000
#define D3DX_FILTER_DITHER               0x00080000
#define D3DX_FILTER_DITHER_DIFFUSION     0x00100000
#define D3DX_FILTER_SRGB_IN              0x00200000
#define D3DX_FILTER_SRGB_OUT             0x00400000
#define D3DX_FILTER_SRGB                 0x00600000

#define D3DX_NORMALMAP_MIRROR_U          0x00010000
#define D3DX_NORMALMAP_MIRROR_V          0x00020000
#define D3DX_NORMALMAP_MIRROR            0x00030000
#define D3DX_NORMALMAP_INVERTSIGN        0x00080000
#define D3DX_NORMALMAP_COMPUTE_OCCLUSION 0x00100000

#define D3DX_CHANNEL_RED                 0x00000001
#define D3DX_CHANNEL_BLUE                0x00000002
#define D3DX_CHANNEL_GREEN               0x00000004
#define D3DX_CHANNEL_ALPHA               0x00000008
#define D3DX_CHANNEL_LUMINANCE           0x00000010

/**********************************************
 **************** Typedefs ****************
 **********************************************/
typedef enum _D3DXIMAGE_FILEFORMAT
{
    D3DXIFF_BMP,
    D3DXIFF_JPG,
    D3DXIFF_TGA,
    D3DXIFF_PNG,
    D3DXIFF_DDS,
    D3DXIFF_PPM,
    D3DXIFF_DIB,
    D3DXIFF_FORCE_DWORD = 0x7fffffff
} D3DXIMAGE_FILEFORMAT;

typedef struct _D3DXIMAGE_INFO
{
    UINT Width;
    UINT Height;
    UINT Depth;
    UINT MipLevels;
    D3DFORMAT Format;
    D3DRESOURCETYPE ResourceType;
    D3DXIMAGE_FILEFORMAT ImageFileFormat;
} D3DXIMAGE_INFO;

/**********************************************
 ****************** Functions *****************
 **********************************************/
/* Typedefs for callback functions */
typedef VOID (WINAPI *LPD3DXFILL2D)(D3DXVECTOR4 *out, CONST D3DXVECTOR2 *texcoord, CONST D3DXVECTOR2 *texelsize, LPVOID data);
typedef VOID (WINAPI *LPD3DXFILL3D)(D3DXVECTOR4 *out, CONST D3DXVECTOR3 *texcoord, CONST D3DXVECTOR3 *texelsize, LPVOID data);

#ifdef __cplusplus
extern "C" {
#endif


/* Image Information */
HRESULT WINAPI D3DXGetImageInfoFromFileA(LPCSTR file, D3DXIMAGE_INFO *info);
HRESULT WINAPI D3DXGetImageInfoFromFileW(LPCWSTR file, D3DXIMAGE_INFO *info);
#define        D3DXGetImageInfoFromFile WINELIB_NAME_AW(D3DXGetImageInfoFromFile)

HRESULT WINAPI D3DXGetImageInfoFromResourceA(HMODULE module, LPCSTR resource, D3DXIMAGE_INFO *info);
HRESULT WINAPI D3DXGetImageInfoFromResourceW(HMODULE module, LPCWSTR resource, D3DXIMAGE_INFO *info);
#define        D3DXGetImageInfoFromResource WINELIB_NAME_AW(D3DXGetImageInfoFromResource)

HRESULT WINAPI D3DXGetImageInfoFromFileInMemory(LPCVOID data, UINT datasize, D3DXIMAGE_INFO *info);


/* Surface Loading/Saving */
HRESULT WINAPI D3DXLoadSurfaceFromFileA(       LPDIRECT3DSURFACE9 destsurface,
                                               CONST PALETTEENTRY *destpalette,
                                               CONST RECT *destrect,
                                               LPCSTR srcfile,
                                               CONST RECT *srcrect,
                                               DWORD filter,
                                               D3DCOLOR colorkey,
                                               D3DXIMAGE_INFO *srcinfo);

HRESULT WINAPI D3DXLoadSurfaceFromFileW(       LPDIRECT3DSURFACE9 destsurface,
                                               CONST PALETTEENTRY *destpalette,
                                               CONST RECT *destrect,
                                               LPCWSTR srcfile,
                                               CONST RECT *srcrect,
                                               DWORD filter,
                                               D3DCOLOR colorkey,
                                               D3DXIMAGE_INFO *srcinfo);
#define        D3DXLoadSurfaceFromFile WINELIB_NAME_AW(D3DXLoadSurfaceFromFile)

HRESULT WINAPI D3DXLoadSurfaceFromResourceA(   LPDIRECT3DSURFACE9 destsurface,
                                               CONST PALETTEENTRY *destpalette,
                                               CONST RECT *destrect,
                                               HMODULE srcmodule,
                                               LPCSTR resource,
                                               CONST RECT *srcrect,
                                               DWORD filter,
                                               D3DCOLOR colorkey,
                                               D3DXIMAGE_INFO *srcinfo);

HRESULT WINAPI D3DXLoadSurfaceFromResourceW(   LPDIRECT3DSURFACE9 destsurface,
                                               CONST PALETTEENTRY *destpalette,
                                               CONST RECT *destrect,
                                               HMODULE srcmodule,
                                               LPCWSTR resource,
                                               CONST RECT *srcrect,
                                               DWORD filter,
                                               D3DCOLOR colorkey,
                                               D3DXIMAGE_INFO *srcinfo);
#define        D3DXLoadSurfaceFromResource WINELIB_NAME_AW(D3DXLoadSurfaceFromResource)

HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory(LPDIRECT3DSURFACE9 destsurface,
                                               CONST PALETTEENTRY *destpalette,
                                               CONST RECT*destrect,
                                               LPCVOID srcdata,
                                               UINT srcdatasize,
                                               CONST RECT *srcrect,
                                               DWORD filter,
                                               D3DCOLOR colorkey,
                                               D3DXIMAGE_INFO *srcinfo);

HRESULT WINAPI D3DXLoadSurfaceFromSurface(     LPDIRECT3DSURFACE9 destsurface,
                                               CONST PALETTEENTRY *destpalette,
                                               CONST RECT *destrect,
                                               LPDIRECT3DSURFACE9 srcsurface,
                                               CONST PALETTEENTRY *srcpalette,
                                               CONST RECT *srcrect,
                                               DWORD filter,
                                               D3DCOLOR colorkey);

HRESULT WINAPI D3DXLoadSurfaceFromMemory(      LPDIRECT3DSURFACE9 destsurface,
                                               CONST PALETTEENTRY *destpalette,
                                               CONST RECT *destrect,
                                               LPCVOID srcmemory,
                                               D3DFORMAT srcformat,
                                               UINT srcpitch,
                                               CONST PALETTEENTRY *srcpalette,
                                               CONST RECT *srcrect,
                                               DWORD filter,
                                               D3DCOLOR colorkey);

HRESULT WINAPI D3DXSaveSurfaceToFileA(         LPCSTR destfile,
                                               D3DXIMAGE_FILEFORMAT destformat,
                                               LPDIRECT3DSURFACE9 srcsurface,
                                               CONST PALETTEENTRY *srcpalette,
                                               CONST RECT *srcrect);

HRESULT WINAPI D3DXSaveSurfaceToFileW(         LPCWSTR destfile,
                                               D3DXIMAGE_FILEFORMAT destformat,
                                               LPDIRECT3DSURFACE9 srcsurface,
                                               CONST PALETTEENTRY *srcpalette,
                                               CONST RECT *srcrect);
#define        D3DXSaveSurfaceToFile WINELIB_NAME_AW(D3DXSaveSurfaceToFile)


/* Volume Loading/Saving */
HRESULT WINAPI D3DXLoadVolumeFromFileA(       LPDIRECT3DVOLUME9 destvolume,
                                              CONST PALETTEENTRY *destpalette,
                                              CONST D3DBOX *destbox,
                                              LPCSTR srcfile,
                                              CONST D3DBOX *srcbox,
                                              DWORD filter,
                                              D3DCOLOR colorkey,
                                              D3DXIMAGE_INFO *srcinfo);

HRESULT WINAPI D3DXLoadVolumeFromFileW(       LPDIRECT3DVOLUME9 destVolume,
                                              CONST PALETTEENTRY *destpalette,
                                              CONST D3DBOX *destbox,
                                              LPCWSTR srcfile,
                                              CONST D3DBOX *srcbox,
                                              DWORD filter,
                                              D3DCOLOR colorkey,
                                              D3DXIMAGE_INFO *srcinfo);
#define        D3DXLoadVolumeFromFile WINELIB_NAME_AW(D3DXLoadVolumeFromFile)

HRESULT WINAPI D3DXLoadVolumeFromResourceA(   LPDIRECT3DVOLUME9 destVolume,
                                              CONST PALETTEENTRY *destpalette,
                                              CONST D3DBOX *destbox,
                                              HMODULE srcmodule,
                                              LPCSTR resource,
                                              CONST D3DBOX *srcbox,
                                              DWORD filter,
                                              D3DCOLOR colorkey,
                                              D3DXIMAGE_INFO *srcinfo);

HRESULT WINAPI D3DXLoadVolumeFromResourceW(   LPDIRECT3DVOLUME9 destVolume,
                                              CONST PALETTEENTRY *destpalette,
                                              CONST D3DBOX *destbox,
                                              HMODULE srcmodule,
                                              LPCWSTR resource,
                                              CONST D3DBOX *srcbox,
                                              DWORD filter,
                                              D3DCOLOR colorkey,
                                              D3DXIMAGE_INFO *srcinfo);
#define        D3DXLoadVolumeFromResource WINELIB_NAME_AW(D3DXLoadVolumeFromResource)

HRESULT WINAPI D3DXLoadVolumeFromFileInMemory(LPDIRECT3DVOLUME9 destvolume,
                                              CONST PALETTEENTRY *destpalette,
                                              CONST D3DBOX *destbox,
                                              LPCVOID srcdata,
                                              UINT srcdatasize,
                                              CONST D3DBOX *srcbox,
                                              DWORD filter,
                                              D3DCOLOR colorkey,
                                              D3DXIMAGE_INFO *srcinfo);

HRESULT WINAPI D3DXLoadVolumeFromVolume(      LPDIRECT3DVOLUME9 destvolume,
                                              CONST PALETTEENTRY *destpalette,
                                              CONST D3DBOX *destbox,
                                              LPDIRECT3DVOLUME9 srcvolume,
                                              CONST PALETTEENTRY *srcpalette,
                                              CONST D3DBOX *srcbox,
                                              DWORD filter,
                                              D3DCOLOR colorkey);

HRESULT WINAPI D3DXLoadVolumeFromMemory(      LPDIRECT3DVOLUME9 destvolume,
                                              CONST PALETTEENTRY *destpalette,
                                              CONST D3DBOX *destbox,
                                              LPCVOID srcmemory,
                                              D3DFORMAT srcformat,
                                              UINT srcrowpitch,
                                              UINT srcslicepitch,
                                              CONST PALETTEENTRY *srcpalette,
                                              CONST D3DBOX *srcbox,
                                              DWORD filter,
                                              D3DCOLOR colorkey);

HRESULT WINAPI D3DXSaveVolumeToFileA(         LPCSTR destfile,
                                              D3DXIMAGE_FILEFORMAT destformat,
                                              LPDIRECT3DVOLUME9 srcvolume,
                                              CONST PALETTEENTRY *srcpalette,
                                              CONST D3DBOX *srcbox);

HRESULT WINAPI D3DXSaveVolumeToFileW(         LPCWSTR destfile,
                                              D3DXIMAGE_FILEFORMAT destformat,
                                              LPDIRECT3DVOLUME9 srcvolume,
                                              CONST PALETTEENTRY *srcpalette,
                                              CONST D3DBOX *srcbox);
#define        D3DXSaveVolumeToFile WINELIB_NAME_AW(D3DXSaveVolumeToFile)


/* Texture, cube texture and volume texture creation */
HRESULT WINAPI D3DXCheckTextureRequirements(      LPDIRECT3DDEVICE9 device,
                                                  UINT *width,
                                                  UINT *height,
                                                  UINT *miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT *format,
                                                  D3DPOOL pool);
HRESULT WINAPI D3DXCheckCubeTextureRequirements(  LPDIRECT3DDEVICE9 device,
                                                  UINT *size,
                                                  UINT *miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT *format,
                                                  D3DPOOL pool);

HRESULT WINAPI D3DXCheckVolumeTextureRequirements(LPDIRECT3DDEVICE9 device,
                                                  UINT *width,
                                                  UINT *height,
                                                  UINT *depth,
                                                  UINT *miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT *format,
                                                  D3DPOOL pool);

HRESULT WINAPI D3DXCreateTexture(      LPDIRECT3DDEVICE9 device,
                                       UINT width,
                                       UINT height,
                                       UINT miplevels,
                                       DWORD usage,
                                       D3DFORMAT format,
                                       D3DPOOL pool,
                                       LPDIRECT3DTEXTURE9 *texture);

HRESULT WINAPI D3DXCreateCubeTexture(  LPDIRECT3DDEVICE9 device,
                                       UINT size,
                                       UINT miplevels,
                                       DWORD usage,
                                       D3DFORMAT format,
                                       D3DPOOL pool,
                                       LPDIRECT3DCUBETEXTURE9 *cube);

HRESULT WINAPI D3DXCreateVolumeTexture(LPDIRECT3DDEVICE9 device,
                                       UINT width,
                                       UINT height,
                                       UINT depth,
                                       UINT miplevels,
                                       DWORD usage,
                                       D3DFORMAT format,
                                       D3DPOOL pool,
                                       LPDIRECT3DVOLUMETEXTURE9 *volume);

HRESULT WINAPI D3DXCreateTextureFromFileA(      LPDIRECT3DDEVICE9 device,
                                                LPCSTR srcfile,
                                                LPDIRECT3DTEXTURE9 *texture);

HRESULT WINAPI D3DXCreateTextureFromFileW(      LPDIRECT3DDEVICE9 device,
                                                LPCWSTR srcfile,
                                                LPDIRECT3DTEXTURE9 *texture);
#define        D3DXCreateTextureFromFile WINELIB_NAME_AW(D3DXCreateTextureFromFile)

HRESULT WINAPI D3DXCreateCubeTextureFromFileA(  LPDIRECT3DDEVICE9 device,
                                                LPCSTR srcfile,
                                                LPDIRECT3DCUBETEXTURE9 *cube);

HRESULT WINAPI D3DXCreateCubeTextureFromFileW(  LPDIRECT3DDEVICE9 device,
                                                LPCWSTR srcfile,
                                                LPDIRECT3DCUBETEXTURE9 *cube);
#define        D3DXCreateCubeTextureFromFile WINELIB_NAME_AW(D3DXCreateCubeTextureFromFile)

HRESULT WINAPI D3DXCreateVolumeTextureFromFileA(LPDIRECT3DDEVICE9 device,
                                                LPCSTR srcfile,
                                                LPDIRECT3DVOLUMETEXTURE9 *volume);

HRESULT WINAPI D3DXCreateVolumeTextureFromFileW(LPDIRECT3DDEVICE9 device,
                                                LPCWSTR srcfile,
                                                LPDIRECT3DVOLUMETEXTURE9 *volume);
#define        D3DXCreateVolumeTextureFromFile WINELIB_NAME_AW(D3DXCreateVolumeTextureFromFile)

HRESULT WINAPI D3DXCreateTextureFromResourceA(      LPDIRECT3DDEVICE9 device,
                                                    HMODULE srcmodule,
                                                    LPCSTR resource,
                                                    LPDIRECT3DTEXTURE9 *texture);

HRESULT WINAPI D3DXCreateTextureFromResourceW(      LPDIRECT3DDEVICE9 device,
                                                    HMODULE srcmodule,
                                                    LPCWSTR resource,
                                                    LPDIRECT3DTEXTURE9 *texture);
#define        D3DXCreateTextureFromResource WINELIB_NAME_AW(D3DXCreateTextureFromResource)

HRESULT WINAPI D3DXCreateCubeTextureFromResourceA(  LPDIRECT3DDEVICE9 device,
                                                    HMODULE srcmodule,
                                                    LPCSTR resource,
                                                    LPDIRECT3DCUBETEXTURE9 *cube);
HRESULT WINAPI D3DXCreateCubeTextureFromResourceW(  LPDIRECT3DDEVICE9 device,
                                                    HMODULE srcmodule,
                                                    LPCWSTR resource,
                                                    LPDIRECT3DCUBETEXTURE9 *cube);
#define        D3DXCreateCubeTextureFromResource WINELIB_NAME_AW(D3DXCreateCubeTextureFromResource)

HRESULT WINAPI D3DXCreateVolumeTextureFromResourceA(LPDIRECT3DDEVICE9 device,
                                                    HMODULE srcmodule,
                                                    LPCSTR resource,
                                                    LPDIRECT3DVOLUMETEXTURE9 *volume);
HRESULT WINAPI D3DXCreateVolumeTextureFromResourceW(LPDIRECT3DDEVICE9 device,
                                                    HMODULE srcmodule,
                                                    LPCWSTR resource,
                                                    LPDIRECT3DVOLUMETEXTURE9 *volume);
#define        D3DXCreateVolumeTextureFromResource WINELIB_NAME_AW(D3DXCreateVolumeTextureFromResource)

HRESULT WINAPI D3DXCreateTextureFromFileExA(      LPDIRECT3DDEVICE9 device,
                                                  LPCSTR srcfile,
                                                  UINT width,
                                                  UINT height,
                                                  UINT miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT format,
                                                  D3DPOOL pool,
                                                  DWORD filter,
                                                  DWORD mipfilter,
                                                  D3DCOLOR colorkey,
                                                  D3DXIMAGE_INFO *srcinfo,
                                                  PALETTEENTRY *palette,
                                                  LPDIRECT3DTEXTURE9 *texture);

HRESULT WINAPI D3DXCreateTextureFromFileExW(      LPDIRECT3DDEVICE9 device,
                                                  LPCWSTR srcfile,
                                                  UINT width,
                                                  UINT height,
                                                  UINT miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT format,
                                                  D3DPOOL pool,
                                                  DWORD filter,
                                                  DWORD mipfilter,
                                                  D3DCOLOR colorkey,
                                                  D3DXIMAGE_INFO *srcinfo,
                                                  PALETTEENTRY *palette,
                                                  LPDIRECT3DTEXTURE9 *texture);
#define        D3DXCreateTextureFromFileEx WINELIB_NAME_AW(D3DXCreateTextureFromFileEx)

HRESULT WINAPI D3DXCreateCubeTextureFromFileExA(  LPDIRECT3DDEVICE9 device,
                                                  LPCSTR srcfile,
                                                  UINT size,
                                                  UINT miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT format,
                                                  D3DPOOL pool,
                                                  DWORD filter,
                                                  DWORD mipfilter,
                                                  D3DCOLOR colorkey,
                                                  D3DXIMAGE_INFO *srcinfo,
                                                  PALETTEENTRY *palette,
                                                  LPDIRECT3DCUBETEXTURE9 *cube);

HRESULT WINAPI D3DXCreateCubeTextureFromFileExW(  LPDIRECT3DDEVICE9 device,
                                                  LPCWSTR srcfile,
                                                  UINT size,
                                                  UINT miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT format,
                                                  D3DPOOL pool,
                                                  DWORD filter,
                                                  DWORD mipfilter,
                                                  D3DCOLOR colorkey,
                                                  D3DXIMAGE_INFO *srcinfo,
                                                  PALETTEENTRY *palette,
                                                  LPDIRECT3DCUBETEXTURE9 *cube);
#define        D3DXCreateCubeTextureFromFileEx WINELIB_NAME_AW(D3DXCreateCubeTextureFromFileEx)

HRESULT WINAPI D3DXCreateVolumeTextureFromFileExA(LPDIRECT3DDEVICE9 device,
                                                  LPCSTR srcfile,
                                                  UINT width,
                                                  UINT height,
                                                  UINT depth,
                                                  UINT miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT format,
                                                  D3DPOOL pool,
                                                  DWORD filter,
                                                  DWORD mipfilter,
                                                  D3DCOLOR colorkey,
                                                  D3DXIMAGE_INFO *srcinfo,
                                                  PALETTEENTRY *palette,
                                                  LPDIRECT3DVOLUMETEXTURE9 *volume);

HRESULT WINAPI D3DXCreateVolumeTextureFromFileExW(LPDIRECT3DDEVICE9 device,
                                                  LPCWSTR srcfile,
                                                  UINT width,
                                                  UINT height,
                                                  UINT depth,
                                                  UINT miplevels,
                                                  DWORD usage,
                                                  D3DFORMAT format,
                                                  D3DPOOL pool,
                                                  DWORD filter,
                                                  DWORD mipfilter,
                                                  D3DCOLOR colorkey,
                                                  D3DXIMAGE_INFO *srcinfo,
                                                  PALETTEENTRY *palette,
                                                  LPDIRECT3DVOLUMETEXTURE9 *volume);
#define        D3DXCreateVolumeTextureFromFileEx WINELIB_NAME_AW(D3DXCreateVolumeTextureFromFileEx)

HRESULT WINAPI D3DXCreateTextureFromResourceExA(      LPDIRECT3DDEVICE9 device,
                                                      HMODULE srcmodule,
                                                      LPCSTR resource,
                                                      UINT width,
                                                      UINT height,
                                                      UINT miplevels,
                                                      DWORD usage,
                                                      D3DFORMAT format,
                                                      D3DPOOL pool,
                                                      DWORD filter,
                                                      DWORD mipfilter,
                                                      D3DCOLOR colorkey,
                                                      D3DXIMAGE_INFO *srcinfo,
                                                      PALETTEENTRY *palette,
                                                      LPDIRECT3DTEXTURE9 *texture);

HRESULT WINAPI D3DXCreateTextureFromResourceExW(      LPDIRECT3DDEVICE9 device,
                                                      HMODULE srcmodule,
                                                      LPCWSTR resource,
                                                      UINT width,
                                                      UINT height,
                                                      UINT miplevels,
                                                      DWORD usage,
                                                      D3DFORMAT format,
                                                      D3DPOOL pool,
                                                      DWORD filter,
                                                      DWORD mipfilter,
                                                      D3DCOLOR colorkey,
                                                      D3DXIMAGE_INFO *srcinfo,
                                                      PALETTEENTRY *palette,
                                                      LPDIRECT3DTEXTURE9 *texture);
#define        D3DXCreateTextureFromResourceEx WINELIB_NAME_AW(D3DXCreateTextureFromResourceEx)

HRESULT WINAPI D3DXCreateCubeTextureFromResourceExA(  LPDIRECT3DDEVICE9 device,
                                                      HMODULE srcmodule,
                                                      LPCSTR resource,
                                                      UINT size,
                                                      UINT miplevels,
                                                      DWORD usage,
                                                      D3DFORMAT format,
                                                      D3DPOOL pool,
                                                      DWORD filter,
                                                      DWORD mipfilter,
                                                      D3DCOLOR colorkey,
                                                      D3DXIMAGE_INFO *srcinfo,
                                                      PALETTEENTRY *palette,
                                                      LPDIRECT3DCUBETEXTURE9 *cube);

HRESULT WINAPI D3DXCreateCubeTextureFromResourceExW(  LPDIRECT3DDEVICE9 device,
                                                      HMODULE srcmodule,
                                                      LPCWSTR resource,
                                                      UINT size,
                                                      UINT miplevels,
                                                      DWORD usage,
                                                      D3DFORMAT format,
                                                      D3DPOOL pool,
                                                      DWORD filter,
                                                      DWORD mipfilter,
                                                      D3DCOLOR colorkey,
                                                      D3DXIMAGE_INFO *srcinfo,
                                                      PALETTEENTRY *palette,
                                                      LPDIRECT3DCUBETEXTURE9 *cube);
#define        D3DXCreateCubeTextureFromResourceEx WINELIB_NAME_AW(D3DXCreateCubeTextureFromResourceEx)

HRESULT WINAPI D3DXCreateVolumeTextureFromResourceExA(LPDIRECT3DDEVICE9 device,
                                                      HMODULE srcmodule,
                                                      LPCSTR resource,
                                                      UINT width,
                                                      UINT height,
                                                      UINT depth,
                                                      UINT miplevels,
                                                      DWORD usage,
                                                      D3DFORMAT format,
                                                      D3DPOOL pool,
                                                      DWORD filter,
                                                      DWORD mipfilter,
                                                      D3DCOLOR colorkey,
                                                      D3DXIMAGE_INFO *srcinfo,
                                                      PALETTEENTRY *palette,
                                                      LPDIRECT3DVOLUMETEXTURE9 *volume);

HRESULT WINAPI D3DXCreateVolumeTextureFromResourceExW(LPDIRECT3DDEVICE9 device,
                                                      HMODULE srcmodule,
                                                      LPCWSTR resource,
                                                      UINT width,
                                                      UINT height,
                                                      UINT depth,
                                                      UINT miplevels,
                                                      DWORD usage,
                                                      D3DFORMAT format,
                                                      D3DPOOL pool,
                                                      DWORD filter,
                                                      DWORD mipfilter,
                                                      D3DCOLOR colorkey,
                                                      D3DXIMAGE_INFO *srcinfo,
                                                      PALETTEENTRY *palette,
                                                      LPDIRECT3DVOLUMETEXTURE9 *volume);
#define        D3DXCreateVolumeTextureFromResourceEx WINELIB_NAME_AW(D3DXCreateVolumeTextureFromResourceEx)

HRESULT WINAPI D3DXCreateTextureFromFileInMemory(      LPDIRECT3DDEVICE9 device,
                                                       LPCVOID srcdata,
                                                       UINT srcdatasize,
                                                       LPDIRECT3DTEXTURE9* texture);

HRESULT WINAPI D3DXCreateCubeTextureFromFileInMemory(  LPDIRECT3DDEVICE9 device,
                                                       LPCVOID srcdata,
                                                       UINT srcdatasize,
                                                       LPDIRECT3DCUBETEXTURE9* cube);

HRESULT WINAPI D3DXCreateVolumeTextureFromFileInMemory(LPDIRECT3DDEVICE9 device,
                                                       LPCVOID srcdata,
                                                       UINT srcdatasize,
                                                       LPDIRECT3DVOLUMETEXTURE9 *volume);

HRESULT WINAPI D3DXCreateTextureFromFileInMemoryEx(      LPDIRECT3DDEVICE9 device,
                                                         LPCVOID srcdata,
                                                         UINT srcdatasize,
                                                         UINT width,
                                                         UINT height,
                                                         UINT miplevels,
                                                         DWORD usage,
                                                         D3DFORMAT format,
                                                         D3DPOOL pool,
                                                         DWORD filter,
                                                         DWORD mipfilter,
                                                         D3DCOLOR colorkey,
                                                         D3DXIMAGE_INFO *srcinfo,
                                                         PALETTEENTRY *palette,
                                                         LPDIRECT3DTEXTURE9 *texture);

HRESULT WINAPI D3DXCreateCubeTextureFromFileInMemoryEx(  LPDIRECT3DDEVICE9 device,
                                                         LPCVOID srcdata,
                                                         UINT srcdatasize,
                                                         UINT size,
                                                         UINT miplevels,
                                                         DWORD usage,
                                                         D3DFORMAT format,
                                                         D3DPOOL pool,
                                                         DWORD filter,
                                                         DWORD mipfilter,
                                                         D3DCOLOR colorkey,
                                                         D3DXIMAGE_INFO *srcinfo,
                                                         PALETTEENTRY *palette,
                                                         LPDIRECT3DCUBETEXTURE9 *cube);

HRESULT WINAPI D3DXCreateVolumeTextureFromFileInMemoryEx(LPDIRECT3DDEVICE9 device,
                                                         LPCVOID srcdata,
                                                         UINT srcdatasize,
                                                         UINT width,
                                                         UINT height,
                                                         UINT depth,
                                                         UINT miplevels,
                                                         DWORD usage,
                                                         D3DFORMAT format,
                                                         D3DPOOL pool,
                                                         DWORD filter,
                                                         DWORD mipfilter,
                                                         D3DCOLOR colorkey,
                                                         D3DXIMAGE_INFO *srcinfo,
                                                         PALETTEENTRY *palette,
                                                         LPDIRECT3DVOLUMETEXTURE9 *volume);

HRESULT WINAPI D3DXSaveTextureToFileA(LPCSTR destfile,
                                      D3DXIMAGE_FILEFORMAT destformat,
                                      LPDIRECT3DBASETEXTURE9 srctexture,
                                      CONST PALETTEENTRY *srcpalette);
HRESULT WINAPI D3DXSaveTextureToFileW(LPCWSTR destfile,
                                      D3DXIMAGE_FILEFORMAT destformat,
                                      LPDIRECT3DBASETEXTURE9 srctexture,
                                      CONST PALETTEENTRY *srcpalette);
#define        D3DXSaveTextureToFile WINELIB_NAME_AW(D3DXSaveTextureToFile)


/* Other functions */
HRESULT WINAPI D3DXFilterTexture(      LPDIRECT3DBASETEXTURE9 texture,
                                       CONST PALETTEENTRY *palette,
                                       UINT srclevel,
                                       DWORD filter);
#define D3DXFilterCubeTexture D3DXFilterTexture
#define D3DXFilterVolumeTexture D3DXFilterTexture

HRESULT WINAPI D3DXFillTexture(        LPDIRECT3DTEXTURE9 texture,
                                       LPD3DXFILL2D function,
                                       LPVOID data);

HRESULT WINAPI D3DXFillCubeTexture(    LPDIRECT3DCUBETEXTURE9 cube,
                                       LPD3DXFILL3D function,
                                       LPVOID data);

HRESULT WINAPI D3DXFillVolumeTexture(  LPDIRECT3DVOLUMETEXTURE9 volume,
                                       LPD3DXFILL3D function,
                                       LPVOID data);

HRESULT WINAPI D3DXFillTextureTX(      LPDIRECT3DTEXTURE9 texture,
                                       CONST DWORD *function,
                                       CONST D3DXVECTOR4 *constants,
                                       UINT numconstants);

HRESULT WINAPI D3DXFillCubeTextureTX(  LPDIRECT3DCUBETEXTURE9 cube,
                                       CONST DWORD *function,
                                       CONST D3DXVECTOR4 *constants,
                                       UINT numconstants);

HRESULT WINAPI D3DXFillVolumeTextureTX(LPDIRECT3DVOLUMETEXTURE9 volume,
                                       CONST DWORD *function,
                                       CONST D3DXVECTOR4 *constants,
                                       UINT numconstants);

HRESULT WINAPI D3DXComputeNormalMap(   LPDIRECT3DTEXTURE9 texture,
                                       LPDIRECT3DTEXTURE9 srctexture,
                                       CONST PALETTEENTRY *srcpalette,
                                       DWORD flags,
                                       DWORD channel,
                                       FLOAT amplitude);


#ifdef __cplusplus
}
#endif

#endif /* __WINE_D3DX9TEX_H */