Convert Figma logo to code with AI

microsoft logoDirectXTex

DirectXTex texture processing library

1,790
437
1,790
37
View on GitHub

Top Related Projects

BinomialLLC's avatar

basis_universal

2,661

Basis Universal GPU Texture Codec

nothings's avatar

stb

26,312

stb single-file public domain libraries for C/C++

Quick Overview

DirectXTex is a collection of texture processing and texture content authoring tools for Direct3D applications. It provides a set of lightweight and efficient C++ libraries for working with DirectX textures, including loading, saving, and manipulating various texture formats.

Pros

  • Comprehensive support for DirectX texture formats
  • Efficient and optimized for performance
  • Actively maintained by Microsoft
  • Includes command-line tools for texture processing

Cons

  • Limited to DirectX-specific formats
  • Steeper learning curve for beginners
  • Requires C++ knowledge for integration
  • Windows-centric, may not be suitable for cross-platform development

Code Examples

Loading a texture from a file:

#include <DirectXTex.h>

DirectX::ScratchImage image;
HRESULT hr = DirectX::LoadFromWICFile(L"texture.png", DirectX::WIC_FLAGS_NONE, nullptr, image);
if (SUCCEEDED(hr))
{
    // Texture loaded successfully
}

Saving a texture to a file:

#include <DirectXTex.h>

DirectX::ScratchImage image;
// Assume image is populated with texture data
HRESULT hr = DirectX::SaveToWICFile(image.GetImages(), image.GetImageCount(), DirectX::WIC_FLAGS_NONE,
                                    GUID_ContainerFormatPng, L"output.png", nullptr);
if (SUCCEEDED(hr))
{
    // Texture saved successfully
}

Resizing a texture:

#include <DirectXTex.h>

DirectX::ScratchImage sourceImage, resizedImage;
// Assume sourceImage is populated with texture data
HRESULT hr = DirectX::Resize(sourceImage.GetImages(), sourceImage.GetImageCount(), sourceImage.GetMetadata(),
                             newWidth, newHeight, DirectX::TEX_FILTER_DEFAULT, resizedImage);
if (SUCCEEDED(hr))
{
    // Texture resized successfully
}

Getting Started

  1. Clone the repository:

    git clone https://github.com/microsoft/DirectXTex.git

  2. Open the solution file in Visual Studio.

  3. Build the project for your desired configuration.

  4. Include the necessary headers in your project:

    #include <DirectXTex.h>

  5. Link against the built library in your project settings.

  6. Use the DirectXTex functions in your code as shown in the examples above.

Competitor Comparisons

BinomialLLC logo

basis_universal

2,661

Basis Universal GPU Texture Codec

Pros of basis_universal

  • Supports a wider range of texture compression formats, including ETC1S and UASTC
  • Provides better compression ratios for certain use cases, especially in web and mobile applications
  • Offers cross-platform compatibility with WebGL, mobile, and desktop platforms

Cons of basis_universal

  • Less integrated with DirectX ecosystem compared to DirectXTex
  • May have a steeper learning curve for developers primarily working with DirectX
  • Limited support for some specialized DirectX-specific texture formats

Code Comparison

basis_universal:

basisu::basisu_encoder_init();
basisu::basis_compressor_params params;
params.m_quality_level = 128;
basisu::basis_compressor compressor(params);
compressor.init(width, height, has_alpha);

DirectXTex:

DirectX::ScratchImage image;
DirectX::LoadFromWICFile(L"texture.png", DirectX::WIC_FLAGS_NONE, nullptr, image);
DirectX::ScratchImage compressedImage;
DirectX::Compress(image.GetImages(), image.GetImageCount(), image.GetMetadata(), DXGI_FORMAT_BC7_UNORM, DirectX::TEX_COMPRESS_PARALLEL, 1.0f, compressedImage);
nothings logo

stb

26,312

stb single-file public domain libraries for C/C++

Pros of stb

  • Single-file, header-only library for easy integration
  • Supports a wide range of image formats
  • Platform-independent and requires no external dependencies

Cons of stb

  • Limited functionality compared to DirectXTex
  • May have slower performance for certain operations
  • Less optimized for DirectX-specific use cases

Code Comparison

stb

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

int width, height, channels;
unsigned char *img = stbi_load("image.jpg", &width, &height, &channels, 0);

DirectXTex

#include <DirectXTex.h>

DirectX::ScratchImage image;
HRESULT hr = DirectX::LoadFromWICFile(L"image.jpg", DirectX::WIC_FLAGS_NONE, nullptr, image);

The stb library offers a simpler API for basic image loading, while DirectXTex provides more advanced functionality tailored for DirectX applications. stb is easier to integrate and use for simple tasks, but DirectXTex offers better performance and more features for DirectX-specific projects.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

DirectX Logo

DirectXTex texture processing library

http://go.microsoft.com/fwlink/?LinkId=248926

Copyright (c) Microsoft Corporation.

September 4, 2024

This package contains DirectXTex, a shared source library for reading and writing .DDS files, and performing various texture content processing operations including resizing, format conversion, mip-map generation, block compression for Direct3D runtime texture resources, and height-map to normal-map conversion. This library makes use of the Windows Image Component (WIC) APIs. It also includes .TGA and .HDR readers and writers since these image file formats are commonly used for texture content processing pipelines, but are not currently supported by a built-in WIC codec.

This code is designed to build with Visual Studio 2019 (16.11), Visual Studio 2022, clang for Windows v12 or later, or MinGW 12.2. Use of the Windows 10 May 2020 Update SDK (19041) or later is required for Visual Studio. It can also be built for Windows Subsystem for Linux using GCC 11 or later.

These components are designed to work without requiring any content from the legacy DirectX SDK. For details, see Where is the DirectX SDK?.

Directory Layout

  • DirectXTex\

    • This contains the DirectXTex library. This includes a full-featured DDS reader and writer including legacy format conversions, a TGA reader and writer, a HDR reader and writer, a WIC-based bitmap reader and writer (BMP, JPEG, PNG, TIFF, and HD Photo), and various texture processing functions. This is intended primarily for tool usage.

The majority of the header files here are intended for internal implementation of the library only (BC.h, BCDirectCompute.h, DDS.h, DirectXTexP.h, etc.). Only DirectXTex.h and DirectXTex.inl are meant as the 'public' header for the library.

  • Auxiliary\

    • Contains optional source files for the DirectXTex library, such as adapter loading functions using the OpenEXR library, Xbox texture tiling extensions, etc.

  • Texconv\

    • This DirectXTex sample is an implementation of the texconv command-line texture utility from the DirectX SDK utilizing DirectXTex rather than D3DX.

      It supports the same arguments as the Texture Conversion Tool Extended (texconvex.exe) legacy DirectX SDK utility. The primary differences are the -10 and -11 arguments are not applicable and the filter names (POINT, LINEAR, CUBIC, FANT or BOX, TRIANGLE, *_DITHER, *_DITHER_DIFFUSION). This also includes support for the JPEG XR (HD Photo) bitmap format.

  • Texassemble\

    • This DirectXTex sample is a command-line utility for creating cubemaps, volume maps, or texture arrays from a set of individual input image files.

  • Texdiag\

    • This DirectXTex sample is a command-line utility for analyzing image contents, primarily for debugging purposes.

  • DDSView\

    • This DirectXTex sample is a simple Direct3D 11-based viewer for DDS files. For array textures or volume maps, the "<" and ">" keyboard keys will show different images contained in the DDS. The "1" through "0" keys can also be used to jump to a specific image index.

  • DDSTextureLoader\

    • This contains a streamlined version of the legacy DirectX SDK sample DDSWithoutD3DX11 texture loading code for a simple light-weight runtime DDS loader. There are versions for Direct3D 9, Direct3D 11, and Direct3D 12. This performs no runtime pixel data conversions. This is ideal for runtime usage, and supports the full complement of Direct3D texture resources (1D, 2D, volume maps, cubemaps, mipmap levels, texture arrays, BC formats, etc.).

  • ScreenGrab\

    • This contains texture writing modules for Direct3D 9, Direct3D 11, and Direct3D 12 primarily intended for creating screenshots. The images are written as a DDS or as an image file format using WIC.

  • WICTextureLoader\

    • This contains a Direct3D 9, Direct3D 11 and Direct3D 12 2D texture loader that uses WIC to load a bitmap (BMP, JPEG, PNG, HD Photo, or other WIC supported file container), resize if needed based on the current feature level (or by explicit parameter), format convert to a DXGI_FORMAT if required, and then create a 2D texture. Note this does not support 1D textures, volume textures, cubemaps, or texture arrays. DDSTextureLoader is recommended for fully "precooked" textures for maximum performance and image quality, but this loader can be useful for creating simple 2D texture from standard image files at runtime.

