feat: modules moved and engine moved to submodule
This commit is contained in:
Jan van der Weide
parent
dfb5e645cd
commit
c33d2130cc
5136 changed files with 225275 additions and 64485 deletions
|
|
@ -30,171 +30,13 @@
|
|||
|
||||
#include "texture_loader_dds.h"
|
||||
|
||||
#include "dds_enums.h"
|
||||
|
||||
#include "core/io/file_access.h"
|
||||
#include "core/io/file_access_memory.h"
|
||||
#include "scene/resources/image_texture.h"
|
||||
|
||||
#define PF_FOURCC(s) ((uint32_t)(((s)[3] << 24U) | ((s)[2] << 16U) | ((s)[1] << 8U) | ((s)[0])))
|
||||
|
||||
// Reference: https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dds-header
|
||||
|
||||
enum {
|
||||
DDS_MAGIC = 0x20534444,
|
||||
DDSD_PITCH = 0x00000008,
|
||||
DDSD_LINEARSIZE = 0x00080000,
|
||||
DDSD_MIPMAPCOUNT = 0x00020000,
|
||||
DDPF_ALPHAPIXELS = 0x00000001,
|
||||
DDPF_ALPHAONLY = 0x00000002,
|
||||
DDPF_FOURCC = 0x00000004,
|
||||
DDPF_RGB = 0x00000040,
|
||||
DDPF_RG_SNORM = 0x00080000,
|
||||
DDSC2_CUBEMAP = 0x200,
|
||||
DDSC2_VOLUME = 0x200000,
|
||||
DX10D_1D = 2,
|
||||
DX10D_2D = 3,
|
||||
DX10D_3D = 4,
|
||||
};
|
||||
|
||||
enum DDSFourCC {
|
||||
DDFCC_DXT1 = PF_FOURCC("DXT1"),
|
||||
DDFCC_DXT2 = PF_FOURCC("DXT2"),
|
||||
DDFCC_DXT3 = PF_FOURCC("DXT3"),
|
||||
DDFCC_DXT4 = PF_FOURCC("DXT4"),
|
||||
DDFCC_DXT5 = PF_FOURCC("DXT5"),
|
||||
DDFCC_ATI1 = PF_FOURCC("ATI1"),
|
||||
DDFCC_BC4U = PF_FOURCC("BC4U"),
|
||||
DDFCC_ATI2 = PF_FOURCC("ATI2"),
|
||||
DDFCC_BC5U = PF_FOURCC("BC5U"),
|
||||
DDFCC_A2XY = PF_FOURCC("A2XY"),
|
||||
DDFCC_DX10 = PF_FOURCC("DX10"),
|
||||
DDFCC_R16F = 111,
|
||||
DDFCC_RG16F = 112,
|
||||
DDFCC_RGBA16F = 113,
|
||||
DDFCC_R32F = 114,
|
||||
DDFCC_RG32F = 115,
|
||||
DDFCC_RGBA32F = 116
|
||||
};
|
||||
|
||||
// Reference: https://learn.microsoft.com/en-us/windows/win32/api/dxgiformat/ne-dxgiformat-dxgi_format
|
||||
enum DXGIFormat {
|
||||
DXGI_R32G32B32A32_FLOAT = 2,
|
||||
DXGI_R32G32B32_FLOAT = 6,
|
||||
DXGI_R16G16B16A16_FLOAT = 10,
|
||||
DXGI_R32G32_FLOAT = 16,
|
||||
DXGI_R10G10B10A2_UNORM = 24,
|
||||
DXGI_R8G8B8A8_UNORM = 28,
|
||||
DXGI_R8G8B8A8_UNORM_SRGB = 29,
|
||||
DXGI_R16G16_FLOAT = 34,
|
||||
DXGI_R32_FLOAT = 41,
|
||||
DXGI_R8G8_UNORM = 49,
|
||||
DXGI_R16_FLOAT = 54,
|
||||
DXGI_R8_UNORM = 61,
|
||||
DXGI_A8_UNORM = 65,
|
||||
DXGI_R9G9B9E5 = 67,
|
||||
DXGI_BC1_UNORM = 71,
|
||||
DXGI_BC1_UNORM_SRGB = 72,
|
||||
DXGI_BC2_UNORM = 74,
|
||||
DXGI_BC2_UNORM_SRGB = 75,
|
||||
DXGI_BC3_UNORM = 77,
|
||||
DXGI_BC3_UNORM_SRGB = 78,
|
||||
DXGI_BC4_UNORM = 80,
|
||||
DXGI_BC5_UNORM = 83,
|
||||
DXGI_B5G6R5_UNORM = 85,
|
||||
DXGI_B5G5R5A1_UNORM = 86,
|
||||
DXGI_B8G8R8A8_UNORM = 87,
|
||||
DXGI_BC6H_UF16 = 95,
|
||||
DXGI_BC6H_SF16 = 96,
|
||||
DXGI_BC7_UNORM = 98,
|
||||
DXGI_BC7_UNORM_SRGB = 99,
|
||||
DXGI_B4G4R4A4_UNORM = 115
|
||||
};
|
||||
|
||||
// The legacy bitmasked format names here represent the actual data layout in the files,
|
||||
// while their official names are flipped (e.g. RGBA8 layout is officially called ABGR8).
|
||||
enum DDSFormat {
|
||||
DDS_DXT1,
|
||||
DDS_DXT3,
|
||||
DDS_DXT5,
|
||||
DDS_ATI1,
|
||||
DDS_ATI2,
|
||||
DDS_BC6U,
|
||||
DDS_BC6S,
|
||||
DDS_BC7,
|
||||
DDS_R16F,
|
||||
DDS_RG16F,
|
||||
DDS_RGBA16F,
|
||||
DDS_R32F,
|
||||
DDS_RG32F,
|
||||
DDS_RGB32F,
|
||||
DDS_RGBA32F,
|
||||
DDS_RGB9E5,
|
||||
DDS_RGB8,
|
||||
DDS_RGBA8,
|
||||
DDS_BGR8,
|
||||
DDS_BGRA8,
|
||||
DDS_BGR5A1,
|
||||
DDS_BGR565,
|
||||
DDS_B2GR3,
|
||||
DDS_B2GR3A8,
|
||||
DDS_BGR10A2,
|
||||
DDS_RGB10A2,
|
||||
DDS_BGRA4,
|
||||
DDS_LUMINANCE,
|
||||
DDS_LUMINANCE_ALPHA,
|
||||
DDS_LUMINANCE_ALPHA_4,
|
||||
DDS_MAX
|
||||
};
|
||||
|
||||
enum DDSType {
|
||||
DDST_2D = 1,
|
||||
DDST_CUBEMAP,
|
||||
DDST_3D,
|
||||
|
||||
DDST_TYPE_MASK = 0x7F,
|
||||
DDST_ARRAY = 0x80,
|
||||
};
|
||||
|
||||
struct DDSFormatInfo {
|
||||
const char *name = nullptr;
|
||||
bool compressed = false;
|
||||
uint32_t divisor = 0;
|
||||
uint32_t block_size = 0;
|
||||
Image::Format format = Image::Format::FORMAT_BPTC_RGBA;
|
||||
};
|
||||
|
||||
static const DDSFormatInfo dds_format_info[DDS_MAX] = {
|
||||
{ "DXT1/BC1", true, 4, 8, Image::FORMAT_DXT1 },
|
||||
{ "DXT2/DXT3/BC2", true, 4, 16, Image::FORMAT_DXT3 },
|
||||
{ "DXT4/DXT5/BC3", true, 4, 16, Image::FORMAT_DXT5 },
|
||||
{ "ATI1/BC4", true, 4, 8, Image::FORMAT_RGTC_R },
|
||||
{ "ATI2/A2XY/BC5", true, 4, 16, Image::FORMAT_RGTC_RG },
|
||||
{ "BC6UF", true, 4, 16, Image::FORMAT_BPTC_RGBFU },
|
||||
{ "BC6SF", true, 4, 16, Image::FORMAT_BPTC_RGBF },
|
||||
{ "BC7", true, 4, 16, Image::FORMAT_BPTC_RGBA },
|
||||
{ "R16F", false, 1, 2, Image::FORMAT_RH },
|
||||
{ "RG16F", false, 1, 4, Image::FORMAT_RGH },
|
||||
{ "RGBA16F", false, 1, 8, Image::FORMAT_RGBAH },
|
||||
{ "R32F", false, 1, 4, Image::FORMAT_RF },
|
||||
{ "RG32F", false, 1, 8, Image::FORMAT_RGF },
|
||||
{ "RGB32F", false, 1, 12, Image::FORMAT_RGBF },
|
||||
{ "RGBA32F", false, 1, 16, Image::FORMAT_RGBAF },
|
||||
{ "RGB9E5", false, 1, 4, Image::FORMAT_RGBE9995 },
|
||||
{ "RGB8", false, 1, 3, Image::FORMAT_RGB8 },
|
||||
{ "RGBA8", false, 1, 4, Image::FORMAT_RGBA8 },
|
||||
{ "BGR8", false, 1, 3, Image::FORMAT_RGB8 },
|
||||
{ "BGRA8", false, 1, 4, Image::FORMAT_RGBA8 },
|
||||
{ "BGR5A1", false, 1, 2, Image::FORMAT_RGBA8 },
|
||||
{ "BGR565", false, 1, 2, Image::FORMAT_RGB8 },
|
||||
{ "B2GR3", false, 1, 1, Image::FORMAT_RGB8 },
|
||||
{ "B2GR3A8", false, 1, 2, Image::FORMAT_RGBA8 },
|
||||
{ "BGR10A2", false, 1, 4, Image::FORMAT_RGBA8 },
|
||||
{ "RGB10A2", false, 1, 4, Image::FORMAT_RGBA8 },
|
||||
{ "BGRA4", false, 1, 2, Image::FORMAT_RGBA8 },
|
||||
{ "GRAYSCALE", false, 1, 1, Image::FORMAT_L8 },
|
||||
{ "GRAYSCALE_ALPHA", false, 1, 2, Image::FORMAT_LA8 },
|
||||
{ "GRAYSCALE_ALPHA_4", false, 1, 1, Image::FORMAT_LA8 }
|
||||
};
|
||||
|
||||
inline DDSFormat _dxgi_to_dds_format(uint32_t p_dxgi_format) {
|
||||
DDSFormat _dxgi_to_dds_format(uint32_t p_dxgi_format) {
|
||||
switch (p_dxgi_format) {
|
||||
case DXGI_R32G32B32A32_FLOAT: {
|
||||
return DDS_RGBA32F;
|
||||
|
|
@ -323,8 +165,8 @@ static Ref<Image> _dds_load_layer(Ref<FileAccess> p_file, DDSFormat p_dds_format
|
|||
uint32_t size = p_width * p_height * info.block_size;
|
||||
|
||||
for (uint32_t i = 1; i < p_mipmaps; i++) {
|
||||
w = (w + 1) >> 1;
|
||||
h = (h + 1) >> 1;
|
||||
w = MAX(1u, w >> 1);
|
||||
h = MAX(1u, h >> 1);
|
||||
size += w * h * info.block_size;
|
||||
}
|
||||
|
||||
|
|
@ -543,7 +385,295 @@ static Ref<Image> _dds_load_layer(Ref<FileAccess> p_file, DDSFormat p_dds_format
|
|||
return memnew(Image(p_width, p_height, p_mipmaps > 1, info.format, r_src_data));
|
||||
}
|
||||
|
||||
Ref<Resource> ResourceFormatDDS::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
static Vector<Ref<Image>> _dds_load_images(Ref<FileAccess> p_f, DDSFormat p_dds_format, uint32_t p_width, uint32_t p_height, uint32_t p_mipmaps, uint32_t p_pitch, uint32_t p_flags, uint32_t p_layer_count) {
|
||||
Vector<uint8_t> src_data;
|
||||
Vector<Ref<Image>> images;
|
||||
images.resize(p_layer_count);
|
||||
|
||||
for (uint32_t i = 0; i < p_layer_count; i++) {
|
||||
images.write[i] = _dds_load_layer(p_f, p_dds_format, p_width, p_height, p_mipmaps, p_pitch, p_flags, src_data);
|
||||
}
|
||||
|
||||
return images;
|
||||
}
|
||||
|
||||
static Ref<Resource> _dds_create_texture(const Vector<Ref<Image>> &p_images, uint32_t p_dds_type, uint32_t p_width, uint32_t p_height, uint32_t p_layer_count, uint32_t p_mipmaps, Error *r_error) {
|
||||
if ((p_dds_type & DDST_TYPE_MASK) == DDST_2D) {
|
||||
if (p_dds_type & DDST_ARRAY) {
|
||||
Ref<Texture2DArray> texture;
|
||||
texture.instantiate();
|
||||
texture->create_from_images(p_images);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return texture;
|
||||
|
||||
} else {
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return ImageTexture::create_from_image(p_images[0]);
|
||||
}
|
||||
|
||||
} else if ((p_layer_count & DDST_TYPE_MASK) == DDST_CUBEMAP) {
|
||||
ERR_FAIL_COND_V(p_layer_count % 6 != 0, Ref<Resource>());
|
||||
|
||||
if (p_dds_type & DDST_ARRAY) {
|
||||
Ref<CubemapArray> texture;
|
||||
texture.instantiate();
|
||||
texture->create_from_images(p_images);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return texture;
|
||||
|
||||
} else {
|
||||
Ref<Cubemap> texture;
|
||||
texture.instantiate();
|
||||
texture->create_from_images(p_images);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
} else if ((p_dds_type & DDST_TYPE_MASK) == DDST_3D) {
|
||||
Ref<ImageTexture3D> texture;
|
||||
texture.instantiate();
|
||||
texture->create(p_images[0]->get_format(), p_width, p_height, p_layer_count, p_mipmaps > 1, p_images);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
static Ref<Resource> _dds_create_texture_from_images(const Vector<Ref<Image>> &p_images, DDSFormat p_dds_format, uint32_t p_width, uint32_t p_height, uint32_t p_mipmaps, uint32_t p_pitch, uint32_t p_flags, uint32_t p_layer_count, uint32_t p_dds_type, Error *r_error) {
|
||||
return _dds_create_texture(p_images, p_dds_type, p_width, p_height, p_layer_count, p_mipmaps, r_error);
|
||||
}
|
||||
|
||||
static Vector<Ref<Image>> _dds_load_images_from_buffer(Ref<FileAccess> p_f, DDSFormat &r_dds_format, uint32_t &r_width, uint32_t &r_height, uint32_t &r_mipmaps, uint32_t &r_pitch, uint32_t &r_flags, uint32_t &r_layer_count, uint32_t &r_dds_type, const String &p_path = "") {
|
||||
ERR_FAIL_COND_V_MSG(p_f.is_null(), Vector<Ref<Image>>(), vformat("Empty DDS texture file."));
|
||||
ERR_FAIL_COND_V_MSG(!p_f->get_length(), Vector<Ref<Image>>(), vformat("Empty DDS texture file."));
|
||||
|
||||
uint32_t magic = p_f->get_32();
|
||||
uint32_t hsize = p_f->get_32();
|
||||
r_flags = p_f->get_32();
|
||||
r_height = p_f->get_32();
|
||||
r_width = p_f->get_32();
|
||||
r_pitch = p_f->get_32();
|
||||
uint32_t depth = p_f->get_32();
|
||||
r_mipmaps = p_f->get_32();
|
||||
|
||||
// Skip reserved.
|
||||
for (int i = 0; i < 11; i++) {
|
||||
p_f->get_32();
|
||||
}
|
||||
|
||||
// Validate.
|
||||
// We don't check DDSD_CAPS or DDSD_PIXELFORMAT, as they're mandatory when writing,
|
||||
// but non-mandatory when reading (as some writers don't set them).
|
||||
if (magic != DDS_MAGIC || hsize != 124) {
|
||||
ERR_FAIL_V_MSG(Vector<Ref<Image>>(), vformat("Invalid or unsupported DDS texture file '%s'.", p_path));
|
||||
}
|
||||
|
||||
/* uint32_t format_size = */ p_f->get_32();
|
||||
uint32_t format_flags = p_f->get_32();
|
||||
uint32_t format_fourcc = p_f->get_32();
|
||||
uint32_t format_rgb_bits = p_f->get_32();
|
||||
uint32_t format_red_mask = p_f->get_32();
|
||||
uint32_t format_green_mask = p_f->get_32();
|
||||
uint32_t format_blue_mask = p_f->get_32();
|
||||
uint32_t format_alpha_mask = p_f->get_32();
|
||||
|
||||
/* uint32_t caps_1 = */ p_f->get_32();
|
||||
uint32_t caps_2 = p_f->get_32();
|
||||
/* uint32_t caps_3 = */ p_f->get_32();
|
||||
/* uint32_t caps_4 = */ p_f->get_32();
|
||||
|
||||
// Skip reserved.
|
||||
p_f->get_32();
|
||||
|
||||
if (p_f->get_position() < 128) {
|
||||
p_f->seek(128);
|
||||
}
|
||||
|
||||
r_layer_count = 1;
|
||||
r_dds_type = DDST_2D;
|
||||
|
||||
if (caps_2 & DDSC2_CUBEMAP) {
|
||||
r_dds_type = DDST_CUBEMAP;
|
||||
r_layer_count *= 6;
|
||||
|
||||
} else if (caps_2 & DDSC2_VOLUME) {
|
||||
r_dds_type = DDST_3D;
|
||||
r_layer_count = depth;
|
||||
}
|
||||
|
||||
r_dds_format = DDS_MAX;
|
||||
|
||||
if (format_flags & DDPF_FOURCC) {
|
||||
// FourCC formats.
|
||||
switch (format_fourcc) {
|
||||
case DDFCC_DXT1: {
|
||||
r_dds_format = DDS_DXT1;
|
||||
} break;
|
||||
case DDFCC_DXT2:
|
||||
case DDFCC_DXT3: {
|
||||
r_dds_format = DDS_DXT3;
|
||||
} break;
|
||||
case DDFCC_DXT4:
|
||||
case DDFCC_DXT5: {
|
||||
r_dds_format = DDS_DXT5;
|
||||
} break;
|
||||
case DDFCC_ATI1:
|
||||
case DDFCC_BC4U: {
|
||||
r_dds_format = DDS_ATI1;
|
||||
} break;
|
||||
case DDFCC_ATI2:
|
||||
case DDFCC_BC5U:
|
||||
case DDFCC_A2XY: {
|
||||
r_dds_format = DDS_ATI2;
|
||||
} break;
|
||||
case DDFCC_R16F: {
|
||||
r_dds_format = DDS_R16F;
|
||||
} break;
|
||||
case DDFCC_RG16F: {
|
||||
r_dds_format = DDS_RG16F;
|
||||
} break;
|
||||
case DDFCC_RGBA16F: {
|
||||
r_dds_format = DDS_RGBA16F;
|
||||
} break;
|
||||
case DDFCC_R32F: {
|
||||
r_dds_format = DDS_R32F;
|
||||
} break;
|
||||
case DDFCC_RG32F: {
|
||||
r_dds_format = DDS_RG32F;
|
||||
} break;
|
||||
case DDFCC_RGBA32F: {
|
||||
r_dds_format = DDS_RGBA32F;
|
||||
} break;
|
||||
case DDFCC_DX10: {
|
||||
uint32_t dxgi_format = p_f->get_32();
|
||||
uint32_t dimension = p_f->get_32();
|
||||
/* uint32_t misc_flags_1 = */ p_f->get_32();
|
||||
uint32_t array_size = p_f->get_32();
|
||||
/* uint32_t misc_flags_2 = */ p_f->get_32();
|
||||
|
||||
if (dimension == DX10D_3D) {
|
||||
r_dds_type = DDST_3D;
|
||||
r_layer_count = depth;
|
||||
}
|
||||
|
||||
if (array_size > 1) {
|
||||
r_layer_count *= array_size;
|
||||
r_dds_type |= DDST_ARRAY;
|
||||
}
|
||||
|
||||
r_dds_format = _dxgi_to_dds_format(dxgi_format);
|
||||
} break;
|
||||
|
||||
default: {
|
||||
ERR_FAIL_V_MSG(Vector<Ref<Image>>(), vformat("Unrecognized or unsupported FourCC in DDS '%s'.", p_path));
|
||||
}
|
||||
}
|
||||
|
||||
} else if (format_flags & DDPF_RGB) {
|
||||
// Channel-bitmasked formats.
|
||||
if (format_flags & DDPF_ALPHAPIXELS) {
|
||||
// With alpha.
|
||||
if (format_rgb_bits == 32 && format_red_mask == 0xff0000 && format_green_mask == 0xff00 && format_blue_mask == 0xff && format_alpha_mask == 0xff000000) {
|
||||
r_dds_format = DDS_BGRA8;
|
||||
} else if (format_rgb_bits == 32 && format_red_mask == 0xff && format_green_mask == 0xff00 && format_blue_mask == 0xff0000 && format_alpha_mask == 0xff000000) {
|
||||
r_dds_format = DDS_RGBA8;
|
||||
} else if (format_rgb_bits == 16 && format_red_mask == 0x00007c00 && format_green_mask == 0x000003e0 && format_blue_mask == 0x0000001f && format_alpha_mask == 0x00008000) {
|
||||
r_dds_format = DDS_BGR5A1;
|
||||
} else if (format_rgb_bits == 32 && format_red_mask == 0x3ff00000 && format_green_mask == 0xffc00 && format_blue_mask == 0x3ff && format_alpha_mask == 0xc0000000) {
|
||||
r_dds_format = DDS_BGR10A2;
|
||||
} else if (format_rgb_bits == 32 && format_red_mask == 0x3ff && format_green_mask == 0xffc00 && format_blue_mask == 0x3ff00000 && format_alpha_mask == 0xc0000000) {
|
||||
r_dds_format = DDS_RGB10A2;
|
||||
} else if (format_rgb_bits == 16 && format_red_mask == 0xf00 && format_green_mask == 0xf0 && format_blue_mask == 0xf && format_alpha_mask == 0xf000) {
|
||||
r_dds_format = DDS_BGRA4;
|
||||
} else if (format_rgb_bits == 16 && format_red_mask == 0xe0 && format_green_mask == 0x1c && format_blue_mask == 0x3 && format_alpha_mask == 0xff00) {
|
||||
r_dds_format = DDS_B2GR3A8;
|
||||
}
|
||||
|
||||
} else {
|
||||
// Without alpha.
|
||||
if (format_rgb_bits == 24 && format_red_mask == 0xff0000 && format_green_mask == 0xff00 && format_blue_mask == 0xff) {
|
||||
r_dds_format = DDS_BGR8;
|
||||
} else if (format_rgb_bits == 24 && format_red_mask == 0xff && format_green_mask == 0xff00 && format_blue_mask == 0xff0000) {
|
||||
r_dds_format = DDS_RGB8;
|
||||
} else if (format_rgb_bits == 16 && format_red_mask == 0x0000f800 && format_green_mask == 0x000007e0 && format_blue_mask == 0x0000001f) {
|
||||
r_dds_format = DDS_BGR565;
|
||||
} else if (format_rgb_bits == 8 && format_red_mask == 0xe0 && format_green_mask == 0x1c && format_blue_mask == 0x3) {
|
||||
r_dds_format = DDS_B2GR3;
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
// Other formats.
|
||||
if (format_flags & DDPF_ALPHAONLY && format_rgb_bits == 8 && format_alpha_mask == 0xff) {
|
||||
// Alpha only.
|
||||
r_dds_format = DDS_LUMINANCE;
|
||||
}
|
||||
}
|
||||
|
||||
// Depending on the writer, luminance formats may or may not have the DDPF_RGB or DDPF_LUMINANCE flags defined,
|
||||
// so we check for these formats after everything else failed.
|
||||
if (r_dds_format == DDS_MAX) {
|
||||
if (format_flags & DDPF_ALPHAPIXELS) {
|
||||
// With alpha.
|
||||
if (format_rgb_bits == 16 && format_red_mask == 0xff && format_alpha_mask == 0xff00) {
|
||||
r_dds_format = DDS_LUMINANCE_ALPHA;
|
||||
} else if (format_rgb_bits == 8 && format_red_mask == 0xf && format_alpha_mask == 0xf0) {
|
||||
r_dds_format = DDS_LUMINANCE_ALPHA_4;
|
||||
}
|
||||
|
||||
} else {
|
||||
// Without alpha.
|
||||
if (format_rgb_bits == 8 && format_red_mask == 0xff) {
|
||||
r_dds_format = DDS_LUMINANCE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// No format detected, error.
|
||||
if (r_dds_format == DDS_MAX) {
|
||||
ERR_FAIL_V_MSG(Vector<Ref<Image>>(), vformat("Unrecognized or unsupported color layout in DDS '%s'.", p_path));
|
||||
}
|
||||
|
||||
if (!(r_flags & DDSD_MIPMAPCOUNT)) {
|
||||
r_mipmaps = 1;
|
||||
}
|
||||
|
||||
return _dds_load_images(p_f, r_dds_format, r_width, r_height, r_mipmaps, r_pitch, r_flags, r_layer_count);
|
||||
}
|
||||
|
||||
static Ref<Resource> _dds_load_from_buffer(Ref<FileAccess> p_f, Error *r_error, const String &p_path = "") {
|
||||
if (r_error) {
|
||||
*r_error = ERR_FILE_CORRUPT;
|
||||
}
|
||||
|
||||
DDSFormat dds_format;
|
||||
uint32_t width = 0, height = 0, mipmaps = 0, pitch = 0, flags = 0, layer_count = 0, dds_type = 0;
|
||||
|
||||
Vector<Ref<Image>> images = _dds_load_images_from_buffer(p_f, dds_format, width, height, mipmaps, pitch, flags, layer_count, dds_type, p_path);
|
||||
return _dds_create_texture_from_images(images, dds_format, width, height, mipmaps, pitch, flags, layer_count, dds_type, r_error);
|
||||
}
|
||||
|
||||
static Ref<Resource> _dds_load_from_file(const String &p_path, Error *r_error) {
|
||||
if (r_error) {
|
||||
*r_error = ERR_CANT_OPEN;
|
||||
}
|
||||
|
|
@ -554,268 +684,11 @@ Ref<Resource> ResourceFormatDDS::load(const String &p_path, const String &p_orig
|
|||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
Ref<FileAccess> fref(f);
|
||||
if (r_error) {
|
||||
*r_error = ERR_FILE_CORRUPT;
|
||||
}
|
||||
return _dds_load_from_buffer(f, r_error, p_path);
|
||||
}
|
||||
|
||||
ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), vformat("Unable to open DDS texture file '%s'.", p_path));
|
||||
|
||||
uint32_t magic = f->get_32();
|
||||
uint32_t hsize = f->get_32();
|
||||
uint32_t flags = f->get_32();
|
||||
uint32_t height = f->get_32();
|
||||
uint32_t width = f->get_32();
|
||||
uint32_t pitch = f->get_32();
|
||||
uint32_t depth = f->get_32();
|
||||
uint32_t mipmaps = f->get_32();
|
||||
|
||||
// Skip reserved.
|
||||
for (int i = 0; i < 11; i++) {
|
||||
f->get_32();
|
||||
}
|
||||
|
||||
// Validate.
|
||||
// We don't check DDSD_CAPS or DDSD_PIXELFORMAT, as they're mandatory when writing,
|
||||
// but non-mandatory when reading (as some writers don't set them).
|
||||
if (magic != DDS_MAGIC || hsize != 124) {
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), vformat("Invalid or unsupported DDS texture file '%s'.", p_path));
|
||||
}
|
||||
|
||||
/* uint32_t format_size = */ f->get_32();
|
||||
uint32_t format_flags = f->get_32();
|
||||
uint32_t format_fourcc = f->get_32();
|
||||
uint32_t format_rgb_bits = f->get_32();
|
||||
uint32_t format_red_mask = f->get_32();
|
||||
uint32_t format_green_mask = f->get_32();
|
||||
uint32_t format_blue_mask = f->get_32();
|
||||
uint32_t format_alpha_mask = f->get_32();
|
||||
|
||||
/* uint32_t caps_1 = */ f->get_32();
|
||||
uint32_t caps_2 = f->get_32();
|
||||
/* uint32_t caps_3 = */ f->get_32();
|
||||
/* uint32_t caps_4 = */ f->get_32();
|
||||
|
||||
// Skip reserved.
|
||||
f->get_32();
|
||||
|
||||
if (f->get_position() < 128) {
|
||||
f->seek(128);
|
||||
}
|
||||
|
||||
uint32_t layer_count = 1;
|
||||
uint32_t dds_type = DDST_2D;
|
||||
|
||||
if (caps_2 & DDSC2_CUBEMAP) {
|
||||
dds_type = DDST_CUBEMAP;
|
||||
layer_count *= 6;
|
||||
|
||||
} else if (caps_2 & DDSC2_VOLUME) {
|
||||
dds_type = DDST_3D;
|
||||
layer_count = depth;
|
||||
}
|
||||
|
||||
DDSFormat dds_format = DDS_MAX;
|
||||
|
||||
if (format_flags & DDPF_FOURCC) {
|
||||
// FourCC formats.
|
||||
switch (format_fourcc) {
|
||||
case DDFCC_DXT1: {
|
||||
dds_format = DDS_DXT1;
|
||||
} break;
|
||||
case DDFCC_DXT2:
|
||||
case DDFCC_DXT3: {
|
||||
dds_format = DDS_DXT3;
|
||||
} break;
|
||||
case DDFCC_DXT4:
|
||||
case DDFCC_DXT5: {
|
||||
dds_format = DDS_DXT5;
|
||||
} break;
|
||||
case DDFCC_ATI1:
|
||||
case DDFCC_BC4U: {
|
||||
dds_format = DDS_ATI1;
|
||||
} break;
|
||||
case DDFCC_ATI2:
|
||||
case DDFCC_BC5U:
|
||||
case DDFCC_A2XY: {
|
||||
dds_format = DDS_ATI2;
|
||||
} break;
|
||||
case DDFCC_R16F: {
|
||||
dds_format = DDS_R16F;
|
||||
} break;
|
||||
case DDFCC_RG16F: {
|
||||
dds_format = DDS_RG16F;
|
||||
} break;
|
||||
case DDFCC_RGBA16F: {
|
||||
dds_format = DDS_RGBA16F;
|
||||
} break;
|
||||
case DDFCC_R32F: {
|
||||
dds_format = DDS_R32F;
|
||||
} break;
|
||||
case DDFCC_RG32F: {
|
||||
dds_format = DDS_RG32F;
|
||||
} break;
|
||||
case DDFCC_RGBA32F: {
|
||||
dds_format = DDS_RGBA32F;
|
||||
} break;
|
||||
case DDFCC_DX10: {
|
||||
uint32_t dxgi_format = f->get_32();
|
||||
uint32_t dimension = f->get_32();
|
||||
/* uint32_t misc_flags_1 = */ f->get_32();
|
||||
uint32_t array_size = f->get_32();
|
||||
/* uint32_t misc_flags_2 = */ f->get_32();
|
||||
|
||||
if (dimension == DX10D_3D) {
|
||||
dds_type = DDST_3D;
|
||||
layer_count = depth;
|
||||
}
|
||||
|
||||
if (array_size > 1) {
|
||||
layer_count *= array_size;
|
||||
dds_type |= DDST_ARRAY;
|
||||
}
|
||||
|
||||
dds_format = _dxgi_to_dds_format(dxgi_format);
|
||||
} break;
|
||||
|
||||
default: {
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), vformat("Unrecognized or unsupported FourCC in DDS '%s'.", p_path));
|
||||
}
|
||||
}
|
||||
|
||||
} else if (format_flags & DDPF_RGB) {
|
||||
// Channel-bitmasked formats.
|
||||
if (format_flags & DDPF_ALPHAPIXELS) {
|
||||
// With alpha.
|
||||
if (format_rgb_bits == 32 && format_red_mask == 0xff0000 && format_green_mask == 0xff00 && format_blue_mask == 0xff && format_alpha_mask == 0xff000000) {
|
||||
dds_format = DDS_BGRA8;
|
||||
} else if (format_rgb_bits == 32 && format_red_mask == 0xff && format_green_mask == 0xff00 && format_blue_mask == 0xff0000 && format_alpha_mask == 0xff000000) {
|
||||
dds_format = DDS_RGBA8;
|
||||
} else if (format_rgb_bits == 16 && format_red_mask == 0x00007c00 && format_green_mask == 0x000003e0 && format_blue_mask == 0x0000001f && format_alpha_mask == 0x00008000) {
|
||||
dds_format = DDS_BGR5A1;
|
||||
} else if (format_rgb_bits == 32 && format_red_mask == 0x3ff00000 && format_green_mask == 0xffc00 && format_blue_mask == 0x3ff && format_alpha_mask == 0xc0000000) {
|
||||
dds_format = DDS_BGR10A2;
|
||||
} else if (format_rgb_bits == 32 && format_red_mask == 0x3ff && format_green_mask == 0xffc00 && format_blue_mask == 0x3ff00000 && format_alpha_mask == 0xc0000000) {
|
||||
dds_format = DDS_RGB10A2;
|
||||
} else if (format_rgb_bits == 16 && format_red_mask == 0xf00 && format_green_mask == 0xf0 && format_blue_mask == 0xf && format_alpha_mask == 0xf000) {
|
||||
dds_format = DDS_BGRA4;
|
||||
} else if (format_rgb_bits == 16 && format_red_mask == 0xe0 && format_green_mask == 0x1c && format_blue_mask == 0x3 && format_alpha_mask == 0xff00) {
|
||||
dds_format = DDS_B2GR3A8;
|
||||
}
|
||||
|
||||
} else {
|
||||
// Without alpha.
|
||||
if (format_rgb_bits == 24 && format_red_mask == 0xff0000 && format_green_mask == 0xff00 && format_blue_mask == 0xff) {
|
||||
dds_format = DDS_BGR8;
|
||||
} else if (format_rgb_bits == 24 && format_red_mask == 0xff && format_green_mask == 0xff00 && format_blue_mask == 0xff0000) {
|
||||
dds_format = DDS_RGB8;
|
||||
} else if (format_rgb_bits == 16 && format_red_mask == 0x0000f800 && format_green_mask == 0x000007e0 && format_blue_mask == 0x0000001f) {
|
||||
dds_format = DDS_BGR565;
|
||||
} else if (format_rgb_bits == 8 && format_red_mask == 0xe0 && format_green_mask == 0x1c && format_blue_mask == 0x3) {
|
||||
dds_format = DDS_B2GR3;
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
// Other formats.
|
||||
if (format_flags & DDPF_ALPHAONLY && format_rgb_bits == 8 && format_alpha_mask == 0xff) {
|
||||
// Alpha only.
|
||||
dds_format = DDS_LUMINANCE;
|
||||
}
|
||||
}
|
||||
|
||||
// Depending on the writer, luminance formats may or may not have the DDPF_RGB or DDPF_LUMINANCE flags defined,
|
||||
// so we check for these formats after everything else failed.
|
||||
if (dds_format == DDS_MAX) {
|
||||
if (format_flags & DDPF_ALPHAPIXELS) {
|
||||
// With alpha.
|
||||
if (format_rgb_bits == 16 && format_red_mask == 0xff && format_alpha_mask == 0xff00) {
|
||||
dds_format = DDS_LUMINANCE_ALPHA;
|
||||
} else if (format_rgb_bits == 8 && format_red_mask == 0xf && format_alpha_mask == 0xf0) {
|
||||
dds_format = DDS_LUMINANCE_ALPHA_4;
|
||||
}
|
||||
|
||||
} else {
|
||||
// Without alpha.
|
||||
if (format_rgb_bits == 8 && format_red_mask == 0xff) {
|
||||
dds_format = DDS_LUMINANCE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// No format detected, error.
|
||||
if (dds_format == DDS_MAX) {
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), vformat("Unrecognized or unsupported color layout in DDS '%s'.", p_path));
|
||||
}
|
||||
|
||||
if (!(flags & DDSD_MIPMAPCOUNT)) {
|
||||
mipmaps = 1;
|
||||
}
|
||||
|
||||
Vector<uint8_t> src_data;
|
||||
|
||||
Vector<Ref<Image>> images;
|
||||
images.resize(layer_count);
|
||||
|
||||
for (uint32_t i = 0; i < layer_count; i++) {
|
||||
images.write[i] = _dds_load_layer(f, dds_format, width, height, mipmaps, pitch, flags, src_data);
|
||||
}
|
||||
|
||||
if ((dds_type & DDST_TYPE_MASK) == DDST_2D) {
|
||||
if (dds_type & DDST_ARRAY) {
|
||||
Ref<Texture2DArray> texture = memnew(Texture2DArray());
|
||||
texture->create_from_images(images);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return texture;
|
||||
|
||||
} else {
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return ImageTexture::create_from_image(images[0]);
|
||||
}
|
||||
|
||||
} else if ((dds_type & DDST_TYPE_MASK) == DDST_CUBEMAP) {
|
||||
ERR_FAIL_COND_V(layer_count % 6 != 0, Ref<Resource>());
|
||||
|
||||
if (dds_type & DDST_ARRAY) {
|
||||
Ref<CubemapArray> texture = memnew(CubemapArray());
|
||||
texture->create_from_images(images);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return texture;
|
||||
|
||||
} else {
|
||||
Ref<Cubemap> texture = memnew(Cubemap());
|
||||
texture->create_from_images(images);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
} else if ((dds_type & DDST_TYPE_MASK) == DDST_3D) {
|
||||
Ref<ImageTexture3D> texture = memnew(ImageTexture3D());
|
||||
texture->create(images[0]->get_format(), width, height, layer_count, mipmaps > 1, images);
|
||||
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
}
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
return Ref<Resource>();
|
||||
Ref<Resource> ResourceFormatDDS::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
return _dds_load_from_file(p_path, r_error);
|
||||
}
|
||||
|
||||
void ResourceFormatDDS::get_recognized_extensions(List<String> *p_extensions) const {
|
||||
|
|
@ -832,3 +705,24 @@ String ResourceFormatDDS::get_resource_type(const String &p_path) const {
|
|||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
Ref<Image> load_mem_dds(const uint8_t *p_dds, int p_size) {
|
||||
ERR_FAIL_NULL_V(p_dds, Ref<Image>());
|
||||
ERR_FAIL_COND_V(!p_size, Ref<Image>());
|
||||
Ref<FileAccessMemory> memfile;
|
||||
memfile.instantiate();
|
||||
Error open_memfile_error = memfile->open_custom(p_dds, p_size);
|
||||
ERR_FAIL_COND_V_MSG(open_memfile_error, Ref<Image>(), "Could not create memfile for DDS image buffer.");
|
||||
|
||||
DDSFormat dds_format;
|
||||
uint32_t width, height, mipmaps, pitch, flags, layer_count, dds_type;
|
||||
|
||||
Vector<Ref<Image>> images = _dds_load_images_from_buffer(memfile, dds_format, width, height, mipmaps, pitch, flags, layer_count, dds_type);
|
||||
ERR_FAIL_COND_V_MSG(images.is_empty(), Ref<Image>(), "Failed to load DDS image.");
|
||||
|
||||
return images[0];
|
||||
}
|
||||
|
||||
ResourceFormatDDS::ResourceFormatDDS() {
|
||||
Image::_dds_mem_loader_func = load_mem_dds;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue