initial commit, 4.5 stable
Some checks failed
🔗 GHA / 📊 Static checks (push) Has been cancelled
🔗 GHA / 🤖 Android (push) Has been cancelled
🔗 GHA / 🍏 iOS (push) Has been cancelled
🔗 GHA / 🐧 Linux (push) Has been cancelled
🔗 GHA / 🍎 macOS (push) Has been cancelled
🔗 GHA / 🏁 Windows (push) Has been cancelled
🔗 GHA / 🌐 Web (push) Has been cancelled
Some checks failed
🔗 GHA / 📊 Static checks (push) Has been cancelled
🔗 GHA / 🤖 Android (push) Has been cancelled
🔗 GHA / 🍏 iOS (push) Has been cancelled
🔗 GHA / 🐧 Linux (push) Has been cancelled
🔗 GHA / 🍎 macOS (push) Has been cancelled
🔗 GHA / 🏁 Windows (push) Has been cancelled
🔗 GHA / 🌐 Web (push) Has been cancelled
This commit is contained in:
470
modules/dds/image_saver_dds.cpp
Normal file
470
modules/dds/image_saver_dds.cpp
Normal file
@@ -0,0 +1,470 @@
|
||||
/**************************************************************************/
|
||||
/* image_saver_dds.cpp */
|
||||
/**************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/**************************************************************************/
|
||||
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
||||
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/**************************************************************************/
|
||||
|
||||
#include "image_saver_dds.h"
|
||||
|
||||
#include "dds_enums.h"
|
||||
|
||||
#include "core/io/file_access.h"
|
||||
#include "core/io/stream_peer.h"
|
||||
|
||||
Error save_dds(const String &p_path, const Ref<Image> &p_img) {
|
||||
Vector<uint8_t> buffer = save_dds_buffer(p_img);
|
||||
|
||||
Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::WRITE);
|
||||
if (file.is_null()) {
|
||||
return ERR_CANT_CREATE;
|
||||
}
|
||||
|
||||
file->store_buffer(buffer.ptr(), buffer.size());
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
enum DDSFormatType {
|
||||
DDFT_BITMASK,
|
||||
DDFT_FOURCC,
|
||||
DDFT_DXGI,
|
||||
};
|
||||
|
||||
DDSFormatType _dds_format_get_type(DDSFormat p_format) {
|
||||
switch (p_format) {
|
||||
case DDS_DXT1:
|
||||
case DDS_DXT3:
|
||||
case DDS_DXT5:
|
||||
case DDS_ATI1:
|
||||
case DDS_ATI2:
|
||||
case DDS_R16F:
|
||||
case DDS_RG16F:
|
||||
case DDS_RGBA16F:
|
||||
case DDS_R32F:
|
||||
case DDS_RG32F:
|
||||
case DDS_RGBA32F:
|
||||
return DDFT_FOURCC;
|
||||
|
||||
case DDS_BC6S:
|
||||
case DDS_BC6U:
|
||||
case DDS_BC7:
|
||||
case DDS_RGB9E5:
|
||||
case DDS_RGB32F:
|
||||
return DDFT_DXGI;
|
||||
|
||||
default:
|
||||
return DDFT_BITMASK;
|
||||
}
|
||||
}
|
||||
|
||||
DDSFormat _image_format_to_dds_format(Image::Format p_image_format) {
|
||||
switch (p_image_format) {
|
||||
case Image::FORMAT_RGBAF: {
|
||||
return DDS_RGBA32F;
|
||||
}
|
||||
case Image::FORMAT_RGBF: {
|
||||
return DDS_RGB32F;
|
||||
}
|
||||
case Image::FORMAT_RGBAH: {
|
||||
return DDS_RGBA16F;
|
||||
}
|
||||
case Image::FORMAT_RGF: {
|
||||
return DDS_RG32F;
|
||||
}
|
||||
case Image::FORMAT_RGBA8: {
|
||||
return DDS_RGBA8;
|
||||
}
|
||||
case Image::FORMAT_RGH: {
|
||||
return DDS_RG16F;
|
||||
}
|
||||
case Image::FORMAT_RF: {
|
||||
return DDS_R32F;
|
||||
}
|
||||
case Image::FORMAT_L8:
|
||||
case Image::FORMAT_R8: {
|
||||
return DDS_LUMINANCE;
|
||||
}
|
||||
case Image::FORMAT_RH: {
|
||||
return DDS_R16F;
|
||||
}
|
||||
case Image::FORMAT_LA8:
|
||||
case Image::FORMAT_RG8: {
|
||||
return DDS_LUMINANCE_ALPHA;
|
||||
}
|
||||
case Image::FORMAT_RGBA4444: {
|
||||
return DDS_BGRA4;
|
||||
}
|
||||
case Image::FORMAT_RGB565: {
|
||||
return DDS_BGR565;
|
||||
}
|
||||
case Image::FORMAT_RGBE9995: {
|
||||
return DDS_RGB9E5;
|
||||
}
|
||||
case Image::FORMAT_DXT1: {
|
||||
return DDS_DXT1;
|
||||
}
|
||||
case Image::FORMAT_DXT3: {
|
||||
return DDS_DXT3;
|
||||
}
|
||||
case Image::FORMAT_DXT5: {
|
||||
return DDS_DXT5;
|
||||
}
|
||||
case Image::FORMAT_RGTC_R: {
|
||||
return DDS_ATI1;
|
||||
}
|
||||
case Image::FORMAT_RGTC_RG: {
|
||||
return DDS_ATI2;
|
||||
}
|
||||
case Image::FORMAT_RGB8: {
|
||||
return DDS_RGB8;
|
||||
}
|
||||
case Image::FORMAT_BPTC_RGBFU: {
|
||||
return DDS_BC6U;
|
||||
}
|
||||
case Image::FORMAT_BPTC_RGBF: {
|
||||
return DDS_BC6S;
|
||||
}
|
||||
case Image::FORMAT_BPTC_RGBA: {
|
||||
return DDS_BC7;
|
||||
}
|
||||
default: {
|
||||
return DDS_MAX;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t _image_format_to_fourcc_format(Image::Format p_format) {
|
||||
switch (p_format) {
|
||||
case Image::FORMAT_DXT1:
|
||||
return DDFCC_DXT1;
|
||||
case Image::FORMAT_DXT3:
|
||||
return DDFCC_DXT3;
|
||||
case Image::FORMAT_DXT5:
|
||||
return DDFCC_DXT5;
|
||||
case Image::FORMAT_RGTC_R:
|
||||
return DDFCC_ATI1;
|
||||
case Image::FORMAT_RGTC_RG:
|
||||
return DDFCC_ATI2;
|
||||
case Image::FORMAT_RF:
|
||||
return DDFCC_R32F;
|
||||
case Image::FORMAT_RGF:
|
||||
return DDFCC_RG32F;
|
||||
case Image::FORMAT_RGBAF:
|
||||
return DDFCC_RGBA32F;
|
||||
case Image::FORMAT_RH:
|
||||
return DDFCC_R16F;
|
||||
case Image::FORMAT_RGH:
|
||||
return DDFCC_RG16F;
|
||||
case Image::FORMAT_RGBAH:
|
||||
return DDFCC_RGBA16F;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t _image_format_to_dxgi_format(Image::Format p_format) {
|
||||
switch (p_format) {
|
||||
case Image::FORMAT_DXT1:
|
||||
return DXGI_BC1_UNORM;
|
||||
case Image::FORMAT_DXT3:
|
||||
return DXGI_BC2_UNORM;
|
||||
case Image::FORMAT_DXT5:
|
||||
return DXGI_BC3_UNORM;
|
||||
case Image::FORMAT_RGTC_R:
|
||||
return DXGI_BC4_UNORM;
|
||||
case Image::FORMAT_RGTC_RG:
|
||||
return DXGI_BC5_UNORM;
|
||||
case Image::FORMAT_BPTC_RGBFU:
|
||||
return DXGI_BC6H_UF16;
|
||||
case Image::FORMAT_BPTC_RGBF:
|
||||
return DXGI_BC6H_SF16;
|
||||
case Image::FORMAT_BPTC_RGBA:
|
||||
return DXGI_BC7_UNORM;
|
||||
case Image::FORMAT_RF:
|
||||
return DXGI_R32_FLOAT;
|
||||
case Image::FORMAT_RGF:
|
||||
return DXGI_R32G32_FLOAT;
|
||||
case Image::FORMAT_RGBF:
|
||||
return DXGI_R32G32B32_FLOAT;
|
||||
case Image::FORMAT_RGBAF:
|
||||
return DXGI_R32G32B32A32_FLOAT;
|
||||
case Image::FORMAT_RH:
|
||||
return DXGI_R16_FLOAT;
|
||||
case Image::FORMAT_RGH:
|
||||
return DXGI_R16G16_FLOAT;
|
||||
case Image::FORMAT_RGBAH:
|
||||
return DXGI_R16G16B16A16_FLOAT;
|
||||
case Image::FORMAT_RGBE9995:
|
||||
return DXGI_R9G9B9E5;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void _get_dds_pixel_bitmask(Image::Format p_format, uint32_t &r_bit_count, uint32_t &r_red_mask, uint32_t &r_green_mask, uint32_t &r_blue_mask, uint32_t &r_alpha_mask) {
|
||||
switch (p_format) {
|
||||
case Image::FORMAT_R8:
|
||||
case Image::FORMAT_L8: {
|
||||
r_bit_count = 8;
|
||||
r_red_mask = 0xff;
|
||||
r_green_mask = 0;
|
||||
r_blue_mask = 0;
|
||||
r_alpha_mask = 0;
|
||||
} break;
|
||||
case Image::FORMAT_RG8:
|
||||
case Image::FORMAT_LA8: {
|
||||
r_bit_count = 16;
|
||||
r_red_mask = 0xff;
|
||||
r_green_mask = 0;
|
||||
r_blue_mask = 0;
|
||||
r_alpha_mask = 0xff00;
|
||||
} break;
|
||||
case Image::FORMAT_RGB8: {
|
||||
// BGR8
|
||||
r_bit_count = 24;
|
||||
r_red_mask = 0xff0000;
|
||||
r_green_mask = 0xff00;
|
||||
r_blue_mask = 0xff;
|
||||
r_alpha_mask = 0;
|
||||
} break;
|
||||
case Image::FORMAT_RGBA8: {
|
||||
r_bit_count = 32;
|
||||
r_red_mask = 0xff;
|
||||
r_green_mask = 0xff00;
|
||||
r_blue_mask = 0xff0000;
|
||||
r_alpha_mask = 0xff000000;
|
||||
} break;
|
||||
case Image::FORMAT_RGBA4444: {
|
||||
// BGRA4444
|
||||
r_bit_count = 16;
|
||||
r_red_mask = 0xf00;
|
||||
r_green_mask = 0xf0;
|
||||
r_blue_mask = 0xf;
|
||||
r_alpha_mask = 0xf000;
|
||||
} break;
|
||||
case Image::FORMAT_RGB565: {
|
||||
// BGR565
|
||||
r_bit_count = 16;
|
||||
r_red_mask = 0xf800;
|
||||
r_green_mask = 0x7e0;
|
||||
r_blue_mask = 0x1f;
|
||||
r_alpha_mask = 0;
|
||||
} break;
|
||||
|
||||
default: {
|
||||
r_bit_count = 0;
|
||||
r_red_mask = 0;
|
||||
r_green_mask = 0;
|
||||
r_blue_mask = 0;
|
||||
r_alpha_mask = 0;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
Vector<uint8_t> save_dds_buffer(const Ref<Image> &p_img) {
|
||||
Ref<StreamPeerBuffer> stream_buffer;
|
||||
stream_buffer.instantiate();
|
||||
|
||||
Ref<Image> image = p_img;
|
||||
|
||||
stream_buffer->put_32(DDS_MAGIC);
|
||||
stream_buffer->put_32(DDS_HEADER_SIZE);
|
||||
|
||||
uint32_t flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_LINEARSIZE;
|
||||
|
||||
if (image->has_mipmaps()) {
|
||||
flags |= DDSD_MIPMAPCOUNT;
|
||||
}
|
||||
|
||||
stream_buffer->put_32(flags);
|
||||
|
||||
uint32_t height = image->get_height();
|
||||
stream_buffer->put_32(height);
|
||||
|
||||
uint32_t width = image->get_width();
|
||||
stream_buffer->put_32(width);
|
||||
|
||||
DDSFormat dds_format = _image_format_to_dds_format(image->get_format());
|
||||
const DDSFormatInfo &info = dds_format_info[dds_format];
|
||||
|
||||
uint32_t depth = 1; // Default depth for 2D textures
|
||||
|
||||
uint32_t pitch;
|
||||
if (info.compressed) {
|
||||
pitch = ((MAX(info.divisor, width) + info.divisor - 1) / info.divisor) * ((MAX(info.divisor, height) + info.divisor - 1) / info.divisor) * info.block_size;
|
||||
} else {
|
||||
pitch = width * info.block_size;
|
||||
}
|
||||
|
||||
stream_buffer->put_32(pitch);
|
||||
stream_buffer->put_32(depth);
|
||||
|
||||
uint32_t mipmaps = image->get_mipmap_count() + 1;
|
||||
stream_buffer->put_32(mipmaps);
|
||||
|
||||
uint32_t reserved = 0;
|
||||
for (int i = 0; i < 11; i++) {
|
||||
stream_buffer->put_32(reserved);
|
||||
}
|
||||
|
||||
stream_buffer->put_32(DDS_PIXELFORMAT_SIZE);
|
||||
|
||||
uint32_t pf_flags = 0;
|
||||
|
||||
DDSFormatType format_type = _dds_format_get_type(dds_format);
|
||||
|
||||
if (format_type == DDFT_BITMASK) {
|
||||
pf_flags = DDPF_RGB;
|
||||
|
||||
if (image->get_format() == Image::FORMAT_LA8 || image->get_format() == Image::FORMAT_RG8 || image->get_format() == Image::FORMAT_RGBA8 || image->get_format() == Image::FORMAT_RGBA4444) {
|
||||
pf_flags |= DDPF_ALPHAPIXELS;
|
||||
}
|
||||
} else {
|
||||
pf_flags = DDPF_FOURCC;
|
||||
}
|
||||
|
||||
stream_buffer->put_32(pf_flags);
|
||||
|
||||
bool needs_pixeldata_swap = false;
|
||||
|
||||
if (format_type == DDFT_BITMASK) {
|
||||
// Uncompressed bitmasked.
|
||||
stream_buffer->put_32(0); // FourCC
|
||||
|
||||
uint32_t bit_count, r_mask, g_mask, b_mask, a_mask;
|
||||
_get_dds_pixel_bitmask(image->get_format(), bit_count, r_mask, g_mask, b_mask, a_mask);
|
||||
|
||||
stream_buffer->put_32(bit_count);
|
||||
stream_buffer->put_32(r_mask);
|
||||
stream_buffer->put_32(g_mask);
|
||||
stream_buffer->put_32(b_mask);
|
||||
stream_buffer->put_32(a_mask);
|
||||
|
||||
if (image->get_format() == Image::FORMAT_RGBA4444 || image->get_format() == Image::FORMAT_RGB8) {
|
||||
needs_pixeldata_swap = true;
|
||||
}
|
||||
} else if (format_type == DDFT_FOURCC) {
|
||||
// FourCC.
|
||||
uint32_t fourcc = _image_format_to_fourcc_format(image->get_format());
|
||||
stream_buffer->put_32(fourcc);
|
||||
|
||||
stream_buffer->put_32(0); // Bit count
|
||||
stream_buffer->put_32(0); // R Bitmask
|
||||
stream_buffer->put_32(0); // G Bitmask
|
||||
stream_buffer->put_32(0); // B Bitmask
|
||||
stream_buffer->put_32(0); // A Bitmask
|
||||
} else {
|
||||
// DXGI format and DX10 header.
|
||||
stream_buffer->put_32(DDFCC_DX10);
|
||||
|
||||
stream_buffer->put_32(0); // Bit count
|
||||
stream_buffer->put_32(0); // R Bitmask
|
||||
stream_buffer->put_32(0); // G Bitmask
|
||||
stream_buffer->put_32(0); // B Bitmask
|
||||
stream_buffer->put_32(0); // A Bitmask
|
||||
}
|
||||
|
||||
uint32_t caps1 = info.compressed ? DDSD_LINEARSIZE : DDSD_PITCH;
|
||||
stream_buffer->put_32(caps1);
|
||||
|
||||
stream_buffer->put_32(0); // Caps2
|
||||
stream_buffer->put_32(0); // Caps3
|
||||
stream_buffer->put_32(0); // Caps4
|
||||
stream_buffer->put_32(0); // Reserved 2
|
||||
|
||||
if (format_type == DDFT_DXGI) {
|
||||
// DX10 header.
|
||||
uint32_t dxgi_format = _image_format_to_dxgi_format(image->get_format());
|
||||
stream_buffer->put_32(dxgi_format);
|
||||
stream_buffer->put_32(DX10D_2D);
|
||||
stream_buffer->put_32(0); // Misc flags 1
|
||||
stream_buffer->put_32(1); // Array size
|
||||
stream_buffer->put_32(0); // Misc flags 2
|
||||
}
|
||||
|
||||
for (uint32_t mip_i = 0; mip_i < mipmaps; mip_i++) {
|
||||
uint32_t mip_width = MAX(1u, width >> mip_i);
|
||||
uint32_t mip_height = MAX(1u, height >> mip_i);
|
||||
|
||||
uint32_t expected_size = 0;
|
||||
if (info.compressed) {
|
||||
uint32_t blocks_x = (mip_width + info.divisor - 1) / info.divisor;
|
||||
uint32_t blocks_y = (mip_height + info.divisor - 1) / info.divisor;
|
||||
expected_size = blocks_x * blocks_y * info.block_size;
|
||||
} else {
|
||||
expected_size = mip_width * mip_height * info.block_size;
|
||||
}
|
||||
|
||||
if (needs_pixeldata_swap) {
|
||||
// The image's channels need to be swapped.
|
||||
Ref<Image> mip_image = image->get_image_from_mipmap(mip_i);
|
||||
Vector<uint8_t> data = mip_image->get_data();
|
||||
|
||||
ERR_FAIL_COND_V_MSG(data.size() != expected_size, Vector<uint8_t>(),
|
||||
"Image data size mismatch for mipmap level " + itos(mip_i) +
|
||||
". Expected size: " + itos(expected_size) + ", actual size: " + itos(data.size()) + ".");
|
||||
|
||||
if (mip_image->get_format() == Image::FORMAT_RGBA4444) {
|
||||
// RGBA4 to BGRA4
|
||||
const int64_t data_size = data.size();
|
||||
uint8_t *wb = data.ptrw();
|
||||
|
||||
for (int64_t data_i = 0; data_i < data_size; data_i += 2) {
|
||||
uint8_t ar = wb[data_i + 0];
|
||||
uint8_t gb = wb[data_i + 1];
|
||||
|
||||
wb[data_i + 1] = ((ar & 0x0F) << 4) | ((gb & 0xF0) >> 4);
|
||||
wb[data_i + 0] = ((ar & 0xF0) >> 4) | ((gb & 0x0F) << 4);
|
||||
}
|
||||
} else if (mip_image->get_format() == Image::FORMAT_RGB8) {
|
||||
// RGB8 to BGR8
|
||||
const int64_t data_size = data.size();
|
||||
uint8_t *wb = data.ptrw();
|
||||
|
||||
for (int64_t data_i = 0; data_i < data_size; data_i += 3) {
|
||||
SWAP(wb[data_i], wb[data_i + 2]);
|
||||
}
|
||||
}
|
||||
|
||||
stream_buffer->put_data(data.ptr(), data.size());
|
||||
} else {
|
||||
int64_t ofs, size;
|
||||
|
||||
image->get_mipmap_offset_and_size(mip_i, ofs, size);
|
||||
|
||||
ERR_FAIL_COND_V_MSG(size != expected_size, Vector<uint8_t>(),
|
||||
"Image data size mismatch for mipmap level " + itos(mip_i) +
|
||||
". Expected size: " + itos(expected_size) + ", actual size: " + itos(size) + ".");
|
||||
|
||||
stream_buffer->put_data(image->ptr() + ofs, size);
|
||||
}
|
||||
}
|
||||
|
||||
return stream_buffer->get_data_array();
|
||||
}
|
||||
Reference in New Issue
Block a user