2403 lines
57 KiB
C++
2403 lines
57 KiB
C++
/*************************************************************************/
|
|
/* image.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 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.h"
|
|
#include "core/io/image_loader.h"
|
|
#include "core/os/copymem.h"
|
|
#include "hash_map.h"
|
|
#include "hq2x.h"
|
|
#include "print_string.h"
|
|
#include <stdio.h>
|
|
|
|
const char *Image::format_names[Image::FORMAT_MAX] = {
|
|
"Grayscale",
|
|
"Intensity",
|
|
"GrayscaleAlpha",
|
|
"RGB",
|
|
"RGBA",
|
|
"Indexed",
|
|
"IndexedAlpha",
|
|
"YUV422",
|
|
"YUV444",
|
|
"BC1",
|
|
"BC2",
|
|
"BC3",
|
|
"BC4",
|
|
"BC5",
|
|
"PVRTC2",
|
|
"PVRTC2Alpha",
|
|
"PVRTC4",
|
|
"PVRTC4Alpha",
|
|
"ETC",
|
|
"ATC",
|
|
"ATCAlphaExp",
|
|
"ATCAlphaInterp",
|
|
|
|
};
|
|
|
|
SavePNGFunc Image::save_png_func = NULL;
|
|
|
|
void Image::_put_pixel(int p_x, int p_y, const BColor &p_color, unsigned char *p_data) {
|
|
|
|
_put_pixelw(p_x, p_y, width, p_color, p_data);
|
|
}
|
|
|
|
void Image::_put_pixelw(int p_x, int p_y, int p_width, const BColor &p_color, unsigned char *p_data) {
|
|
|
|
int ofs = p_y * p_width + p_x;
|
|
|
|
switch (format) {
|
|
case FORMAT_GRAYSCALE: {
|
|
|
|
p_data[ofs] = p_color.gray();
|
|
} break;
|
|
case FORMAT_INTENSITY: {
|
|
|
|
p_data[ofs] = p_color.a;
|
|
} break;
|
|
case FORMAT_GRAYSCALE_ALPHA: {
|
|
|
|
p_data[ofs * 2] = p_color.gray();
|
|
p_data[ofs * 2 + 1] = p_color.a;
|
|
|
|
} break;
|
|
case FORMAT_RGB: {
|
|
|
|
p_data[ofs * 3 + 0] = p_color.r;
|
|
p_data[ofs * 3 + 1] = p_color.g;
|
|
p_data[ofs * 3 + 2] = p_color.b;
|
|
|
|
} break;
|
|
case FORMAT_RGBA: {
|
|
|
|
p_data[ofs * 4 + 0] = p_color.r;
|
|
p_data[ofs * 4 + 1] = p_color.g;
|
|
p_data[ofs * 4 + 2] = p_color.b;
|
|
p_data[ofs * 4 + 3] = p_color.a;
|
|
|
|
} break;
|
|
case FORMAT_INDEXED:
|
|
case FORMAT_INDEXED_ALPHA: {
|
|
|
|
ERR_FAIL();
|
|
} break;
|
|
default: {};
|
|
}
|
|
}
|
|
|
|
void Image::_get_mipmap_offset_and_size(int p_mipmap, int &r_offset, int &r_width, int &r_height) const {
|
|
|
|
int w = width;
|
|
int h = height;
|
|
int ofs = 0;
|
|
|
|
int pixel_size = get_format_pixel_size(format);
|
|
int pixel_rshift = get_format_pixel_rshift(format);
|
|
int minw, minh;
|
|
_get_format_min_data_size(format, minw, minh);
|
|
|
|
for (int i = 0; i < p_mipmap; i++) {
|
|
int s = w * h;
|
|
s *= pixel_size;
|
|
s >>= pixel_rshift;
|
|
ofs += s;
|
|
w = MAX(minw, w >> 1);
|
|
h = MAX(minh, h >> 1);
|
|
}
|
|
|
|
r_offset = ofs;
|
|
r_width = w;
|
|
r_height = h;
|
|
}
|
|
int Image::get_mipmap_offset(int p_mipmap) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_mipmap, (mipmaps + 1), -1);
|
|
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
|
|
return ofs;
|
|
}
|
|
|
|
void Image::get_mipmap_offset_and_size(int p_mipmap, int &r_ofs, int &r_size) const {
|
|
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
|
|
int ofs2;
|
|
_get_mipmap_offset_and_size(p_mipmap + 1, ofs2, w, h);
|
|
r_ofs = ofs;
|
|
r_size = ofs2 - ofs;
|
|
}
|
|
|
|
void Image::get_mipmap_offset_size_and_dimensions(int p_mipmap, int &r_ofs, int &r_size, int &w, int &h) const {
|
|
|
|
int ofs;
|
|
_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
|
|
int ofs2, w2, h2;
|
|
_get_mipmap_offset_and_size(p_mipmap + 1, ofs2, w2, h2);
|
|
r_ofs = ofs;
|
|
r_size = ofs2 - ofs;
|
|
}
|
|
|
|
void Image::put_pixel(int p_x, int p_y, const Color &p_color, int p_mipmap) {
|
|
|
|
ERR_FAIL_INDEX(p_mipmap, mipmaps + 1);
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
|
|
ERR_FAIL_INDEX(p_x, w);
|
|
ERR_FAIL_INDEX(p_y, h);
|
|
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *data_ptr = wp.ptr();
|
|
|
|
_put_pixelw(p_x, p_y, w, BColor(p_color.r * 255, p_color.g * 255, p_color.b * 255, p_color.a * 255), &data_ptr[ofs]);
|
|
}
|
|
|
|
Image::BColor Image::_get_pixel(int p_x, int p_y, const unsigned char *p_data, int p_data_size) const {
|
|
|
|
return _get_pixelw(p_x, p_y, width, p_data, p_data_size);
|
|
}
|
|
Image::BColor Image::_get_pixelw(int p_x, int p_y, int p_width, const unsigned char *p_data, int p_data_size) const {
|
|
|
|
int ofs = p_y * p_width + p_x;
|
|
BColor result(0, 0, 0, 0);
|
|
switch (format) {
|
|
|
|
case FORMAT_GRAYSCALE: {
|
|
|
|
result = BColor(p_data[ofs], p_data[ofs], p_data[ofs], 255.0);
|
|
} break;
|
|
case FORMAT_INTENSITY: {
|
|
|
|
result = BColor(255, 255, 255, p_data[ofs]);
|
|
} break;
|
|
case FORMAT_GRAYSCALE_ALPHA: {
|
|
|
|
result = BColor(p_data[ofs * 2], p_data[ofs * 2], p_data[ofs * 2], p_data[ofs * 2 + 1]);
|
|
|
|
} break;
|
|
case FORMAT_RGB: {
|
|
|
|
result = BColor(p_data[ofs * 3], p_data[ofs * 3 + 1], p_data[ofs * 3 + 2]);
|
|
|
|
} break;
|
|
case FORMAT_RGBA: {
|
|
|
|
result = BColor(p_data[ofs * 4], p_data[ofs * 4 + 1], p_data[ofs * 4 + 2], p_data[ofs * 4 + 3]);
|
|
} break;
|
|
case FORMAT_INDEXED_ALPHA: {
|
|
|
|
int pitch = 4;
|
|
const uint8_t *pal = &p_data[p_data_size - pitch * 256];
|
|
int idx = p_data[ofs];
|
|
result = BColor(pal[idx * pitch + 0], pal[idx * pitch + 1], pal[idx * pitch + 2], pal[idx * pitch + 3]);
|
|
|
|
} break;
|
|
case FORMAT_INDEXED: {
|
|
|
|
int pitch = 3;
|
|
const uint8_t *pal = &p_data[p_data_size - pitch * 256];
|
|
int idx = p_data[ofs];
|
|
result = BColor(pal[idx * pitch + 0], pal[idx * pitch + 1], pal[idx * pitch + 2], 255);
|
|
} break;
|
|
case FORMAT_YUV_422: {
|
|
|
|
int y, u, v;
|
|
if (p_x % 2) {
|
|
const uint8_t *yp = &p_data[p_width * 2 * p_y + p_x * 2];
|
|
u = *(yp - 1);
|
|
y = yp[0];
|
|
v = yp[1];
|
|
} else {
|
|
|
|
const uint8_t *yp = &p_data[p_width * 2 * p_y + p_x * 2];
|
|
y = yp[0];
|
|
u = yp[1];
|
|
v = yp[3];
|
|
};
|
|
|
|
int32_t r = 1.164 * (y - 16) + 1.596 * (v - 128);
|
|
int32_t g = 1.164 * (y - 16) - 0.813 * (v - 128) - 0.391 * (u - 128);
|
|
int32_t b = 1.164 * (y - 16) + 2.018 * (u - 128);
|
|
result = BColor(CLAMP(r, 0, 255), CLAMP(g, 0, 255), CLAMP(b, 0, 255));
|
|
} break;
|
|
case FORMAT_YUV_444: {
|
|
|
|
uint8_t y, u, v;
|
|
const uint8_t *yp = &p_data[p_width * 3 * p_y + p_x * 3];
|
|
y = yp[0];
|
|
u = yp[1];
|
|
v = yp[2];
|
|
|
|
int32_t r = 1.164 * (y - 16) + 1.596 * (v - 128);
|
|
int32_t g = 1.164 * (y - 16) - 0.813 * (v - 128) - 0.391 * (u - 128);
|
|
int32_t b = 1.164 * (y - 16) + 2.018 * (u - 128);
|
|
result = BColor(CLAMP(r, 0, 255), CLAMP(g, 0, 255), CLAMP(b, 0, 255));
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void Image::put_indexed_pixel(int p_x, int p_y, uint8_t p_idx, int p_mipmap) {
|
|
|
|
ERR_FAIL_COND(format != FORMAT_INDEXED && format != FORMAT_INDEXED_ALPHA);
|
|
ERR_FAIL_INDEX(p_mipmap, mipmaps + 1);
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
|
|
ERR_FAIL_INDEX(p_x, w);
|
|
ERR_FAIL_INDEX(p_y, h);
|
|
|
|
data.set(ofs + p_y * w + p_x, p_idx);
|
|
};
|
|
|
|
uint8_t Image::get_indexed_pixel(int p_x, int p_y, int p_mipmap) const {
|
|
|
|
ERR_FAIL_COND_V(format != FORMAT_INDEXED && format != FORMAT_INDEXED_ALPHA, 0);
|
|
|
|
ERR_FAIL_INDEX_V(p_mipmap, mipmaps + 1, 0);
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
|
|
ERR_FAIL_INDEX_V(p_x, w, 0);
|
|
ERR_FAIL_INDEX_V(p_y, h, 0);
|
|
|
|
return data[ofs + p_y * w + p_x];
|
|
};
|
|
|
|
void Image::set_pallete(const DVector<uint8_t> &p_data) {
|
|
|
|
int len = p_data.size();
|
|
|
|
ERR_FAIL_COND(format != FORMAT_INDEXED && format != FORMAT_INDEXED_ALPHA);
|
|
ERR_FAIL_COND(format == FORMAT_INDEXED && len != (256 * 3));
|
|
ERR_FAIL_COND(format == FORMAT_INDEXED_ALPHA && len != (256 * 4));
|
|
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(mipmaps + 1, ofs, w, h);
|
|
|
|
int pal_ofs = ofs;
|
|
data.resize(pal_ofs + p_data.size());
|
|
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *dst = wp.ptr() + pal_ofs;
|
|
|
|
DVector<uint8_t>::Read r = p_data.read();
|
|
const unsigned char *src = r.ptr();
|
|
|
|
copymem(dst, src, len);
|
|
};
|
|
|
|
int Image::get_width() const {
|
|
|
|
return width;
|
|
}
|
|
int Image::get_height() const {
|
|
|
|
return height;
|
|
}
|
|
|
|
int Image::get_mipmaps() const {
|
|
|
|
return mipmaps;
|
|
}
|
|
|
|
Color Image::get_pixel(int p_x, int p_y, int p_mipmap) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_mipmap, mipmaps + 1, Color());
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(p_mipmap, ofs, w, h);
|
|
ERR_FAIL_INDEX_V(p_x, w, Color());
|
|
ERR_FAIL_INDEX_V(p_y, h, Color());
|
|
|
|
int len = data.size();
|
|
DVector<uint8_t>::Read r = data.read();
|
|
const unsigned char *data_ptr = r.ptr();
|
|
BColor c = _get_pixelw(p_x, p_y, w, &data_ptr[ofs], len);
|
|
return Color(c.r / 255.0, c.g / 255.0, c.b / 255.0, c.a / 255.0);
|
|
}
|
|
|
|
void Image::convert(Format p_new_format) {
|
|
|
|
if (data.size() == 0)
|
|
return;
|
|
|
|
if (p_new_format == format)
|
|
return;
|
|
|
|
if (format >= FORMAT_BC1 || p_new_format >= FORMAT_BC1) {
|
|
|
|
ERR_EXPLAIN("Cannot convert to <-> from compressed/custom image formats (for now).");
|
|
ERR_FAIL();
|
|
}
|
|
|
|
if (p_new_format == FORMAT_INDEXED || p_new_format == FORMAT_INDEXED_ALPHA) {
|
|
|
|
return;
|
|
}
|
|
|
|
Image new_img(width, height, 0, p_new_format);
|
|
|
|
int len = data.size();
|
|
|
|
DVector<uint8_t>::Read r = data.read();
|
|
DVector<uint8_t>::Write w = new_img.data.write();
|
|
|
|
const uint8_t *rptr = r.ptr();
|
|
uint8_t *wptr = w.ptr();
|
|
|
|
if (p_new_format == FORMAT_RGBA && format == FORMAT_INDEXED_ALPHA) {
|
|
|
|
//optimized unquantized form
|
|
int dataend = len - 256 * 4;
|
|
const uint32_t *palpos = (const uint32_t *)&rptr[dataend];
|
|
uint32_t *dst32 = (uint32_t *)wptr;
|
|
|
|
for (int i = 0; i < dataend; i++)
|
|
dst32[i] = palpos[rptr[i]]; //since this is read/write, endianness is not a problem
|
|
|
|
} else {
|
|
|
|
//this is temporary, must find a faster way to do it.
|
|
for (int i = 0; i < width; i++)
|
|
for (int j = 0; j < height; j++)
|
|
new_img._put_pixel(i, j, _get_pixel(i, j, rptr, len), wptr);
|
|
}
|
|
|
|
r = DVector<uint8_t>::Read();
|
|
w = DVector<uint8_t>::Write();
|
|
|
|
bool gen_mipmaps = mipmaps > 0;
|
|
|
|
*this = new_img;
|
|
|
|
if (gen_mipmaps)
|
|
generate_mipmaps();
|
|
}
|
|
|
|
Image::Format Image::get_format() const {
|
|
|
|
return format;
|
|
}
|
|
|
|
static double _bicubic_interp_kernel(double x) {
|
|
|
|
x = ABS(x);
|
|
|
|
double bc = 0;
|
|
|
|
if (x <= 1)
|
|
bc = (1.5 * x - 2.5) * x * x + 1;
|
|
else if (x < 2)
|
|
bc = ((-0.5 * x + 2.5) * x - 4) * x + 2;
|
|
|
|
return bc;
|
|
}
|
|
|
|
template <int CC>
|
|
static void _scale_cubic(const uint8_t *p_src, uint8_t *p_dst, uint32_t p_src_width, uint32_t p_src_height, uint32_t p_dst_width, uint32_t p_dst_height) {
|
|
|
|
// get source image size
|
|
int width = p_src_width;
|
|
int height = p_src_height;
|
|
double xfac = (double)width / p_dst_width;
|
|
double yfac = (double)height / p_dst_height;
|
|
// coordinates of source points and cooefficiens
|
|
double ox, oy, dx, dy, k1, k2;
|
|
int ox1, oy1, ox2, oy2;
|
|
// destination pixel values
|
|
// width and height decreased by 1
|
|
int ymax = height - 1;
|
|
int xmax = width - 1;
|
|
// temporary pointer
|
|
|
|
for (int y = 0; y < p_dst_height; y++) {
|
|
// Y coordinates
|
|
oy = (double)y * yfac - 0.5f;
|
|
oy1 = (int)oy;
|
|
dy = oy - (double)oy1;
|
|
|
|
for (int x = 0; x < p_dst_width; x++) {
|
|
// X coordinates
|
|
ox = (double)x * xfac - 0.5f;
|
|
ox1 = (int)ox;
|
|
dx = ox - (double)ox1;
|
|
|
|
// initial pixel value
|
|
|
|
uint8_t *dst = p_dst + (y * p_dst_width + x) * CC;
|
|
|
|
double color[CC];
|
|
for (int i = 0; i < CC; i++) {
|
|
color[i] = 0;
|
|
}
|
|
|
|
for (int n = -1; n < 3; n++) {
|
|
// get Y cooefficient
|
|
k1 = _bicubic_interp_kernel(dy - (double)n);
|
|
|
|
oy2 = oy1 + n;
|
|
if (oy2 < 0)
|
|
oy2 = 0;
|
|
if (oy2 > ymax)
|
|
oy2 = ymax;
|
|
|
|
for (int m = -1; m < 3; m++) {
|
|
// get X cooefficient
|
|
k2 = k1 * _bicubic_interp_kernel((double)m - dx);
|
|
|
|
ox2 = ox1 + m;
|
|
if (ox2 < 0)
|
|
ox2 = 0;
|
|
if (ox2 > xmax)
|
|
ox2 = xmax;
|
|
|
|
// get pixel of original image
|
|
const uint8_t *p = p_src + (oy2 * p_src_width + ox2) * CC;
|
|
|
|
for (int i = 0; i < CC; i++) {
|
|
|
|
color[i] += p[i] * k2;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < CC; i++) {
|
|
dst[i] = CLAMP(Math::fast_ftoi(color[i]), 0, 255);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template <int CC>
|
|
static void _scale_bilinear(const uint8_t *p_src, uint8_t *p_dst, uint32_t p_src_width, uint32_t p_src_height, uint32_t p_dst_width, uint32_t p_dst_height) {
|
|
|
|
enum {
|
|
FRAC_BITS = 8,
|
|
FRAC_LEN = (1 << FRAC_BITS),
|
|
FRAC_MASK = FRAC_LEN - 1
|
|
|
|
};
|
|
|
|
for (uint32_t i = 0; i < p_dst_height; i++) {
|
|
|
|
uint32_t src_yofs_up_fp = (i * p_src_height * FRAC_LEN / p_dst_height);
|
|
uint32_t src_yofs_frac = src_yofs_up_fp & FRAC_MASK;
|
|
uint32_t src_yofs_up = src_yofs_up_fp >> FRAC_BITS;
|
|
|
|
uint32_t src_yofs_down = (i + 1) * p_src_height / p_dst_height;
|
|
if (src_yofs_down >= p_src_height)
|
|
src_yofs_down = p_src_height - 1;
|
|
|
|
//src_yofs_up*=CC;
|
|
//src_yofs_down*=CC;
|
|
|
|
uint32_t y_ofs_up = src_yofs_up * p_src_width * CC;
|
|
uint32_t y_ofs_down = src_yofs_down * p_src_width * CC;
|
|
|
|
for (uint32_t j = 0; j < p_dst_width; j++) {
|
|
|
|
uint32_t src_xofs_left_fp = (j * p_src_width * FRAC_LEN / p_dst_width);
|
|
uint32_t src_xofs_frac = src_xofs_left_fp & FRAC_MASK;
|
|
uint32_t src_xofs_left = src_xofs_left_fp >> FRAC_BITS;
|
|
uint32_t src_xofs_right = (j + 1) * p_src_width / p_dst_width;
|
|
if (src_xofs_right >= p_src_width)
|
|
src_xofs_right = p_src_width - 1;
|
|
|
|
src_xofs_left *= CC;
|
|
src_xofs_right *= CC;
|
|
|
|
for (uint32_t l = 0; l < CC; l++) {
|
|
|
|
uint32_t p00 = p_src[y_ofs_up + src_xofs_left + l] << FRAC_BITS;
|
|
uint32_t p10 = p_src[y_ofs_up + src_xofs_right + l] << FRAC_BITS;
|
|
uint32_t p01 = p_src[y_ofs_down + src_xofs_left + l] << FRAC_BITS;
|
|
uint32_t p11 = p_src[y_ofs_down + src_xofs_right + l] << FRAC_BITS;
|
|
|
|
uint32_t interp_up = p00 + (((p10 - p00) * src_xofs_frac) >> FRAC_BITS);
|
|
uint32_t interp_down = p01 + (((p11 - p01) * src_xofs_frac) >> FRAC_BITS);
|
|
uint32_t interp = interp_up + (((interp_down - interp_up) * src_yofs_frac) >> FRAC_BITS);
|
|
interp >>= FRAC_BITS;
|
|
p_dst[i * p_dst_width * CC + j * CC + l] = interp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template <int CC>
|
|
static void _scale_nearest(const uint8_t *p_src, uint8_t *p_dst, uint32_t p_src_width, uint32_t p_src_height, uint32_t p_dst_width, uint32_t p_dst_height) {
|
|
|
|
for (uint32_t i = 0; i < p_dst_height; i++) {
|
|
|
|
uint32_t src_yofs = i * p_src_height / p_dst_height;
|
|
uint32_t y_ofs = src_yofs * p_src_width * CC;
|
|
|
|
for (uint32_t j = 0; j < p_dst_width; j++) {
|
|
|
|
uint32_t src_xofs = j * p_src_width / p_dst_width;
|
|
src_xofs *= CC;
|
|
|
|
for (uint32_t l = 0; l < CC; l++) {
|
|
|
|
uint32_t p = p_src[y_ofs + src_xofs + l];
|
|
p_dst[i * p_dst_width * CC + j * CC + l] = p;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Image::resize_to_po2(bool p_square) {
|
|
|
|
if (!_can_modify(format)) {
|
|
ERR_EXPLAIN("Cannot resize in indexed, compressed or custom image formats.");
|
|
ERR_FAIL();
|
|
}
|
|
|
|
int w = nearest_power_of_2(width);
|
|
int h = nearest_power_of_2(height);
|
|
|
|
if (w == width && h == height) {
|
|
|
|
if (!p_square || w == h)
|
|
return; //nothing to do
|
|
}
|
|
|
|
resize(w, h);
|
|
}
|
|
|
|
Image Image::resized(int p_width, int p_height, int p_interpolation) {
|
|
|
|
Image ret = *this;
|
|
ret.resize(p_width, p_height, (Interpolation)p_interpolation);
|
|
|
|
return ret;
|
|
};
|
|
|
|
void Image::resize(int p_width, int p_height, Interpolation p_interpolation) {
|
|
|
|
if (!_can_modify(format)) {
|
|
ERR_EXPLAIN("Cannot resize in indexed, compressed or custom image formats.");
|
|
ERR_FAIL();
|
|
}
|
|
|
|
ERR_FAIL_COND(p_width <= 0);
|
|
ERR_FAIL_COND(p_height <= 0);
|
|
ERR_FAIL_COND(p_width > MAX_WIDTH);
|
|
ERR_FAIL_COND(p_height > MAX_HEIGHT);
|
|
|
|
if (p_width == width && p_height == height)
|
|
return;
|
|
|
|
Image dst(p_width, p_height, 0, format);
|
|
|
|
if (format == FORMAT_INDEXED)
|
|
p_interpolation = INTERPOLATE_NEAREST;
|
|
|
|
DVector<uint8_t>::Read r = data.read();
|
|
const unsigned char *r_ptr = r.ptr();
|
|
|
|
DVector<uint8_t>::Write w = dst.data.write();
|
|
unsigned char *w_ptr = w.ptr();
|
|
|
|
switch (p_interpolation) {
|
|
|
|
case INTERPOLATE_NEAREST: {
|
|
|
|
switch (get_format_pixel_size(format)) {
|
|
case 1: _scale_nearest<1>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 2: _scale_nearest<2>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 3: _scale_nearest<3>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 4: _scale_nearest<4>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
}
|
|
} break;
|
|
case INTERPOLATE_BILINEAR: {
|
|
|
|
switch (get_format_pixel_size(format)) {
|
|
case 1: _scale_bilinear<1>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 2: _scale_bilinear<2>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 3: _scale_bilinear<3>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 4: _scale_bilinear<4>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
}
|
|
|
|
} break;
|
|
case INTERPOLATE_CUBIC: {
|
|
|
|
switch (get_format_pixel_size(format)) {
|
|
case 1: _scale_cubic<1>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 2: _scale_cubic<2>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 3: _scale_cubic<3>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
case 4: _scale_cubic<4>(r_ptr, w_ptr, width, height, p_width, p_height); break;
|
|
}
|
|
|
|
} break;
|
|
}
|
|
|
|
r = DVector<uint8_t>::Read();
|
|
w = DVector<uint8_t>::Write();
|
|
|
|
if (mipmaps > 0)
|
|
dst.generate_mipmaps();
|
|
|
|
*this = dst;
|
|
}
|
|
void Image::crop(int p_width, int p_height) {
|
|
|
|
if (!_can_modify(format)) {
|
|
ERR_EXPLAIN("Cannot crop in indexed, compressed or custom image formats.");
|
|
ERR_FAIL();
|
|
}
|
|
ERR_FAIL_COND(p_width <= 0);
|
|
ERR_FAIL_COND(p_height <= 0);
|
|
ERR_FAIL_COND(p_width > MAX_WIDTH);
|
|
ERR_FAIL_COND(p_height > MAX_HEIGHT);
|
|
|
|
/* to save memory, cropping should be done in-place, however, since this function
|
|
will most likely either not be used much, or in critical areas, for now it wont, because
|
|
it's a waste of time. */
|
|
|
|
if (p_width == width && p_height == height)
|
|
return;
|
|
|
|
Image dst(p_width, p_height, 0, format);
|
|
|
|
for (int y = 0; y < p_height; y++) {
|
|
|
|
for (int x = 0; x < p_width; x++) {
|
|
|
|
Color col = (x >= width || y >= height) ? Color() : get_pixel(x, y);
|
|
dst.put_pixel(x, y, col);
|
|
}
|
|
}
|
|
|
|
if (mipmaps > 0)
|
|
dst.generate_mipmaps();
|
|
*this = dst;
|
|
}
|
|
|
|
void Image::flip_y() {
|
|
|
|
if (!_can_modify(format)) {
|
|
ERR_EXPLAIN("Cannot flip_y in indexed, compressed or custom image formats.");
|
|
ERR_FAIL();
|
|
}
|
|
|
|
bool gm = mipmaps;
|
|
|
|
if (gm)
|
|
clear_mipmaps();
|
|
|
|
for (int y = 0; y < (height / 2); y++) {
|
|
|
|
for (int x = 0; x < width; x++) {
|
|
|
|
Color up = get_pixel(x, y);
|
|
Color down = get_pixel(x, height - y - 1);
|
|
|
|
put_pixel(x, y, down);
|
|
put_pixel(x, height - y - 1, up);
|
|
}
|
|
}
|
|
if (gm)
|
|
generate_mipmaps();
|
|
}
|
|
|
|
void Image::flip_x() {
|
|
|
|
if (!_can_modify(format)) {
|
|
ERR_EXPLAIN("Cannot flip_x in indexed, compressed or custom image formats.");
|
|
ERR_FAIL();
|
|
}
|
|
|
|
bool gm = mipmaps;
|
|
if (gm)
|
|
clear_mipmaps();
|
|
|
|
for (int y = 0; y < (height / 2); y++) {
|
|
|
|
for (int x = 0; x < width; x++) {
|
|
|
|
Color up = get_pixel(x, y);
|
|
Color down = get_pixel(width - x - 1, y);
|
|
|
|
put_pixel(x, y, down);
|
|
put_pixel(width - x - 1, y, up);
|
|
}
|
|
}
|
|
|
|
if (gm)
|
|
generate_mipmaps();
|
|
}
|
|
|
|
int Image::_get_dst_image_size(int p_width, int p_height, Format p_format, int &r_mipmaps, int p_mipmaps) {
|
|
|
|
int size = 0;
|
|
int w = p_width;
|
|
int h = p_height;
|
|
int mm = 0;
|
|
|
|
int pixsize = get_format_pixel_size(p_format);
|
|
int pixshift = get_format_pixel_rshift(p_format);
|
|
int minw, minh;
|
|
_get_format_min_data_size(p_format, minw, minh);
|
|
|
|
switch (p_format) {
|
|
|
|
case FORMAT_INDEXED:
|
|
pixsize = 1;
|
|
size = 256 * 3;
|
|
break;
|
|
case FORMAT_INDEXED_ALPHA:
|
|
pixsize = 1;
|
|
size = 256 * 4;
|
|
break;
|
|
default: {}
|
|
};
|
|
|
|
while (true) {
|
|
|
|
int s = w * h;
|
|
s *= pixsize;
|
|
s >>= pixshift;
|
|
|
|
size += s;
|
|
|
|
if (p_mipmaps >= 0 && mm == p_mipmaps)
|
|
break;
|
|
|
|
if (p_mipmaps >= 0) {
|
|
|
|
w = MAX(minw, w >> 1);
|
|
h = MAX(minh, h >> 1);
|
|
} else {
|
|
if (w == minw && h == minh)
|
|
break;
|
|
w = MAX(minw, w >> 1);
|
|
h = MAX(minh, h >> 1);
|
|
}
|
|
mm++;
|
|
};
|
|
|
|
r_mipmaps = mm;
|
|
return size;
|
|
}
|
|
|
|
bool Image::_can_modify(Format p_format) const {
|
|
|
|
switch (p_format) {
|
|
|
|
//these are OK
|
|
case FORMAT_GRAYSCALE:
|
|
case FORMAT_INTENSITY:
|
|
case FORMAT_GRAYSCALE_ALPHA:
|
|
case FORMAT_RGB:
|
|
case FORMAT_RGBA:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
template <int CC>
|
|
static void _generate_po2_mipmap(const uint8_t *p_src, uint8_t *p_dst, uint32_t p_width, uint32_t p_height) {
|
|
|
|
//fast power of 2 mipmap generation
|
|
uint32_t dst_w = p_width >> 1;
|
|
uint32_t dst_h = p_height >> 1;
|
|
|
|
for (uint32_t i = 0; i < dst_h; i++) {
|
|
|
|
const uint8_t *rup_ptr = &p_src[i * 2 * p_width * CC];
|
|
const uint8_t *rdown_ptr = rup_ptr + p_width * CC;
|
|
uint8_t *dst_ptr = &p_dst[i * dst_w * CC];
|
|
uint32_t count = dst_w;
|
|
|
|
while (count--) {
|
|
|
|
for (int j = 0; j < CC; j++) {
|
|
|
|
uint16_t val = 0;
|
|
val += rup_ptr[j];
|
|
val += rup_ptr[j + CC];
|
|
val += rdown_ptr[j];
|
|
val += rdown_ptr[j + CC];
|
|
dst_ptr[j] = val >> 2;
|
|
}
|
|
|
|
dst_ptr += CC;
|
|
rup_ptr += CC * 2;
|
|
rdown_ptr += CC * 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Image::expand_x2_hq2x() {
|
|
|
|
ERR_FAIL_COND(format >= FORMAT_INDEXED);
|
|
|
|
Format current = format;
|
|
bool mipmaps = get_mipmaps();
|
|
if (mipmaps) {
|
|
clear_mipmaps();
|
|
}
|
|
|
|
if (current != FORMAT_RGBA)
|
|
convert(FORMAT_RGBA);
|
|
|
|
DVector<uint8_t> dest;
|
|
dest.resize(width * 2 * height * 2 * 4);
|
|
|
|
{
|
|
DVector<uint8_t>::Read r = data.read();
|
|
DVector<uint8_t>::Write w = dest.write();
|
|
|
|
hq2x_resize((const uint32_t *)r.ptr(), width, height, (uint32_t *)w.ptr());
|
|
}
|
|
|
|
width *= 2;
|
|
height *= 2;
|
|
data = dest;
|
|
|
|
if (current != FORMAT_RGBA)
|
|
convert(current);
|
|
|
|
if (mipmaps) {
|
|
generate_mipmaps();
|
|
}
|
|
}
|
|
|
|
void Image::shrink_x2() {
|
|
|
|
ERR_FAIL_COND(format == FORMAT_INDEXED || format == FORMAT_INDEXED_ALPHA);
|
|
ERR_FAIL_COND(data.size() == 0);
|
|
|
|
if (mipmaps) {
|
|
|
|
//just use the lower mipmap as base and copy all
|
|
DVector<uint8_t> new_img;
|
|
|
|
int ofs = get_mipmap_offset(1);
|
|
|
|
int new_size = data.size() - ofs;
|
|
new_img.resize(new_size);
|
|
|
|
{
|
|
DVector<uint8_t>::Write w = new_img.write();
|
|
DVector<uint8_t>::Read r = data.read();
|
|
|
|
copymem(w.ptr(), &r[ofs], new_size);
|
|
}
|
|
|
|
mipmaps--;
|
|
width /= 2;
|
|
height /= 2;
|
|
data = new_img;
|
|
|
|
} else {
|
|
|
|
DVector<uint8_t> new_img;
|
|
|
|
ERR_FAIL_COND(format >= FORMAT_INDEXED);
|
|
int ps = get_format_pixel_size(format);
|
|
new_img.resize((width / 2) * (height / 2) * ps);
|
|
|
|
{
|
|
DVector<uint8_t>::Write w = new_img.write();
|
|
DVector<uint8_t>::Read r = data.read();
|
|
|
|
switch (format) {
|
|
|
|
case FORMAT_GRAYSCALE:
|
|
case FORMAT_INTENSITY: _generate_po2_mipmap<1>(r.ptr(), w.ptr(), width, height); break;
|
|
case FORMAT_GRAYSCALE_ALPHA: _generate_po2_mipmap<2>(r.ptr(), w.ptr(), width, height); break;
|
|
case FORMAT_RGB: _generate_po2_mipmap<3>(r.ptr(), w.ptr(), width, height); break;
|
|
case FORMAT_RGBA: _generate_po2_mipmap<4>(r.ptr(), w.ptr(), width, height); break;
|
|
default: {}
|
|
}
|
|
}
|
|
|
|
width /= 2;
|
|
height /= 2;
|
|
data = new_img;
|
|
}
|
|
}
|
|
|
|
Error Image::generate_mipmaps(int p_mipmaps, bool p_keep_existing) {
|
|
|
|
if (!_can_modify(format)) {
|
|
ERR_EXPLAIN("Cannot generate mipmaps in indexed, compressed or custom image formats.");
|
|
ERR_FAIL_V(ERR_UNAVAILABLE);
|
|
}
|
|
|
|
int from_mm = 1;
|
|
if (p_keep_existing) {
|
|
from_mm = mipmaps + 1;
|
|
}
|
|
int size = _get_dst_image_size(width, height, format, mipmaps, p_mipmaps);
|
|
|
|
data.resize(size);
|
|
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
|
|
if (nearest_power_of_2(width) == uint32_t(width) && nearest_power_of_2(height) == uint32_t(height)) {
|
|
//use fast code for powers of 2
|
|
int prev_ofs = 0;
|
|
int prev_h = height;
|
|
int prev_w = width;
|
|
|
|
for (int i = 1; i < mipmaps; i++) {
|
|
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(i, ofs, w, h);
|
|
|
|
if (i >= from_mm) {
|
|
|
|
switch (format) {
|
|
|
|
case FORMAT_GRAYSCALE:
|
|
case FORMAT_INTENSITY: _generate_po2_mipmap<1>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h); break;
|
|
case FORMAT_GRAYSCALE_ALPHA: _generate_po2_mipmap<2>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h); break;
|
|
case FORMAT_RGB: _generate_po2_mipmap<3>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h); break;
|
|
case FORMAT_RGBA: _generate_po2_mipmap<4>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h); break;
|
|
default: {}
|
|
}
|
|
}
|
|
|
|
prev_ofs = ofs;
|
|
prev_w = w;
|
|
prev_h = h;
|
|
}
|
|
|
|
} else {
|
|
//use slow code..
|
|
|
|
//use bilinear filtered code for non powers of 2
|
|
int prev_ofs = 0;
|
|
int prev_h = height;
|
|
int prev_w = width;
|
|
|
|
for (int i = 1; i < mipmaps; i++) {
|
|
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(i, ofs, w, h);
|
|
|
|
if (i >= from_mm) {
|
|
|
|
switch (format) {
|
|
|
|
case FORMAT_GRAYSCALE:
|
|
case FORMAT_INTENSITY: _scale_bilinear<1>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h, w, h); break;
|
|
case FORMAT_GRAYSCALE_ALPHA: _scale_bilinear<2>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h, w, h); break;
|
|
case FORMAT_RGB: _scale_bilinear<3>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h, w, h); break;
|
|
case FORMAT_RGBA: _scale_bilinear<4>(&wp[prev_ofs], &wp[ofs], prev_w, prev_h, w, h); break;
|
|
default: {}
|
|
}
|
|
}
|
|
|
|
prev_ofs = ofs;
|
|
prev_w = w;
|
|
prev_h = h;
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
void Image::clear_mipmaps() {
|
|
|
|
if (mipmaps == 0)
|
|
return;
|
|
|
|
if (format == FORMAT_CUSTOM) {
|
|
ERR_EXPLAIN("Cannot clear mipmaps in indexed, compressed or custom image formats.");
|
|
ERR_FAIL();
|
|
}
|
|
|
|
if (empty())
|
|
return;
|
|
|
|
int ofs, w, h;
|
|
_get_mipmap_offset_and_size(1, ofs, w, h);
|
|
int palsize = get_format_pallete_size(format);
|
|
DVector<uint8_t> pallete;
|
|
ERR_FAIL_COND(ofs + palsize > data.size()); //bug?
|
|
if (palsize) {
|
|
|
|
pallete.resize(palsize);
|
|
DVector<uint8_t>::Read r = data.read();
|
|
DVector<uint8_t>::Write w = pallete.write();
|
|
|
|
copymem(&w[0], &r[data.size() - palsize], palsize);
|
|
}
|
|
|
|
data.resize(ofs + palsize);
|
|
|
|
if (palsize) {
|
|
|
|
DVector<uint8_t>::Read r = pallete.read();
|
|
DVector<uint8_t>::Write w = data.write();
|
|
|
|
copymem(&w[ofs], &r[0], palsize);
|
|
}
|
|
|
|
mipmaps = 0;
|
|
}
|
|
|
|
void Image::make_normalmap(float p_height_scale) {
|
|
|
|
if (!_can_modify(format)) {
|
|
ERR_EXPLAIN("Cannot crop in indexed, compressed or custom image formats.");
|
|
ERR_FAIL();
|
|
}
|
|
|
|
ERR_FAIL_COND(empty());
|
|
|
|
Image normalmap(width, height, 0, FORMAT_RGB);
|
|
/*
|
|
for (int y=0;y<height;y++) {
|
|
for (int x=0;x<width;x++) {
|
|
|
|
float center=get_pixel(x,y).gray()/255.0;
|
|
float up=(y>0)?get_pixel(x,y-1).gray()/255.0:center;
|
|
float down=(y<(height-1))?get_pixel(x,y+1).gray()/255.0:center;
|
|
float left=(x>0)?get_pixel(x-1,y).gray()/255.0:center;
|
|
float right=(x<(width-1))?get_pixel(x+1,y).gray()/255.0:center;
|
|
|
|
|
|
// uhm, how do i do this? ....
|
|
|
|
Color result( (uint8_t)((normal.x+1.0)*127.0), (uint8_t)((normal.y+1.0)*127.0), (uint8_t)((normal.z+1.0)*127.0) );
|
|
|
|
normalmap.put_pixel( x, y, result );
|
|
}
|
|
|
|
}
|
|
*/
|
|
*this = normalmap;
|
|
}
|
|
|
|
bool Image::empty() const {
|
|
|
|
return (data.size() == 0);
|
|
}
|
|
|
|
DVector<uint8_t> Image::get_data() const {
|
|
|
|
return data;
|
|
}
|
|
|
|
void Image::create(int p_width, int p_height, bool p_use_mipmaps, Format p_format) {
|
|
|
|
int mm = 0;
|
|
int size = _get_dst_image_size(p_width, p_height, p_format, mm, p_use_mipmaps ? -1 : 0);
|
|
data.resize(size);
|
|
{
|
|
DVector<uint8_t>::Write w = data.write();
|
|
zeromem(w.ptr(), size);
|
|
}
|
|
|
|
width = p_width;
|
|
height = p_height;
|
|
mipmaps = mm;
|
|
format = p_format;
|
|
}
|
|
|
|
void Image::create(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t> &p_data) {
|
|
|
|
ERR_FAIL_INDEX(p_width - 1, MAX_WIDTH);
|
|
ERR_FAIL_INDEX(p_height - 1, MAX_HEIGHT);
|
|
|
|
if (p_format < FORMAT_CUSTOM) {
|
|
int mm;
|
|
int size = _get_dst_image_size(p_width, p_height, p_format, mm, p_mipmaps);
|
|
|
|
if (size != p_data.size()) {
|
|
ERR_EXPLAIN("Expected data size of " + itos(size) + " in Image::create()");
|
|
ERR_FAIL_COND(p_data.size() != size);
|
|
}
|
|
};
|
|
|
|
height = p_height;
|
|
width = p_width;
|
|
format = p_format;
|
|
data = p_data;
|
|
mipmaps = p_mipmaps;
|
|
}
|
|
|
|
void Image::create(const char **p_xpm) {
|
|
|
|
int size_width, size_height;
|
|
int pixelchars = 0;
|
|
mipmaps = 0;
|
|
bool has_alpha = false;
|
|
|
|
enum Status {
|
|
READING_HEADER,
|
|
READING_COLORS,
|
|
READING_PIXELS,
|
|
DONE
|
|
};
|
|
|
|
Status status = READING_HEADER;
|
|
int line = 0;
|
|
|
|
HashMap<String, Color> colormap;
|
|
int colormap_size;
|
|
|
|
while (status != DONE) {
|
|
|
|
const char *line_ptr = p_xpm[line];
|
|
|
|
switch (status) {
|
|
|
|
case READING_HEADER: {
|
|
|
|
String line_str = line_ptr;
|
|
line_str.replace("\t", " ");
|
|
|
|
size_width = line_str.get_slicec(' ', 0).to_int();
|
|
size_height = line_str.get_slicec(' ', 1).to_int();
|
|
colormap_size = line_str.get_slicec(' ', 2).to_int();
|
|
pixelchars = line_str.get_slicec(' ', 3).to_int();
|
|
ERR_FAIL_COND(colormap_size > 32766);
|
|
ERR_FAIL_COND(pixelchars > 5);
|
|
ERR_FAIL_COND(size_width > 32767);
|
|
ERR_FAIL_COND(size_height > 32767);
|
|
status = READING_COLORS;
|
|
} break;
|
|
case READING_COLORS: {
|
|
|
|
String colorstring;
|
|
for (int i = 0; i < pixelchars; i++) {
|
|
|
|
colorstring += *line_ptr;
|
|
line_ptr++;
|
|
}
|
|
//skip spaces
|
|
while (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == 0) {
|
|
if (*line_ptr == 0)
|
|
break;
|
|
line_ptr++;
|
|
}
|
|
if (*line_ptr == 'c') {
|
|
|
|
line_ptr++;
|
|
while (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == 0) {
|
|
if (*line_ptr == 0)
|
|
break;
|
|
line_ptr++;
|
|
}
|
|
|
|
if (*line_ptr == '#') {
|
|
line_ptr++;
|
|
uint8_t col_r;
|
|
uint8_t col_g;
|
|
uint8_t col_b;
|
|
// uint8_t col_a=255;
|
|
|
|
for (int i = 0; i < 6; i++) {
|
|
|
|
char v = line_ptr[i];
|
|
|
|
if (v >= '0' && v <= '9')
|
|
v -= '0';
|
|
else if (v >= 'A' && v <= 'F')
|
|
v = (v - 'A') + 10;
|
|
else if (v >= 'a' && v <= 'f')
|
|
v = (v - 'a') + 10;
|
|
else
|
|
break;
|
|
|
|
switch (i) {
|
|
case 0: col_r = v << 4; break;
|
|
case 1: col_r |= v; break;
|
|
case 2: col_g = v << 4; break;
|
|
case 3: col_g |= v; break;
|
|
case 4: col_b = v << 4; break;
|
|
case 5: col_b |= v; break;
|
|
};
|
|
}
|
|
|
|
// magenta mask
|
|
if (col_r == 255 && col_g == 0 && col_b == 255) {
|
|
|
|
colormap[colorstring] = Color(0, 0, 0, 0);
|
|
has_alpha = true;
|
|
} else {
|
|
|
|
colormap[colorstring] = Color(col_r / 255.0, col_g / 255.0, col_b / 255.0, 1.0);
|
|
}
|
|
}
|
|
}
|
|
if (line == colormap_size) {
|
|
|
|
status = READING_PIXELS;
|
|
create(size_width, size_height, 0, has_alpha ? FORMAT_RGBA : FORMAT_RGB);
|
|
}
|
|
} break;
|
|
case READING_PIXELS: {
|
|
|
|
int y = line - colormap_size - 1;
|
|
for (int x = 0; x < size_width; x++) {
|
|
|
|
char pixelstr[6] = { 0, 0, 0, 0, 0, 0 };
|
|
for (int i = 0; i < pixelchars; i++)
|
|
pixelstr[i] = line_ptr[x * pixelchars + i];
|
|
|
|
Color *colorptr = colormap.getptr(pixelstr);
|
|
ERR_FAIL_COND(!colorptr);
|
|
put_pixel(x, y, *colorptr);
|
|
}
|
|
|
|
if (y == (size_height - 1))
|
|
status = DONE;
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
line++;
|
|
}
|
|
}
|
|
#define DETECT_ALPHA_MAX_TRESHOLD 254
|
|
#define DETECT_ALPHA_MIN_TRESHOLD 2
|
|
|
|
#define DETECT_ALPHA(m_value) \
|
|
{ \
|
|
uint8_t value = m_value; \
|
|
if (value < DETECT_ALPHA_MIN_TRESHOLD) \
|
|
bit = true; \
|
|
else if (value < DETECT_ALPHA_MAX_TRESHOLD) { \
|
|
\
|
|
detected = true; \
|
|
break; \
|
|
} \
|
|
}
|
|
|
|
#define DETECT_NON_ALPHA(m_value) \
|
|
{ \
|
|
uint8_t value = m_value; \
|
|
if (value > 0) { \
|
|
\
|
|
detected = true; \
|
|
break; \
|
|
} \
|
|
}
|
|
|
|
bool Image::is_invisible() const {
|
|
|
|
if (format == FORMAT_GRAYSCALE ||
|
|
format == FORMAT_RGB ||
|
|
format == FORMAT_INDEXED)
|
|
return false;
|
|
|
|
int len = data.size();
|
|
|
|
if (len == 0)
|
|
return true;
|
|
|
|
if (format >= FORMAT_YUV_422 && format <= FORMAT_YUV_444)
|
|
return false;
|
|
|
|
int w, h;
|
|
_get_mipmap_offset_and_size(1, len, w, h);
|
|
|
|
DVector<uint8_t>::Read r = data.read();
|
|
const unsigned char *data_ptr = r.ptr();
|
|
|
|
bool detected = false;
|
|
|
|
switch (format) {
|
|
case FORMAT_INTENSITY: {
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
DETECT_NON_ALPHA(data_ptr[i]);
|
|
}
|
|
} break;
|
|
case FORMAT_GRAYSCALE_ALPHA: {
|
|
|
|
for (int i = 0; i < (len >> 1); i++) {
|
|
DETECT_NON_ALPHA(data_ptr[(i << 1) + 1]);
|
|
}
|
|
|
|
} break;
|
|
case FORMAT_RGBA: {
|
|
|
|
for (int i = 0; i < (len >> 2); i++) {
|
|
DETECT_NON_ALPHA(data_ptr[(i << 2) + 3])
|
|
}
|
|
|
|
} break;
|
|
case FORMAT_INDEXED: {
|
|
|
|
return false;
|
|
} break;
|
|
case FORMAT_INDEXED_ALPHA: {
|
|
|
|
return false;
|
|
} break;
|
|
case FORMAT_PVRTC2_ALPHA:
|
|
case FORMAT_PVRTC4_ALPHA:
|
|
case FORMAT_BC2:
|
|
case FORMAT_BC3: {
|
|
detected = true;
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
return !detected;
|
|
}
|
|
|
|
Image::AlphaMode Image::detect_alpha() const {
|
|
|
|
if (format == FORMAT_GRAYSCALE ||
|
|
format == FORMAT_RGB ||
|
|
format == FORMAT_INDEXED)
|
|
return ALPHA_NONE;
|
|
|
|
int len = data.size();
|
|
|
|
if (len == 0)
|
|
return ALPHA_NONE;
|
|
|
|
if (format >= FORMAT_YUV_422 && format <= FORMAT_YUV_444)
|
|
return ALPHA_NONE;
|
|
|
|
int w, h;
|
|
_get_mipmap_offset_and_size(1, len, w, h);
|
|
|
|
DVector<uint8_t>::Read r = data.read();
|
|
const unsigned char *data_ptr = r.ptr();
|
|
|
|
bool bit = false;
|
|
bool detected = false;
|
|
|
|
switch (format) {
|
|
case FORMAT_INTENSITY: {
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
DETECT_ALPHA(data_ptr[i]);
|
|
}
|
|
} break;
|
|
case FORMAT_GRAYSCALE_ALPHA: {
|
|
|
|
for (int i = 0; i < (len >> 1); i++) {
|
|
DETECT_ALPHA(data_ptr[(i << 1) + 1]);
|
|
}
|
|
|
|
} break;
|
|
case FORMAT_RGBA: {
|
|
|
|
for (int i = 0; i < (len >> 2); i++) {
|
|
DETECT_ALPHA(data_ptr[(i << 2) + 3])
|
|
}
|
|
|
|
} break;
|
|
case FORMAT_INDEXED: {
|
|
|
|
return ALPHA_NONE;
|
|
} break;
|
|
case FORMAT_INDEXED_ALPHA: {
|
|
|
|
return ALPHA_BLEND;
|
|
} break;
|
|
case FORMAT_PVRTC2_ALPHA:
|
|
case FORMAT_PVRTC4_ALPHA:
|
|
case FORMAT_BC2:
|
|
case FORMAT_BC3: {
|
|
detected = true;
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
if (detected)
|
|
return ALPHA_BLEND;
|
|
else if (bit)
|
|
return ALPHA_BIT;
|
|
else
|
|
return ALPHA_NONE;
|
|
}
|
|
|
|
Error Image::load(const String &p_path) {
|
|
|
|
return ImageLoader::load_image(p_path, this);
|
|
}
|
|
|
|
Error Image::save_png(const String &p_path) {
|
|
|
|
if (save_png_func == NULL)
|
|
return ERR_UNAVAILABLE;
|
|
|
|
return save_png_func(p_path, *this);
|
|
};
|
|
|
|
bool Image::operator==(const Image &p_image) const {
|
|
|
|
if (data.size() == 0 && p_image.data.size() == 0)
|
|
return true;
|
|
DVector<uint8_t>::Read r = data.read();
|
|
DVector<uint8_t>::Read pr = p_image.data.read();
|
|
|
|
return r.ptr() == pr.ptr();
|
|
}
|
|
|
|
int Image::get_format_pixel_size(Format p_format) {
|
|
|
|
switch (p_format) {
|
|
case FORMAT_GRAYSCALE: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_INTENSITY: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_GRAYSCALE_ALPHA: {
|
|
|
|
return 2;
|
|
} break;
|
|
case FORMAT_RGB: {
|
|
|
|
return 3;
|
|
} break;
|
|
case FORMAT_RGBA: {
|
|
|
|
return 4;
|
|
} break;
|
|
case FORMAT_INDEXED: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_INDEXED_ALPHA: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_BC1:
|
|
case FORMAT_BC2:
|
|
case FORMAT_BC3:
|
|
case FORMAT_BC4:
|
|
case FORMAT_BC5: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_PVRTC2:
|
|
case FORMAT_PVRTC2_ALPHA: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_PVRTC4:
|
|
case FORMAT_PVRTC4_ALPHA: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_ATC:
|
|
case FORMAT_ATC_ALPHA_EXPLICIT:
|
|
case FORMAT_ATC_ALPHA_INTERPOLATED: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_ETC: {
|
|
|
|
return 1;
|
|
} break;
|
|
case FORMAT_YUV_422: {
|
|
return 2;
|
|
};
|
|
case FORMAT_YUV_444: {
|
|
return 3;
|
|
} break;
|
|
case FORMAT_CUSTOM: {
|
|
|
|
ERR_EXPLAIN("pixel size requested for custom image format, and it's unknown obviously");
|
|
ERR_FAIL_V(1);
|
|
} break;
|
|
default: {
|
|
ERR_EXPLAIN("Cannot obtain pixel size from this format");
|
|
ERR_FAIL_V(1);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Image::get_image_data_size(int p_width, int p_height, Format p_format, int p_mipmaps) {
|
|
|
|
int mm;
|
|
return _get_dst_image_size(p_width, p_height, p_format, mm, p_mipmaps);
|
|
}
|
|
|
|
int Image::get_image_required_mipmaps(int p_width, int p_height, Format p_format) {
|
|
|
|
int mm;
|
|
_get_dst_image_size(p_width, p_height, p_format, mm, -1);
|
|
return mm;
|
|
}
|
|
|
|
void Image::_get_format_min_data_size(Format p_format, int &r_w, int &r_h) {
|
|
|
|
switch (p_format) {
|
|
case FORMAT_BC1:
|
|
case FORMAT_BC2:
|
|
case FORMAT_BC3:
|
|
case FORMAT_BC4:
|
|
case FORMAT_BC5: {
|
|
r_w = 4;
|
|
r_h = 4;
|
|
} break;
|
|
case FORMAT_PVRTC2:
|
|
case FORMAT_PVRTC2_ALPHA: {
|
|
|
|
r_w = 16;
|
|
r_h = 8;
|
|
} break;
|
|
case FORMAT_PVRTC4_ALPHA:
|
|
case FORMAT_PVRTC4: {
|
|
|
|
r_w = 8;
|
|
r_h = 8;
|
|
} break;
|
|
case FORMAT_ATC:
|
|
case FORMAT_ATC_ALPHA_EXPLICIT:
|
|
case FORMAT_ATC_ALPHA_INTERPOLATED: {
|
|
|
|
r_w = 8;
|
|
r_h = 8;
|
|
|
|
} break;
|
|
|
|
case FORMAT_ETC: {
|
|
|
|
r_w = 4;
|
|
r_h = 4;
|
|
} break;
|
|
default: {
|
|
r_w = 1;
|
|
r_h = 1;
|
|
} break;
|
|
}
|
|
}
|
|
|
|
int Image::get_format_pixel_rshift(Format p_format) {
|
|
|
|
if (p_format == FORMAT_BC1 || p_format == FORMAT_BC4 || p_format == FORMAT_ATC || p_format == FORMAT_PVRTC4 || p_format == FORMAT_PVRTC4_ALPHA || p_format == FORMAT_ETC)
|
|
return 1;
|
|
else if (p_format == FORMAT_PVRTC2 || p_format == FORMAT_PVRTC2_ALPHA)
|
|
return 2;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int Image::get_format_pallete_size(Format p_format) {
|
|
|
|
switch (p_format) {
|
|
case FORMAT_GRAYSCALE: {
|
|
|
|
return 0;
|
|
} break;
|
|
case FORMAT_INTENSITY: {
|
|
|
|
return 0;
|
|
} break;
|
|
case FORMAT_GRAYSCALE_ALPHA: {
|
|
|
|
return 0;
|
|
} break;
|
|
case FORMAT_RGB: {
|
|
|
|
return 0;
|
|
} break;
|
|
case FORMAT_RGBA: {
|
|
|
|
return 0;
|
|
} break;
|
|
case FORMAT_INDEXED: {
|
|
|
|
return 3 * 256;
|
|
} break;
|
|
case FORMAT_INDEXED_ALPHA: {
|
|
|
|
return 4 * 256;
|
|
} break;
|
|
default: {}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Error Image::_decompress_bc() {
|
|
|
|
print_line("decompressing bc");
|
|
|
|
int wd = width, ht = height;
|
|
if (wd % 4 != 0) {
|
|
wd += 4 - (wd % 4);
|
|
}
|
|
if (ht % 4 != 0) {
|
|
ht += 4 - (ht % 4);
|
|
}
|
|
|
|
int mm;
|
|
int size = _get_dst_image_size(wd, ht, FORMAT_RGBA, mm, mipmaps);
|
|
|
|
DVector<uint8_t> newdata;
|
|
newdata.resize(size);
|
|
|
|
DVector<uint8_t>::Write w = newdata.write();
|
|
DVector<uint8_t>::Read r = data.read();
|
|
|
|
int rofs = 0;
|
|
int wofs = 0;
|
|
|
|
//print_line("width: "+itos(wd)+" height: "+itos(ht));
|
|
|
|
for (int i = 0; i <= mm; i++) {
|
|
|
|
switch (format) {
|
|
|
|
case FORMAT_BC1: {
|
|
|
|
int len = (wd * ht) / 16;
|
|
uint8_t *dst = &w[wofs];
|
|
|
|
uint32_t ofs_table[16];
|
|
for (int x = 0; x < 4; x++) {
|
|
|
|
for (int y = 0; y < 4; y++) {
|
|
|
|
ofs_table[15 - (y * 4 + (3 - x))] = (x + y * wd) * 4;
|
|
}
|
|
}
|
|
|
|
for (int j = 0; j < len; j++) {
|
|
|
|
const uint8_t *src = &r[rofs + j * 8];
|
|
uint16_t col_a = src[1];
|
|
col_a <<= 8;
|
|
col_a |= src[0];
|
|
uint16_t col_b = src[3];
|
|
col_b <<= 8;
|
|
col_b |= src[2];
|
|
|
|
uint8_t table[4][4] = {
|
|
{ (col_a >> 11) << 3, ((col_a >> 5) & 0x3f) << 2, ((col_a)&0x1f) << 3, 255 },
|
|
{ (col_b >> 11) << 3, ((col_b >> 5) & 0x3f) << 2, ((col_b)&0x1f) << 3, 255 },
|
|
{ 0, 0, 0, 255 },
|
|
{ 0, 0, 0, 255 }
|
|
};
|
|
|
|
if (col_a < col_b) {
|
|
//punchrough
|
|
table[2][0] = (int(table[0][0]) + int(table[1][0])) >> 1;
|
|
table[2][1] = (int(table[0][1]) + int(table[1][1])) >> 1;
|
|
table[2][2] = (int(table[0][2]) + int(table[1][2])) >> 1;
|
|
table[3][3] = 0; //premul alpha black
|
|
} else {
|
|
//gradient
|
|
table[2][0] = (int(table[0][0]) * 2 + int(table[1][0])) / 3;
|
|
table[2][1] = (int(table[0][1]) * 2 + int(table[1][1])) / 3;
|
|
table[2][2] = (int(table[0][2]) * 2 + int(table[1][2])) / 3;
|
|
table[3][0] = (int(table[0][0]) + int(table[1][0]) * 2) / 3;
|
|
table[3][1] = (int(table[0][1]) + int(table[1][1]) * 2) / 3;
|
|
table[3][2] = (int(table[0][2]) + int(table[1][2]) * 2) / 3;
|
|
}
|
|
|
|
uint32_t block = src[4];
|
|
block <<= 8;
|
|
block |= src[5];
|
|
block <<= 8;
|
|
block |= src[6];
|
|
block <<= 8;
|
|
block |= src[7];
|
|
|
|
int y = (j / (wd / 4)) * 4;
|
|
int x = (j % (wd / 4)) * 4;
|
|
int pixofs = (y * wd + x) * 4;
|
|
|
|
for (int k = 0; k < 16; k++) {
|
|
int idx = pixofs + ofs_table[k];
|
|
dst[idx + 0] = table[block & 0x3][0];
|
|
dst[idx + 1] = table[block & 0x3][1];
|
|
dst[idx + 2] = table[block & 0x3][2];
|
|
dst[idx + 3] = table[block & 0x3][3];
|
|
block >>= 2;
|
|
}
|
|
}
|
|
|
|
rofs += len * 8;
|
|
wofs += wd * ht * 4;
|
|
|
|
wd /= 2;
|
|
ht /= 2;
|
|
|
|
} break;
|
|
case FORMAT_BC2: {
|
|
|
|
int len = (wd * ht) / 16;
|
|
uint8_t *dst = &w[wofs];
|
|
|
|
uint32_t ofs_table[16];
|
|
for (int x = 0; x < 4; x++) {
|
|
|
|
for (int y = 0; y < 4; y++) {
|
|
|
|
ofs_table[15 - (y * 4 + (3 - x))] = (x + y * wd) * 4;
|
|
}
|
|
}
|
|
|
|
for (int j = 0; j < len; j++) {
|
|
|
|
const uint8_t *src = &r[rofs + j * 16];
|
|
|
|
uint64_t ablock = src[1];
|
|
ablock <<= 8;
|
|
ablock |= src[0];
|
|
ablock <<= 8;
|
|
ablock |= src[3];
|
|
ablock <<= 8;
|
|
ablock |= src[2];
|
|
ablock <<= 8;
|
|
ablock |= src[5];
|
|
ablock <<= 8;
|
|
ablock |= src[4];
|
|
ablock <<= 8;
|
|
ablock |= src[7];
|
|
ablock <<= 8;
|
|
ablock |= src[6];
|
|
|
|
uint16_t col_a = src[8 + 1];
|
|
col_a <<= 8;
|
|
col_a |= src[8 + 0];
|
|
uint16_t col_b = src[8 + 3];
|
|
col_b <<= 8;
|
|
col_b |= src[8 + 2];
|
|
|
|
uint8_t table[4][4] = {
|
|
{ (col_a >> 11) << 3, ((col_a >> 5) & 0x3f) << 2, ((col_a)&0x1f) << 3, 255 },
|
|
{ (col_b >> 11) << 3, ((col_b >> 5) & 0x3f) << 2, ((col_b)&0x1f) << 3, 255 },
|
|
{ 0, 0, 0, 255 },
|
|
{ 0, 0, 0, 255 }
|
|
};
|
|
|
|
//always gradient
|
|
table[2][0] = (int(table[0][0]) * 2 + int(table[1][0])) / 3;
|
|
table[2][1] = (int(table[0][1]) * 2 + int(table[1][1])) / 3;
|
|
table[2][2] = (int(table[0][2]) * 2 + int(table[1][2])) / 3;
|
|
table[3][0] = (int(table[0][0]) + int(table[1][0]) * 2) / 3;
|
|
table[3][1] = (int(table[0][1]) + int(table[1][1]) * 2) / 3;
|
|
table[3][2] = (int(table[0][2]) + int(table[1][2]) * 2) / 3;
|
|
|
|
uint32_t block = src[4 + 8];
|
|
block <<= 8;
|
|
block |= src[5 + 8];
|
|
block <<= 8;
|
|
block |= src[6 + 8];
|
|
block <<= 8;
|
|
block |= src[7 + 8];
|
|
|
|
int y = (j / (wd / 4)) * 4;
|
|
int x = (j % (wd / 4)) * 4;
|
|
int pixofs = (y * wd + x) * 4;
|
|
|
|
for (int k = 0; k < 16; k++) {
|
|
uint8_t alpha = ablock & 0xf;
|
|
alpha = int(alpha) * 255 / 15; //right way for alpha
|
|
int idx = pixofs + ofs_table[k];
|
|
dst[idx + 0] = table[block & 0x3][0];
|
|
dst[idx + 1] = table[block & 0x3][1];
|
|
dst[idx + 2] = table[block & 0x3][2];
|
|
dst[idx + 3] = alpha;
|
|
block >>= 2;
|
|
ablock >>= 4;
|
|
}
|
|
}
|
|
|
|
rofs += len * 16;
|
|
wofs += wd * ht * 4;
|
|
|
|
wd /= 2;
|
|
ht /= 2;
|
|
|
|
} break;
|
|
case FORMAT_BC3: {
|
|
|
|
int len = (wd * ht) / 16;
|
|
uint8_t *dst = &w[wofs];
|
|
|
|
uint32_t ofs_table[16];
|
|
for (int x = 0; x < 4; x++) {
|
|
|
|
for (int y = 0; y < 4; y++) {
|
|
|
|
ofs_table[15 - (y * 4 + (3 - x))] = (x + y * wd) * 4;
|
|
}
|
|
}
|
|
|
|
for (int j = 0; j < len; j++) {
|
|
|
|
const uint8_t *src = &r[rofs + j * 16];
|
|
|
|
uint8_t a_start = src[1];
|
|
uint8_t a_end = src[0];
|
|
|
|
uint64_t ablock = src[3];
|
|
ablock <<= 8;
|
|
ablock |= src[2];
|
|
ablock <<= 8;
|
|
ablock |= src[5];
|
|
ablock <<= 8;
|
|
ablock |= src[4];
|
|
ablock <<= 8;
|
|
ablock |= src[7];
|
|
ablock <<= 8;
|
|
ablock |= src[6];
|
|
|
|
uint8_t atable[8];
|
|
|
|
if (a_start > a_end) {
|
|
|
|
atable[0] = (int(a_start) * 7 + int(a_end) * 0) / 7;
|
|
atable[1] = (int(a_start) * 6 + int(a_end) * 1) / 7;
|
|
atable[2] = (int(a_start) * 5 + int(a_end) * 2) / 7;
|
|
atable[3] = (int(a_start) * 4 + int(a_end) * 3) / 7;
|
|
atable[4] = (int(a_start) * 3 + int(a_end) * 4) / 7;
|
|
atable[5] = (int(a_start) * 2 + int(a_end) * 5) / 7;
|
|
atable[6] = (int(a_start) * 1 + int(a_end) * 6) / 7;
|
|
atable[7] = (int(a_start) * 0 + int(a_end) * 7) / 7;
|
|
} else {
|
|
|
|
atable[0] = (int(a_start) * 5 + int(a_end) * 0) / 5;
|
|
atable[1] = (int(a_start) * 4 + int(a_end) * 1) / 5;
|
|
atable[2] = (int(a_start) * 3 + int(a_end) * 2) / 5;
|
|
atable[3] = (int(a_start) * 2 + int(a_end) * 3) / 5;
|
|
atable[4] = (int(a_start) * 1 + int(a_end) * 4) / 5;
|
|
atable[5] = (int(a_start) * 0 + int(a_end) * 5) / 5;
|
|
atable[6] = 0;
|
|
atable[7] = 255;
|
|
}
|
|
|
|
uint16_t col_a = src[8 + 1];
|
|
col_a <<= 8;
|
|
col_a |= src[8 + 0];
|
|
uint16_t col_b = src[8 + 3];
|
|
col_b <<= 8;
|
|
col_b |= src[8 + 2];
|
|
|
|
uint8_t table[4][4] = {
|
|
{ (col_a >> 11) << 3, ((col_a >> 5) & 0x3f) << 2, ((col_a)&0x1f) << 3, 255 },
|
|
{ (col_b >> 11) << 3, ((col_b >> 5) & 0x3f) << 2, ((col_b)&0x1f) << 3, 255 },
|
|
{ 0, 0, 0, 255 },
|
|
{ 0, 0, 0, 255 }
|
|
};
|
|
|
|
//always gradient
|
|
table[2][0] = (int(table[0][0]) * 2 + int(table[1][0])) / 3;
|
|
table[2][1] = (int(table[0][1]) * 2 + int(table[1][1])) / 3;
|
|
table[2][2] = (int(table[0][2]) * 2 + int(table[1][2])) / 3;
|
|
table[3][0] = (int(table[0][0]) + int(table[1][0]) * 2) / 3;
|
|
table[3][1] = (int(table[0][1]) + int(table[1][1]) * 2) / 3;
|
|
table[3][2] = (int(table[0][2]) + int(table[1][2]) * 2) / 3;
|
|
|
|
uint32_t block = src[4 + 8];
|
|
block <<= 8;
|
|
block |= src[5 + 8];
|
|
block <<= 8;
|
|
block |= src[6 + 8];
|
|
block <<= 8;
|
|
block |= src[7 + 8];
|
|
|
|
int y = (j / (wd / 4)) * 4;
|
|
int x = (j % (wd / 4)) * 4;
|
|
int pixofs = (y * wd + x) * 4;
|
|
|
|
for (int k = 0; k < 16; k++) {
|
|
uint8_t alpha = ablock & 0x7;
|
|
int idx = pixofs + ofs_table[k];
|
|
dst[idx + 0] = table[block & 0x3][0];
|
|
dst[idx + 1] = table[block & 0x3][1];
|
|
dst[idx + 2] = table[block & 0x3][2];
|
|
dst[idx + 3] = atable[alpha];
|
|
block >>= 2;
|
|
ablock >>= 3;
|
|
}
|
|
}
|
|
|
|
rofs += len * 16;
|
|
wofs += wd * ht * 4;
|
|
|
|
wd /= 2;
|
|
ht /= 2;
|
|
|
|
} break;
|
|
}
|
|
}
|
|
|
|
w = DVector<uint8_t>::Write();
|
|
r = DVector<uint8_t>::Read();
|
|
|
|
data = newdata;
|
|
format = FORMAT_RGBA;
|
|
if (wd != width || ht != height) {
|
|
//todo, crop
|
|
width = wd;
|
|
height = ht;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
bool Image::is_compressed() const {
|
|
return format >= FORMAT_BC1;
|
|
}
|
|
|
|
Image Image::decompressed() const {
|
|
|
|
Image img = *this;
|
|
img.decompress();
|
|
return img;
|
|
}
|
|
|
|
Error Image::decompress() {
|
|
|
|
if (format >= FORMAT_BC1 && format <= FORMAT_BC5)
|
|
_decompress_bc(); //_image_decompress_bc(this);
|
|
else if (format >= FORMAT_PVRTC2 && format <= FORMAT_PVRTC4_ALPHA && _image_decompress_pvrtc)
|
|
_image_decompress_pvrtc(this);
|
|
else if (format == FORMAT_ETC && _image_decompress_etc)
|
|
_image_decompress_etc(this);
|
|
else
|
|
return ERR_UNAVAILABLE;
|
|
return OK;
|
|
}
|
|
|
|
Error Image::compress(CompressMode p_mode) {
|
|
|
|
switch (p_mode) {
|
|
|
|
case COMPRESS_BC: {
|
|
|
|
ERR_FAIL_COND_V(!_image_compress_bc_func, ERR_UNAVAILABLE);
|
|
_image_compress_bc_func(this);
|
|
} break;
|
|
case COMPRESS_PVRTC2: {
|
|
|
|
ERR_FAIL_COND_V(!_image_compress_pvrtc2_func, ERR_UNAVAILABLE);
|
|
_image_compress_pvrtc2_func(this);
|
|
} break;
|
|
case COMPRESS_PVRTC4: {
|
|
|
|
ERR_FAIL_COND_V(!_image_compress_pvrtc4_func, ERR_UNAVAILABLE);
|
|
_image_compress_pvrtc4_func(this);
|
|
} break;
|
|
case COMPRESS_ETC: {
|
|
|
|
ERR_FAIL_COND_V(!_image_compress_etc_func, ERR_UNAVAILABLE);
|
|
_image_compress_etc_func(this);
|
|
} break;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Image Image::compressed(int p_mode) {
|
|
|
|
Image ret = *this;
|
|
ret.compress((Image::CompressMode)p_mode);
|
|
|
|
return ret;
|
|
};
|
|
|
|
Image::Image(const char **p_xpm) {
|
|
|
|
width = 0;
|
|
height = 0;
|
|
mipmaps = 0;
|
|
format = FORMAT_GRAYSCALE;
|
|
|
|
create(p_xpm);
|
|
}
|
|
|
|
Image::Image(int p_width, int p_height, bool p_use_mipmaps, Format p_format) {
|
|
|
|
width = 0;
|
|
height = 0;
|
|
mipmaps = 0;
|
|
format = FORMAT_GRAYSCALE;
|
|
|
|
create(p_width, p_height, p_use_mipmaps, p_format);
|
|
}
|
|
|
|
Image::Image(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector<uint8_t> &p_data) {
|
|
|
|
width = 0;
|
|
height = 0;
|
|
mipmaps = 0;
|
|
format = FORMAT_GRAYSCALE;
|
|
|
|
create(p_width, p_height, p_mipmaps, p_format, p_data);
|
|
}
|
|
|
|
Image Image::brushed(const Image &p_src, const Image &p_brush, const Point2 &p_dest) const {
|
|
|
|
Image img = *this;
|
|
img.brush_transfer(p_src, p_brush, p_dest);
|
|
return img;
|
|
}
|
|
|
|
Rect2 Image::get_used_rect() const {
|
|
|
|
if (format == FORMAT_GRAYSCALE ||
|
|
format == FORMAT_RGB ||
|
|
format == FORMAT_INDEXED || format > FORMAT_INDEXED_ALPHA)
|
|
return Rect2(Point2(), Size2(width, height));
|
|
|
|
int len = data.size();
|
|
|
|
if (len == 0)
|
|
return Rect2();
|
|
|
|
int data_size = len;
|
|
DVector<uint8_t>::Read r = data.read();
|
|
const unsigned char *rptr = r.ptr();
|
|
|
|
int minx = 0xFFFFFF, miny = 0xFFFFFFF;
|
|
int maxx = -1, maxy = -1;
|
|
for (int i = 0; i < width; i++) {
|
|
for (int j = 0; j < height; j++) {
|
|
|
|
bool opaque = _get_pixel(i, j, rptr, data_size).a > 2;
|
|
if (!opaque)
|
|
continue;
|
|
if (i > maxx)
|
|
maxx = i;
|
|
if (j > maxy)
|
|
maxy = j;
|
|
if (i < minx)
|
|
minx = i;
|
|
if (j < miny)
|
|
miny = j;
|
|
}
|
|
}
|
|
|
|
if (maxx == -1)
|
|
return Rect2();
|
|
else
|
|
return Rect2(minx, miny, maxx - minx + 1, maxy - miny + 1);
|
|
}
|
|
|
|
Image Image::get_rect(const Rect2 &p_area) const {
|
|
|
|
Image img(p_area.size.x, p_area.size.y, mipmaps, format);
|
|
img.blit_rect(*this, p_area, Point2(0, 0));
|
|
|
|
return img;
|
|
};
|
|
|
|
void Image::brush_transfer(const Image &p_src, const Image &p_brush, const Point2 &p_dest) {
|
|
|
|
ERR_FAIL_COND(width != p_src.width || height != p_src.height);
|
|
|
|
int dst_data_size = data.size();
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *dst_data_ptr = wp.ptr();
|
|
|
|
int src_data_size = p_src.data.size();
|
|
DVector<uint8_t>::Read rp = p_src.data.read();
|
|
const unsigned char *src_data_ptr = rp.ptr();
|
|
|
|
int brush_data_size = p_brush.data.size();
|
|
DVector<uint8_t>::Read bp = p_brush.data.read();
|
|
const unsigned char *src_brush_ptr = bp.ptr();
|
|
|
|
int bw = p_brush.get_width();
|
|
int bh = p_brush.get_height();
|
|
int dx = p_dest.x;
|
|
int dy = p_dest.y;
|
|
|
|
for (int i = dy; i < dy + bh; i++) {
|
|
|
|
if (i < 0 || i >= height)
|
|
continue;
|
|
for (int j = dx; j < dx + bw; j++) {
|
|
|
|
if (j < 0 || j >= width)
|
|
continue;
|
|
|
|
BColor src = p_src._get_pixel(j, i, src_data_ptr, src_data_size);
|
|
BColor dst = _get_pixel(j, i, dst_data_ptr, dst_data_size);
|
|
BColor brush = p_brush._get_pixel(j - dx, i - dy, src_brush_ptr, brush_data_size);
|
|
uint32_t mult = brush.r;
|
|
dst.r = dst.r + (((int32_t(src.r) - int32_t(dst.r)) * mult) >> 8);
|
|
dst.g = dst.g + (((int32_t(src.g) - int32_t(dst.g)) * mult) >> 8);
|
|
dst.b = dst.b + (((int32_t(src.b) - int32_t(dst.b)) * mult) >> 8);
|
|
dst.a = dst.a + (((int32_t(src.a) - int32_t(dst.a)) * mult) >> 8);
|
|
_put_pixel(j, i, dst, dst_data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 &p_dest) {
|
|
|
|
int dsize = data.size();
|
|
int srcdsize = p_src.data.size();
|
|
ERR_FAIL_COND(dsize == 0);
|
|
ERR_FAIL_COND(srcdsize == 0);
|
|
|
|
Rect2 rrect = Rect2(0, 0, p_src.width, p_src.height).clip(p_src_rect);
|
|
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *dst_data_ptr = wp.ptr();
|
|
|
|
DVector<uint8_t>::Read rp = p_src.data.read();
|
|
const unsigned char *src_data_ptr = rp.ptr();
|
|
|
|
if ((format == FORMAT_INDEXED || format == FORMAT_INDEXED_ALPHA) && (p_src.format == FORMAT_INDEXED || p_src.format == FORMAT_INDEXED_ALPHA)) {
|
|
|
|
Point2i desti(p_dest.x, p_dest.y);
|
|
Point2i srci(rrect.pos.x, rrect.pos.y);
|
|
|
|
for (int i = 0; i < rrect.size.y; i++) {
|
|
|
|
if (i < 0 || i >= height)
|
|
continue;
|
|
for (int j = 0; j < rrect.size.x; j++) {
|
|
|
|
if (j < 0 || j >= width)
|
|
continue;
|
|
|
|
dst_data_ptr[width * (desti.y + i) + desti.x + j] = src_data_ptr[p_src.width * (srci.y + i) + srci.x + j];
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
for (int i = 0; i < rrect.size.y; i++) {
|
|
|
|
if (i < 0 || i >= height)
|
|
continue;
|
|
for (int j = 0; j < rrect.size.x; j++) {
|
|
|
|
if (j < 0 || j >= width)
|
|
continue;
|
|
|
|
_put_pixel(p_dest.x + j, p_dest.y + i, p_src._get_pixel(rrect.pos.x + j, rrect.pos.y + i, src_data_ptr, srcdsize), dst_data_ptr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Image (*Image::_png_mem_loader_func)(const uint8_t *, int) = NULL;
|
|
Image (*Image::_jpg_mem_loader_func)(const uint8_t *, int) = NULL;
|
|
|
|
void (*Image::_image_compress_bc_func)(Image *) = NULL;
|
|
void (*Image::_image_compress_pvrtc2_func)(Image *) = NULL;
|
|
void (*Image::_image_compress_pvrtc4_func)(Image *) = NULL;
|
|
void (*Image::_image_compress_etc_func)(Image *) = NULL;
|
|
void (*Image::_image_decompress_pvrtc)(Image *) = NULL;
|
|
void (*Image::_image_decompress_bc)(Image *) = NULL;
|
|
void (*Image::_image_decompress_etc)(Image *) = NULL;
|
|
|
|
DVector<uint8_t> (*Image::lossy_packer)(const Image &, float) = NULL;
|
|
Image (*Image::lossy_unpacker)(const DVector<uint8_t> &) = NULL;
|
|
DVector<uint8_t> (*Image::lossless_packer)(const Image &) = NULL;
|
|
Image (*Image::lossless_unpacker)(const DVector<uint8_t> &) = NULL;
|
|
|
|
void Image::set_compress_bc_func(void (*p_compress_func)(Image *)) {
|
|
|
|
_image_compress_bc_func = p_compress_func;
|
|
}
|
|
|
|
void Image::normalmap_to_xy() {
|
|
|
|
convert(Image::FORMAT_RGBA);
|
|
|
|
{
|
|
int len = data.size() / 4;
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *data_ptr = wp.ptr();
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
|
|
data_ptr[(i << 2) + 3] = data_ptr[(i << 2) + 0]; //x to w
|
|
data_ptr[(i << 2) + 0] = data_ptr[(i << 2) + 1]; //y to xz
|
|
data_ptr[(i << 2) + 2] = data_ptr[(i << 2) + 1];
|
|
}
|
|
}
|
|
|
|
convert(Image::FORMAT_GRAYSCALE_ALPHA);
|
|
}
|
|
|
|
void Image::srgb_to_linear() {
|
|
|
|
if (data.size() == 0)
|
|
return;
|
|
|
|
static const uint8_t srgb2lin[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 22, 22, 23, 23, 24, 24, 25, 26, 26, 27, 27, 28, 29, 29, 30, 31, 31, 32, 33, 33, 34, 35, 36, 36, 37, 38, 38, 39, 40, 41, 42, 42, 43, 44, 45, 46, 47, 47, 48, 49, 50, 51, 52, 53, 54, 55, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 70, 71, 72, 73, 74, 75, 76, 77, 78, 80, 81, 82, 83, 84, 85, 87, 88, 89, 90, 92, 93, 94, 95, 97, 98, 99, 101, 102, 103, 105, 106, 107, 109, 110, 112, 113, 114, 116, 117, 119, 120, 122, 123, 125, 126, 128, 129, 131, 132, 134, 135, 137, 139, 140, 142, 144, 145, 147, 148, 150, 152, 153, 155, 157, 159, 160, 162, 164, 166, 167, 169, 171, 173, 175, 176, 178, 180, 182, 184, 186, 188, 190, 192, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 218, 220, 222, 224, 226, 228, 230, 232, 235, 237, 239, 241, 243, 245, 248, 250, 252 };
|
|
|
|
ERR_FAIL_COND(format != FORMAT_RGB && format != FORMAT_RGBA);
|
|
|
|
if (format == FORMAT_RGBA) {
|
|
|
|
int len = data.size() / 4;
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *data_ptr = wp.ptr();
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
|
|
data_ptr[(i << 2) + 0] = srgb2lin[data_ptr[(i << 2) + 0]];
|
|
data_ptr[(i << 2) + 1] = srgb2lin[data_ptr[(i << 2) + 1]];
|
|
data_ptr[(i << 2) + 2] = srgb2lin[data_ptr[(i << 2) + 2]];
|
|
}
|
|
|
|
} else if (format == FORMAT_RGB) {
|
|
|
|
int len = data.size() / 3;
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *data_ptr = wp.ptr();
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
|
|
data_ptr[(i * 3) + 0] = srgb2lin[data_ptr[(i * 3) + 0]];
|
|
data_ptr[(i * 3) + 1] = srgb2lin[data_ptr[(i * 3) + 1]];
|
|
data_ptr[(i * 3) + 2] = srgb2lin[data_ptr[(i * 3) + 2]];
|
|
}
|
|
}
|
|
}
|
|
|
|
void Image::premultiply_alpha() {
|
|
|
|
if (data.size() == 0)
|
|
return;
|
|
|
|
if (format != FORMAT_RGBA)
|
|
return; //not needed
|
|
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *data_ptr = wp.ptr();
|
|
|
|
for (int i = 0; i < height; i++) {
|
|
for (int j = 0; j < width; j++) {
|
|
|
|
BColor bc = _get_pixel(j, i, data_ptr, 0);
|
|
bc.r = (int(bc.r) * int(bc.a)) >> 8;
|
|
bc.g = (int(bc.g) * int(bc.a)) >> 8;
|
|
bc.b = (int(bc.b) * int(bc.a)) >> 8;
|
|
_put_pixel(j, i, bc, data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Image::fix_alpha_edges() {
|
|
|
|
if (data.size() == 0)
|
|
return;
|
|
|
|
if (format != FORMAT_RGBA)
|
|
return; //not needed
|
|
|
|
DVector<uint8_t> dcopy = data;
|
|
DVector<uint8_t>::Read rp = data.read();
|
|
const uint8_t *rptr = rp.ptr();
|
|
|
|
DVector<uint8_t>::Write wp = data.write();
|
|
unsigned char *data_ptr = wp.ptr();
|
|
|
|
const int max_radius = 4;
|
|
const int alpha_treshold = 20;
|
|
const int max_dist = 0x7FFFFFFF;
|
|
|
|
for (int i = 0; i < height; i++) {
|
|
for (int j = 0; j < width; j++) {
|
|
|
|
BColor bc = _get_pixel(j, i, rptr, 0);
|
|
if (bc.a >= alpha_treshold)
|
|
continue;
|
|
|
|
int closest_dist = max_dist;
|
|
BColor closest_color;
|
|
closest_color.a = bc.a;
|
|
int from_x = MAX(0, j - max_radius);
|
|
int to_x = MIN(width - 1, j + max_radius);
|
|
int from_y = MAX(0, i - max_radius);
|
|
int to_y = MIN(height - 1, i + max_radius);
|
|
|
|
for (int k = from_y; k <= to_y; k++) {
|
|
for (int l = from_x; l <= to_x; l++) {
|
|
|
|
int dy = i - k;
|
|
int dx = j - l;
|
|
int dist = dy * dy + dx * dx;
|
|
if (dist >= closest_dist)
|
|
continue;
|
|
|
|
const uint8_t *rp = &rptr[(k * width + l) << 2];
|
|
|
|
if (rp[3] < alpha_treshold)
|
|
continue;
|
|
|
|
closest_dist = dist;
|
|
closest_color.r = rp[0];
|
|
closest_color.g = rp[1];
|
|
closest_color.b = rp[2];
|
|
}
|
|
}
|
|
|
|
if (closest_dist != max_dist)
|
|
_put_pixel(j, i, closest_color, data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
String Image::get_format_name(Format p_format) {
|
|
|
|
ERR_FAIL_INDEX_V(p_format, FORMAT_MAX, String());
|
|
return format_names[p_format];
|
|
}
|
|
|
|
Image::Image(const uint8_t *p_mem_png_jpg, int p_len) {
|
|
|
|
width = 0;
|
|
height = 0;
|
|
mipmaps = 0;
|
|
format = FORMAT_GRAYSCALE;
|
|
|
|
if (_png_mem_loader_func) {
|
|
*this = _png_mem_loader_func(p_mem_png_jpg, p_len);
|
|
}
|
|
|
|
if (empty() && _jpg_mem_loader_func) {
|
|
*this = _jpg_mem_loader_func(p_mem_png_jpg, p_len);
|
|
}
|
|
}
|
|
|
|
Image::Image() {
|
|
|
|
width = 0;
|
|
height = 0;
|
|
mipmaps = 0;
|
|
format = FORMAT_GRAYSCALE;
|
|
}
|
|
|
|
Image::~Image() {
|
|
}
|