maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
godot/core/image.cpp
Rémi Verschelde b97401f304 Update copyright statements to 2020 
And apply clang-format 10 to the codebase.
2020-08-13 22:58:13 +02:00

2608 lines
63 KiB
C++
Raw Blame History

/*************************************************************************/
/* image.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* 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 "print_string.h"
#include "thirdparty/misc/hq2x.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 = next_power_of_2(width);
int h = next_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 (next_power_of_2(width) == uint32_t(width) && next_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) const {
if (save_png_func == NULL)
return ERR_UNAVAILABLE;
Image image = *this;
return save_png_func(p_path, image);
};
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));
int mm_w = wd;
int mm_h = ht;
for (int i = 0; i <= mm; i++) {
switch (format) {
case FORMAT_BC1: {
int len = (mm_w * mm_h) / 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 * mm_w) * 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] = {
{ (uint8_t)((col_a >> 11) << 3), (uint8_t)(((col_a >> 5) & 0x3f) << 2), (uint8_t)(((col_a)&0x1f) << 3), 255 },
{ (uint8_t)((col_b >> 11) << 3), (uint8_t)(((col_b >> 5) & 0x3f) << 2), (uint8_t)(((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 / (mm_w / 4)) * 4;
int x = (j % (mm_w / 4)) * 4;
int pixofs = (y * mm_w + 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 += mm_w * mm_h * 4;
mm_w /= 2;
mm_h /= 2;
} break;
case FORMAT_BC2: {
int len = (mm_w * mm_h) / 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 * mm_w) * 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] = {
{ (uint8_t)((col_a >> 11) << 3), (uint8_t)(((col_a >> 5) & 0x3f) << 2), (uint8_t)(((col_a)&0x1f) << 3), 255 },
{ (uint8_t)((col_b >> 11) << 3), (uint8_t)(((col_b >> 5) & 0x3f) << 2), (uint8_t)(((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 / (mm_w / 4)) * 4;
int x = (j % (mm_w / 4)) * 4;
int pixofs = (y * mm_w + 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 += mm_w * mm_h * 4;
mm_w /= 2;
mm_h /= 2;
} break;
case FORMAT_BC3: {
int len = (mm_w * mm_h) / 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 * mm_w) * 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] = {
{ (uint8_t)((col_a >> 11) << 3), (uint8_t)(((col_a >> 5) & 0x3f) << 2), (uint8_t)(((col_a)&0x1f) << 3), 255 },
{ (uint8_t)((col_b >> 11) << 3), (uint8_t)(((col_b >> 5) & 0x3f) << 2), (uint8_t)(((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 / (mm_w / 4)) * 4;
int x = (j % (mm_w / 4)) * 4;
int pixofs = (y * mm_w + 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 += mm_w * mm_h * 4;
mm_w /= 2;
mm_h /= 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::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;
}
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 && _image_decompress_bc)
_image_decompress_bc(this); // libsquish
else if (format >= FORMAT_BC1 && format <= FORMAT_BC3)
_decompress_bc(); // builtin
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 + desti.y < 0 || i + desti.y >= height)
continue;
for (int j = 0; j < rrect.size.x; j++) {
if (j + desti.x < 0 || j + desti.x >= 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 + p_dest.y < 0 || i + p_dest.y >= height)
continue;
for (int j = 0; j < rrect.size.x; j++) {
if (j + p_dest.x < 0 || j + p_dest.x >= 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);
}
}
}
}
void Image::blit_rect_mask(const Image &p_src, const Image &p_mask, const Rect2 &p_src_rect, const Point2 &p_dest) {
int dsize = data.size();
int srcdsize = p_src.data.size();
int maskdsize = p_mask.data.size();
ERR_FAIL_COND(dsize == 0);
ERR_FAIL_COND(srcdsize == 0);
ERR_FAIL_COND(maskdsize == 0);
ERR_FAIL_COND(p_src.width != p_mask.width);
ERR_FAIL_COND(p_src.height != p_mask.height);
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();
DVector<uint8_t>::Read mp = p_mask.data.read();
const unsigned char *mask_data_ptr = mp.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 + desti.y < 0 || i + desti.y >= height)
continue;
for (int j = 0; j < rrect.size.x; j++) {
if (j + desti.x < 0 || j + desti.x >= width)
continue;
BColor msk = p_mask._get_pixel(rrect.pos.x + j, rrect.pos.y + i, mask_data_ptr, maskdsize);
if (msk.a != 0) {
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 + p_dest.y < 0 || i + p_dest.y >= height)
continue;
for (int j = 0; j < rrect.size.x; j++) {
if (j + p_dest.x < 0 || j + p_dest.x >= width)
continue;
BColor msk = p_mask._get_pixel(rrect.pos.x + j, rrect.pos.y + i, mask_data_ptr, maskdsize);
if (msk.a != 0) {
_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);
}
}
}
}
}
void Image::blend_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 &p_dest) {
int dsize = data.size();
int srcdsize = p_src.data.size();
int dst_data_size = data.size();
ERR_FAIL_COND(dsize == 0);
ERR_FAIL_COND(srcdsize == 0);
ERR_FAIL_COND(dst_data_size == 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) {
return;
} else {
for (int i = 0; i < rrect.size.y; i++) {
if (i + p_dest.y < 0 || i + p_dest.y >= height)
continue;
for (int j = 0; j < rrect.size.x; j++) {
if (j + p_dest.x < 0 || j + p_dest.x >= width)
continue;
BColor src = p_src._get_pixel(rrect.pos.x + j, rrect.pos.y + i, src_data_ptr, srcdsize);
BColor dst = _get_pixel(p_dest.x + j, p_dest.y + i, dst_data_ptr, dst_data_size);
float ba = (float)dst.a / 255.0;
float fa = (float)src.a / 255.0;
dst.r = (uint8_t)(fa * src.r + ba * (1.0 - fa) * dst.r);
dst.g = (uint8_t)(fa * src.g + ba * (1.0 - fa) * dst.g);
dst.b = (uint8_t)(fa * src.b + ba * (1.0 - fa) * dst.b);
dst.a = (uint8_t)(255.0 * (fa + ba * (1.0 - fa)));
_put_pixel(p_dest.x + j, p_dest.y + i, dst, dst_data_ptr);
}
}
}
}
void Image::blend_rect_mask(const Image &p_src, const Image &p_mask, const Rect2 &p_src_rect, const Point2 &p_dest) {
int dsize = data.size();
int srcdsize = p_src.data.size();
int maskdsize = p_mask.data.size();
int dst_data_size = data.size();
ERR_FAIL_COND(dsize == 0);
ERR_FAIL_COND(srcdsize == 0);
ERR_FAIL_COND(maskdsize == 0);
ERR_FAIL_COND(dst_data_size == 0);
ERR_FAIL_COND(p_src.width != p_mask.width);
ERR_FAIL_COND(p_src.height != p_mask.height);
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();
DVector<uint8_t>::Read mrp = p_mask.data.read();
const unsigned char *mask_data_ptr = mrp.ptr();
if (format == FORMAT_INDEXED || format == FORMAT_INDEXED_ALPHA || p_src.format == FORMAT_INDEXED || p_src.format == FORMAT_INDEXED_ALPHA) {
return;
} else {
for (int i = 0; i < rrect.size.y; i++) {
if (i + p_dest.y < 0 || i + p_dest.y >= height)
continue;
for (int j = 0; j < rrect.size.x; j++) {
if (j + p_dest.x < 0 || j + p_dest.x >= width)
continue;
BColor msk = p_mask._get_pixel(rrect.pos.x + j, rrect.pos.y + i, mask_data_ptr, maskdsize);
if (msk.a != 0) {
BColor src = p_src._get_pixel(rrect.pos.x + j, rrect.pos.y + i, src_data_ptr, srcdsize);
BColor dst = _get_pixel(p_dest.x + j, p_dest.y + i, dst_data_ptr, dst_data_size);
float ba = (float)dst.a / 255.0;
float fa = (float)src.a / 255.0;
dst.r = (uint8_t)(fa * src.r + ba * (1.0 - fa) * dst.r);
dst.g = (uint8_t)(fa * src.g + ba * (1.0 - fa) * dst.g);
dst.b = (uint8_t)(fa * src.b + ba * (1.0 - fa) * dst.b);
dst.a = (uint8_t)(255.0 * (fa + ba * (1.0 - fa)));
_put_pixel(p_dest.x + j, p_dest.y + i, dst, dst_data_ptr);
}
}
}
}
}
void Image::fill(const Color &p_color) {
int dsize = data.size();
ERR_FAIL_COND(dsize == 0);
DVector<uint8_t>::Write wp = data.write();
unsigned char *dst_data_ptr = wp.ptr();
BColor c = BColor(p_color.r * 255, p_color.g * 255, p_color.b * 255, p_color.a * 255);
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
_put_pixel(j, i, c, 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() {
}
Reference in a new issue View git blame Copy permalink