DDSTextureLoader11, ScreenGrab11, and WICTextureLoader11 are 'stand-alone' versions of the same modules provided in the DirectX Tool Kit for DX11

DDSTextureLoader12, ScreenGrab12, and WICTextureLoader12 are 'stand-alone' versions of the same modules provided in the DirectX Tool Kit for DX12.

  • build\

    • Contains YAML files for the build pipelines along with some miscellaneous build files and scripts.

Documentation

Documentation is available on the GitHub wiki.

Notices

All content and source code for this package are subject to the terms of the MIT License.

For the latest version of DirectXTex, bug reports, etc. please visit the project site on GitHub.

Release Notes

FOR SECURITY ADVISORIES, see GitHub.

For a full change history, see CHANGELOG.md.

  • Starting with the July 2022 release, the bool forceSRGB parameter for the CreateTextureEx and CreateShaderResourceViewEx functions is now a CREATETEX_FLAGS typed enum bitmask flag parameter. This may have a breaking change impact to client code. Replace true with CREATETEX_FORCE_SRGB and false with CREATETEX_DEFAULT.

  • Starting with the June 2020 release, this library makes use of typed enum bitmask flags per the recommendation of the C++ Standard section 17.5.2.1.3 Bitmask types. This is consistent with Direct3D 12's use of the DEFINE_ENUM_FLAG_OPERATORS macro. This may have breaking change impacts to client code:

    • You cannot pass the 0 literal as your flags value. Instead you must make use of the appropriate default enum value: CP_FLAGS_NONE, DDS_FLAGS_NONE, WIC_FLAGS_NONE, TEX_FR_ROTATE0, TEX_FILTER_DEFAULT, TEX_FILTER_DEFAULT, TEX_FILTER_DEFAULT, CNMAP_DEFAULT, or CNMAP_DEFAULT.

    • Use the enum type instead of DWORD if building up flags values locally with bitmask operations. For example, DDS_FLAGS flags = DDS_FLAGS_NONE; if (...) flags |= DDS_FLAGS_EXPAND_LUMINANCE;

    • In cases where some of the flags overlap, you can use the | to combine the relevant types: TEX_FILTER_FLAGS filter modes combine with WIC_FLAGS, TEX_FILTER_FLAGS sRGB flags combine with TEX_PMALPHA_FLAGS or TEX_COMPRESS_FLAGS. No other bitwise operators are defined. For example, WIC_FLAGS wicFlags = WIC_FLAGS_NONE | TEX_FILTER_CUBIC;

  • WICTextureLoader cannot load .TGA or .HDR files unless the system has a 3rd party WIC codec installed. You must use the DirectXTex library for TGA/HDR file format support without relying on an add-on WIC codec.

  • The UWP projects and the Win10 classic desktop project include configurations for the ARM64 platform. Building these requires installing the ARM64 toolset.

  • When using clang/LLVM for the ARM64 platform, the Windows 11 SDK (22000) or later is required.

  • The CompileShaders.cmd script must have Windows-style (CRLF) line-endings. If it is changed to Linux-style (LF) line-endings, it can fail to build all the required shaders.

Support

For questions, consider using Stack Overflow with the directxtk tag, or the DirectX Discord Server in the dx12-developers or dx9-dx11-developers channel.

For bug reports and feature requests, please use GitHub issues for this project.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.

When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

Tests for new features should also be submitted as a PR to the Test Suite repository.

Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft's Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies.

Credits

The DirectXTex library is the work of Chuck Walbourn, with contributions from Matt Lee, Xin Huang, Craig Peeper, and the numerous other Microsoft engineers who developed the D3DX utility library over the years.

Thanks to Paul Penson for his help with the implementation of MemoryStreamOnBlob.

Thanks to Andrew Farrier and Scott Matloff for their on-going help with code reviews.

Thanks to Park DongHa for their contribution of the JPEG/PNG auxiliary functions.