From f8db8a3faa30b71dca33ced38be16d3f93f43e8a Mon Sep 17 00:00:00 2001 From: Rémi Verschelde Date: Sun, 19 Mar 2017 00:36:26 +0100 Subject: Bring that Whole New World to the Old Continent too Applies the clang-format style to the 2.1 branch as done for master in 5dbf1809c6e3e905b94b8764e99491e608122261. --- core/image.cpp | 2090 ++++++++++++++++++++++++++------------------------------ 1 file changed, 979 insertions(+), 1111 deletions(-) (limited to 'core/image.cpp') diff --git a/core/image.cpp b/core/image.cpp index ae3bd46fe..8afbb278f 100644 --- a/core/image.cpp +++ b/core/image.cpp @@ -27,15 +27,14 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "image.h" -#include "hash_map.h" #include "core/io/image_loader.h" #include "core/os/copymem.h" +#include "hash_map.h" #include "hq2x.h" #include "print_string.h" #include - -const char* Image::format_names[Image::FORMAT_MAX]={ +const char *Image::format_names[Image::FORMAT_MAX] = { "Grayscale", "Intensity", "GrayscaleAlpha", @@ -63,45 +62,43 @@ const char* Image::format_names[Image::FORMAT_MAX]={ 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_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) { - +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; + int ofs = p_y * p_width + p_x; - switch(format) { + switch (format) { case FORMAT_GRAYSCALE: { - p_data[ofs]=p_color.gray(); + p_data[ofs] = p_color.gray(); } break; case FORMAT_INTENSITY: { - p_data[ofs]=p_color.a; + 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; + 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; + 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; + 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: @@ -110,143 +107,134 @@ void Image::_put_pixelw(int p_x,int p_y, int p_width, const BColor& p_color, uns ERR_FAIL(); } break; default: {}; - } - } +void Image::_get_mipmap_offset_and_size(int p_mipmap, int &r_offset, int &r_width, int &r_height) const { - -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 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>=pixel_rshift; - ofs+=s; - w=MAX(minw,w>>1); - h=MAX(minh,h>>1); + 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; + 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); + ERR_FAIL_INDEX_V(p_mipmap, (mipmaps + 1), -1); - int ofs,w,h; - _get_mipmap_offset_and_size(p_mipmap,ofs,w,h); + 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 { +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 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; - + _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 { - +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; - + _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){ +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); + 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::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]); + 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 { -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); + 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{ +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) { + 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); + 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]); + 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]); + 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]); + 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]); + 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 ]; + 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] ); + 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 ]; + 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); + 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); + 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]; + const uint8_t *yp = &p_data[p_width * 2 * p_y + p_x * 2]; y = yp[0]; u = yp[1]; v = yp[3]; @@ -260,7 +248,7 @@ Image::BColor Image::_get_pixelw(int p_x,int p_y,int p_width,const unsigned char case FORMAT_YUV_444: { uint8_t y, u, v; - const uint8_t* yp = &p_data[p_width * 3 * p_y + p_x * 3]; + const uint8_t *yp = &p_data[p_width * 3 * p_y + p_x * 3]; y = yp[0]; u = yp[1]; v = yp[2]; @@ -270,60 +258,56 @@ Image::BColor Image::_get_pixelw(int p_x,int p_y,int p_width,const unsigned char 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:{} - + default: {} } return result; - } -void Image::put_indexed_pixel(int p_x, int p_y, uint8_t p_idx,int p_mipmap) { +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); + 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 { +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); - + 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& p_data) { - +void Image::set_pallete(const DVector &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)); + 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 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::Write wp = data.write(); - unsigned char *dst=wp.ptr() + pal_ofs; + unsigned char *dst = wp.ptr() + pal_ofs; DVector::Read r = p_data.read(); - const unsigned char *src=r.ptr(); + const unsigned char *src = r.ptr(); copymem(dst, src, len); }; @@ -332,58 +316,53 @@ int Image::get_width() const { return width; } -int Image::get_height() const{ +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()); +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::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 ); + 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 ){ +void Image::convert(Format p_new_format) { - if (data.size()==0) + if (data.size() == 0) return; - if (p_new_format==format) + if (p_new_format == format) return; - if (format>=FORMAT_BC1 || p_new_format>=FORMAT_BC1) { + 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) { - + if (p_new_format == FORMAT_INDEXED || p_new_format == FORMAT_INDEXED_ALPHA) { return; } + Image new_img(width, height, 0, p_new_format); - Image new_img(width,height,0,p_new_format); - - int len=data.size(); + int len = data.size(); DVector::Read r = data.read(); DVector::Write w = new_img.data.write(); @@ -391,158 +370,148 @@ void Image::convert( Format p_new_format ){ const uint8_t *rptr = r.ptr(); uint8_t *wptr = w.ptr(); - if (p_new_format==FORMAT_RGBA && format==FORMAT_INDEXED_ALPHA) { + 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]; + 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::Read(); w = DVector::Write(); - bool gen_mipmaps=mipmaps>0; + bool gen_mipmaps = mipmaps > 0; - *this=new_img; + *this = new_img; if (gen_mipmaps) generate_mipmaps(); - - } -Image::Format Image::get_format() const{ +Image::Format Image::get_format() const { return format; } -static double _bicubic_interp_kernel( double x ) { +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; - + 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 -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) { - +template +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; + 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; + 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++ ) { + for (int y = 0; y < p_dst_height; y++) { // Y coordinates - oy = (double) y * yfac - 0.5f; - oy1 = (int) oy; - dy = oy - (double) oy1; + oy = (double)y * yfac - 0.5f; + oy1 = (int)oy; + dy = oy - (double)oy1; - for ( int x = 0; x < p_dst_width; x++ ) { + for (int x = 0; x < p_dst_width; x++) { // X coordinates - ox = (double) x * xfac - 0.5f; - ox1 = (int) ox; - dx = ox - (double) ox1; + 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; + uint8_t *dst = p_dst + (y * p_dst_width + x) * CC; double color[CC]; - for(int i=0;i ymax ) + if (oy2 > ymax) oy2 = ymax; - for ( int m = -1; m < 3; m++ ) { + for (int m = -1; m < 3; m++) { // get X cooefficient - k2 = k1 * _bicubic_interp_kernel( (double) m - dx ); + k2 = k1 * _bicubic_interp_kernel((double)m - dx); ox2 = ox1 + m; - if ( ox2 < 0 ) + if (ox2 < 0) ox2 = 0; - if ( ox2 > xmax ) + if (ox2 > xmax) ox2 = xmax; // get pixel of original image - const uint8_t *p = p_src + (oy2 * p_src_width + ox2)*CC; + const uint8_t *p = p_src + (oy2 * p_src_width + ox2) * CC; - for(int i=0;i -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) { +template +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; - - 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; + 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; @@ -550,60 +519,57 @@ static void _scale_bilinear(const uint8_t* p_src, uint8_t* p_dst, uint32_t p_src 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> 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; + 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; + src_xofs_left *= CC; + src_xofs_right *= CC; - for(uint32_t l=0;l>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; + 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 +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) { -template -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++) { - - for(uint32_t i=0;iMAX_WIDTH); - ERR_FAIL_COND(p_height>MAX_HEIGHT); - + 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) + if (p_width == width && p_height == height) return; - Image dst( p_width, p_height, 0, format ); - - if (format==FORMAT_INDEXED) - p_interpolation=INTERPOLATE_NEAREST; + Image dst(p_width, p_height, 0, format); + if (format == FORMAT_INDEXED) + p_interpolation = INTERPOLATE_NEAREST; DVector::Read r = data.read(); - const unsigned char*r_ptr=r.ptr(); + const unsigned char *r_ptr = r.ptr(); DVector::Write w = dst.data.write(); - unsigned char*w_ptr=w.ptr(); + unsigned char *w_ptr = w.ptr(); - - switch(p_interpolation) { + 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; + 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; + 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; + 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::Read(); w = DVector::Write(); - if (mipmaps>0) + if (mipmaps > 0) dst.generate_mipmaps(); - *this=dst; + *this = dst; } -void Image::crop( int p_width, int p_height ) { +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); + 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) + if (p_width == width && p_height == height) return; - Image dst( p_width, p_height,0, format ); + Image dst(p_width, p_height, 0, format); + for (int y = 0; y < p_height; y++) { - for (int y=0;y=width || y>=height)? Color() : get_pixel(x,y); - dst.put_pixel(x,y,col); + Color col = (x >= width || y >= height) ? Color() : get_pixel(x, y); + dst.put_pixel(x, y, col); } } - if (mipmaps>0) + if (mipmaps > 0) dst.generate_mipmaps(); - *this=dst; - + *this = dst; } void Image::flip_y() { @@ -747,28 +705,24 @@ void Image::flip_y() { ERR_FAIL(); } - bool gm=mipmaps; + 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); - for (int y=0;y<(height/2);y++) { - - for (int x=0;x>=pixshift; + int s = w * h; + s *= pixsize; + s >>= pixshift; - size+=s; + size += s; - if (p_mipmaps>=0 && mm==p_mipmaps) + if (p_mipmaps >= 0 && mm == p_mipmaps) break; - if (p_mipmaps>=0) { + if (p_mipmaps >= 0) { - w=MAX(minw,w>>1); - h=MAX(minh,h>>1); + w = MAX(minw, w >> 1); + h = MAX(minh, h >> 1); } else { - if (w==minw && h==minh) + if (w == minw && h == minh) break; - w=MAX(minw,w>>1); - h=MAX(minh,h>>1); + w = MAX(minw, w >> 1); + h = MAX(minh, h >> 1); } mm++; }; - r_mipmaps=mm; + r_mipmaps = mm; return size; } bool Image::_can_modify(Format p_format) const { - switch(p_format) { + switch (p_format) { //these are OK case FORMAT_GRAYSCALE: @@ -865,86 +823,78 @@ bool Image::_can_modify(Format p_format) const { return false; } -template -static void _generate_po2_mipmap(const uint8_t* p_src, uint8_t* p_dst, uint32_t p_width, uint32_t p_height) { +template +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>2; + 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; + dst_ptr += CC; + rup_ptr += CC * 2; + rdown_ptr += CC * 2; } } } - void Image::expand_x2_hq2x() { - ERR_FAIL_COND(format>=FORMAT_INDEXED); + ERR_FAIL_COND(format >= FORMAT_INDEXED); Format current = format; - bool mipmaps=get_mipmaps(); + bool mipmaps = get_mipmaps(); if (mipmaps) { clear_mipmaps(); } - if (current!=FORMAT_RGBA) + if (current != FORMAT_RGBA) convert(FORMAT_RGBA); DVector dest; - dest.resize(width*2*height*2*4); + dest.resize(width * 2 * height * 2 * 4); { DVector::Read r = data.read(); DVector::Write w = dest.write(); - hq2x_resize((const uint32_t*)r.ptr(),width,height,(uint32_t*)w.ptr()); - + hq2x_resize((const uint32_t *)r.ptr(), width, height, (uint32_t *)w.ptr()); } - width*=2; - height*=2; - data=dest; - + width *= 2; + height *= 2; + data = dest; - if (current!=FORMAT_RGBA) + 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 ); - - + ERR_FAIL_COND(format == FORMAT_INDEXED || format == FORMAT_INDEXED_ALPHA); + ERR_FAIL_COND(data.size() == 0); if (mipmaps) { @@ -953,181 +903,169 @@ void Image::shrink_x2() { int ofs = get_mipmap_offset(1); - int new_size = data.size()-ofs; + int new_size = data.size() - ofs; new_img.resize(new_size); - { - DVector::Write w=new_img.write(); - DVector::Read r=data.read(); + DVector::Write w = new_img.write(); + DVector::Read r = data.read(); - copymem(w.ptr(),&r[ofs],new_size); + copymem(w.ptr(), &r[ofs], new_size); } mipmaps--; - width/=2; - height/=2; - data=new_img; + width /= 2; + height /= 2; + data = new_img; } else { DVector new_img; - ERR_FAIL_COND( format>=FORMAT_INDEXED ); + ERR_FAIL_COND(format >= FORMAT_INDEXED); int ps = get_format_pixel_size(format); - new_img.resize((width/2)*(height/2)*ps); + new_img.resize((width / 2) * (height / 2) * ps); { - DVector::Write w=new_img.write(); - DVector::Read r=data.read(); + DVector::Write w = new_img.write(); + DVector::Read r = data.read(); - switch(format) { + 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; + 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; - + width /= 2; + height /= 2; + data = new_img; } } -Error Image::generate_mipmaps(int p_mipmaps,bool p_keep_existing) { +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; + int from_mm = 1; if (p_keep_existing) { - from_mm=mipmaps+1; + from_mm = mipmaps + 1; } - int size = _get_dst_image_size(width,height,format,mipmaps,p_mipmaps); + int size = _get_dst_image_size(width, height, format, mipmaps, p_mipmaps); data.resize(size); - DVector::Write wp=data.write(); + DVector::Write wp = data.write(); - if (nearest_power_of_2(width)==uint32_t(width) && nearest_power_of_2(height)==uint32_t(height)) { + 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=from_mm) { + if (i >= from_mm) { - switch(format) { + 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; + 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; + 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; + int prev_ofs = 0; + int prev_h = height; + int prev_w = width; - for(int i=1;i= from_mm) { - if (i>=from_mm) { - - switch(format) { + 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; + 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; + prev_ofs = ofs; + prev_w = w; + prev_h = h; } - } - - - return OK; } void Image::clear_mipmaps() { - if (mipmaps==0) + if (mipmaps == 0) return; - if (format==FORMAT_CUSTOM) { + 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 ofs, w, h; + _get_mipmap_offset_and_size(1, ofs, w, h); int palsize = get_format_pallete_size(format); DVector pallete; - ERR_FAIL_COND(ofs+palsize > data.size()); //bug? + ERR_FAIL_COND(ofs + palsize > data.size()); //bug? if (palsize) { pallete.resize(palsize); DVector::Read r = data.read(); DVector::Write w = pallete.write(); - copymem(&w[0],&r[data.size()-palsize],palsize); + copymem(&w[0], &r[data.size() - palsize], palsize); } - data.resize(ofs+palsize); + data.resize(ofs + palsize); if (palsize) { DVector::Read r = pallete.read(); DVector::Write w = data.write(); - copymem(&w[ofs],&r[0],palsize); + copymem(&w[ofs], &r[0], palsize); } - mipmaps=0; - + mipmaps = 0; } void Image::make_normalmap(float p_height_scale) { @@ -1137,9 +1075,9 @@ void Image::make_normalmap(float p_height_scale) { ERR_FAIL(); } - ERR_FAIL_COND( empty() ); + ERR_FAIL_COND(empty()); - Image normalmap(width,height,0, FORMAT_RGB); + Image normalmap(width, height, 0, FORMAT_RGB); /* for (int y=0;y Image::get_data() const { @@ -1173,55 +1111,50 @@ DVector Image::get_data() const { return data; } -void Image::create(int p_width, int p_height, bool p_use_mipmaps,Format p_format) { - +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 ); + 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::Write w= data.write(); - zeromem(w.ptr(),size); + DVector::Write w = data.write(); + zeromem(w.ptr(), size); } - width=p_width; - height=p_height; - mipmaps=mm; - format=p_format; - - + 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& p_data) { +void Image::create(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector &p_data) { - ERR_FAIL_INDEX(p_width-1,MAX_WIDTH); - ERR_FAIL_INDEX(p_height-1,MAX_HEIGHT); + 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); + 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); + 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; + height = p_height; + width = p_width; + format = p_format; + data = p_data; + mipmaps = p_mipmaps; } +void Image::create(const char **p_xpm) { -void Image::create( const char ** p_xpm ) { - - - int size_width,size_height; - int pixelchars=0; - mipmaps=0; - bool has_alpha=false; + int size_width, size_height; + int pixelchars = 0; + mipmaps = 0; + bool has_alpha = false; enum Status { READING_HEADER, @@ -1231,124 +1164,120 @@ void Image::create( const char ** p_xpm ) { }; Status status = READING_HEADER; - int line=0; + int line = 0; - HashMap colormap; + HashMap colormap; int colormap_size; - while (status!=DONE) { - - const char * line_ptr = p_xpm[line]; + while (status != DONE) { + const char *line_ptr = p_xpm[line]; switch (status) { - case READING_HEADER: { + case READING_HEADER: { - String line_str=line_ptr; - line_str.replace("\t"," "); + 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: { + 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='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 + while (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == 0) { + if (*line_ptr == 0) 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; - }; - + line_ptr++; } - // 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_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: { + if (line == colormap_size) { - int y=line-colormap_size-1; - for (int x=0;x0) {\ - \ - detected=true;\ - break;\ - }\ -} +#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) + if (format == FORMAT_GRAYSCALE || + format == FORMAT_RGB || + format == FORMAT_INDEXED) return false; int len = data.size(); - if (len==0) + 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); + int w, h; + _get_mipmap_offset_and_size(1, len, w, h); DVector::Read r = data.read(); - const unsigned char *data_ptr=r.ptr(); + const unsigned char *data_ptr = r.ptr(); - bool detected=false; + bool detected = false; - switch(format) { + switch (format) { case FORMAT_INTENSITY: { - for(int i=0;i>1);i++) { - DETECT_NON_ALPHA(data_ptr[(i<<1)+1]); + 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]) + for (int i = 0; i < (len >> 2); i++) { + DETECT_NON_ALPHA(data_ptr[(i << 2) + 3]) } } break; @@ -1437,7 +1364,7 @@ bool Image::is_invisible() const { case FORMAT_PVRTC4_ALPHA: case FORMAT_BC2: case FORMAT_BC3: { - detected=true; + detected = true; } break; default: {} } @@ -1447,47 +1374,46 @@ bool Image::is_invisible() const { Image::AlphaMode Image::detect_alpha() const { - if (format==FORMAT_GRAYSCALE || - format==FORMAT_RGB || - format==FORMAT_INDEXED) + if (format == FORMAT_GRAYSCALE || + format == FORMAT_RGB || + format == FORMAT_INDEXED) return ALPHA_NONE; int len = data.size(); - if (len==0) + 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); + int w, h; + _get_mipmap_offset_and_size(1, len, w, h); DVector::Read r = data.read(); - const unsigned char *data_ptr=r.ptr(); + const unsigned char *data_ptr = r.ptr(); - bool bit=false; - bool detected=false; + bool bit = false; + bool detected = false; - switch(format) { + switch (format) { case FORMAT_INTENSITY: { - for(int i=0;i>1);i++) { - DETECT_ALPHA(data_ptr[(i<<1)+1]); + 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]) + for (int i = 0; i < (len >> 2); i++) { + DETECT_ALPHA(data_ptr[(i << 2) + 3]) } } break; @@ -1503,7 +1429,7 @@ Image::AlphaMode Image::detect_alpha() const { case FORMAT_PVRTC4_ALPHA: case FORMAT_BC2: case FORMAT_BC3: { - detected=true; + detected = true; } break; default: {} } @@ -1514,15 +1440,14 @@ Image::AlphaMode Image::detect_alpha() const { return ALPHA_BIT; else return ALPHA_NONE; - } -Error Image::load(const String& p_path) { +Error Image::load(const String &p_path) { return ImageLoader::load_image(p_path, this); } -Error Image::save_png(const String& p_path) { +Error Image::save_png(const String &p_path) { if (save_png_func == NULL) return ERR_UNAVAILABLE; @@ -1530,7 +1455,7 @@ Error Image::save_png(const String& p_path) { return save_png_func(p_path, *this); }; -bool Image::operator==(const Image& p_image) const { +bool Image::operator==(const Image &p_image) const { if (data.size() == 0 && p_image.data.size() == 0) return true; @@ -1540,10 +1465,9 @@ bool Image::operator==(const Image& p_image) const { return r.ptr() == pr.ptr(); } - int Image::get_format_pixel_size(Format p_format) { - switch(p_format) { + switch (p_format) { case FORMAT_GRAYSCALE: { return 1; @@ -1611,82 +1535,76 @@ int Image::get_format_pixel_size(Format p_format) { ERR_EXPLAIN("pixel size requested for custom image format, and it's unknown obviously"); ERR_FAIL_V(1); } break; - default:{ + 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 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); - + 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); + _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) { - +void Image::_get_format_min_data_size(Format p_format, int &r_w, int &r_h) { - switch(p_format) { + switch (p_format) { case FORMAT_BC1: case FORMAT_BC2: case FORMAT_BC3: case FORMAT_BC4: case FORMAT_BC5: { - r_w=4; - r_h=4; + r_w = 4; + r_h = 4; } break; case FORMAT_PVRTC2: case FORMAT_PVRTC2_ALPHA: { - r_w=16; - r_h=8; + r_w = 16; + r_h = 8; } break; case FORMAT_PVRTC4_ALPHA: case FORMAT_PVRTC4: { - r_w=8; - r_h=8; + 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; + r_w = 8; + r_h = 8; } break; case FORMAT_ETC: { - r_w=4; - r_h=4; + r_w = 4; + r_h = 4; } break; default: { - r_w=1; - r_h=1; + 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) + 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) + else if (p_format == FORMAT_PVRTC2 || p_format == FORMAT_PVRTC2_ALPHA) return 2; else return 0; @@ -1694,7 +1612,7 @@ int Image::get_format_pixel_rshift(Format p_format) { int Image::get_format_pallete_size(Format p_format) { - switch(p_format) { + switch (p_format) { case FORMAT_GRAYSCALE: { return 0; @@ -1717,35 +1635,31 @@ int Image::get_format_pallete_size(Format p_format) { } break; case FORMAT_INDEXED: { - return 3*256; + return 3 * 256; } break; case FORMAT_INDEXED_ALPHA: { - return 4*256; + return 4 * 256; } break; - default:{} + default: {} } return 0; } - - - Error Image::_decompress_bc() { print_line("decompressing bc"); - int wd=width,ht=height; - if (wd%4!=0) { - wd+=4-(wd%4); + int wd = width, ht = height; + if (wd % 4 != 0) { + wd += 4 - (wd % 4); } - if (ht%4!=0) { - ht+=4-(ht%4); + if (ht % 4 != 0) { + ht += 4 - (ht % 4); } - int mm; - int size = _get_dst_image_size(wd,ht,FORMAT_RGBA,mm,mipmaps); + int size = _get_dst_image_size(wd, ht, FORMAT_RGBA, mm, mipmaps); DVector newdata; newdata.resize(size); @@ -1753,352 +1667,333 @@ Error Image::_decompress_bc() { DVector::Write w = newdata.write(); DVector::Read r = data.read(); - int rofs=0; - int wofs=0; + int rofs = 0; + int wofs = 0; //print_line("width: "+itos(wd)+" height: "+itos(ht)); - for(int i=0;i<=mm;i++) { + for (int i = 0; i <= mm; i++) { - switch(format) { + switch (format) { case FORMAT_BC1: { - int len = (wd*ht)/16; - uint8_t* dst=&w[wofs]; + int len = (wd * ht) / 16; + uint8_t *dst = &w[wofs]; uint32_t ofs_table[16]; - for(int x=0;x<4;x++) { + for (int x = 0; x < 4; x++) { - for(int y=0;y<4;y++) { + for (int y = 0; y < 4; y++) { - ofs_table[15-(y*4+(3-x))]=(x+y*wd)*4; + ofs_table[15 - (y * 4 + (3 - x))] = (x + y * wd) * 4; } } - - for(int j=0;j>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} + 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>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 + 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; + 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; + 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; - + rofs += len * 8; + wofs += wd * ht * 4; - wd/=2; - ht/=2; + wd /= 2; + ht /= 2; } break; case FORMAT_BC2: { - int len = (wd*ht)/16; - uint8_t* dst=&w[wofs]; + int len = (wd * ht) / 16; + uint8_t *dst = &w[wofs]; uint32_t ofs_table[16]; - for(int x=0;x<4;x++) { + for (int x = 0; x < 4; x++) { - for(int y=0;y<4;y++) { + for (int y = 0; y < 4; y++) { - ofs_table[15-(y*4+(3-x))]=(x+y*wd)*4; + ofs_table[15 - (y * 4 + (3 - x))] = (x + y * wd) * 4; } } - - for(int j=0;j>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} + 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; + 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; + rofs += len * 16; + wofs += wd * ht * 4; - - wd/=2; - ht/=2; + wd /= 2; + ht /= 2; } break; case FORMAT_BC3: { - int len = (wd*ht)/16; - uint8_t* dst=&w[wofs]; + int len = (wd * ht) / 16; + uint8_t *dst = &w[wofs]; uint32_t ofs_table[16]; - for(int x=0;x<4;x++) { + for (int x = 0; x < 4; x++) { - for(int y=0;y<4;y++) { + for (int y = 0; y < 4; y++) { - ofs_table[15-(y*4+(3-x))]=(x+y*wd)*4; + 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]; - for(int j=0;ja_end) { + 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; + 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; - + 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} + 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; + 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; - + rofs += len * 16; + wofs += wd * ht * 4; - wd/=2; - ht/=2; + wd /= 2; + ht /= 2; } break; } - } - w=DVector::Write(); - r=DVector::Read(); + w = DVector::Write(); + r = DVector::Read(); - data=newdata; - format=FORMAT_RGBA; - if (wd!=width || ht!=height) { + data = newdata; + format = FORMAT_RGBA; + if (wd != width || ht != height) { //todo, crop - width=wd; - height=ht; + width = wd; + height = ht; } return OK; } bool Image::is_compressed() const { - return format>=FORMAT_BC1; + return format >= FORMAT_BC1; } - Image Image::decompressed() const { - Image img=*this; + 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) + 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) + 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) { + switch (p_mode) { case COMPRESS_BC: { @@ -2122,7 +2017,6 @@ Error Image::compress(CompressMode p_mode) { } break; } - return OK; } @@ -2136,89 +2030,83 @@ Image Image::compressed(int p_mode) { Image::Image(const char **p_xpm) { - width=0; - height=0; - mipmaps=0; - format=FORMAT_GRAYSCALE; + 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) { -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); + 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& p_data) { - - width=0; - height=0; - mipmaps=0; - format=FORMAT_GRAYSCALE; +Image::Image(int p_width, int p_height, int p_mipmaps, Format p_format, const DVector &p_data) { - create(p_width,p_height,p_mipmaps,p_format,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 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); + 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)); + 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) + if (len == 0) return Rect2(); int data_size = len; DVector::Read r = data.read(); - const unsigned char *rptr=r.ptr(); + const unsigned char *rptr = r.ptr(); - int minx=0xFFFFFF,miny=0xFFFFFFF; - int maxx=-1,maxy=-1; - for(int i=0;i2; + 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 maxx) + maxx = i; + if (j > maxy) + maxy = j; + if (i < minx) + minx = i; + if (j < miny) + miny = j; } } - if (maxx==-1) + if (maxx == -1) return Rect2(); else - return Rect2(minx,miny,maxx-minx+1,maxy-miny+1); - + return Rect2(minx, miny, maxx - minx + 1, maxy - miny + 1); } - -Image Image::get_rect(const Rect2& p_area) const { +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)); @@ -2226,143 +2114,134 @@ Image Image::get_rect(const Rect2& p_area) const { return img; }; -void Image::brush_transfer(const Image& p_src, const Image& p_brush, const Point2& p_dest) { - +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); + ERR_FAIL_COND(width != p_src.width || height != p_src.height); int dst_data_size = data.size(); DVector::Write wp = data.write(); - unsigned char *dst_data_ptr=wp.ptr(); - + unsigned char *dst_data_ptr = wp.ptr(); int src_data_size = p_src.data.size(); DVector::Read rp = p_src.data.read(); - const unsigned char *src_data_ptr=rp.ptr(); + const unsigned char *src_data_ptr = rp.ptr(); int brush_data_size = p_brush.data.size(); DVector::Read bp = p_brush.data.read(); - const unsigned char *src_brush_ptr=bp.ptr(); + 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; + int dx = p_dest.x; + int dy = p_dest.y; - for(int i=dy;i= height) + if (i < 0 || i >= height) continue; - for(int j=dx;j=width) + 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); + 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); + 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) { -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 ); - - + 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); + Rect2 rrect = Rect2(0, 0, p_src.width, p_src.height).clip(p_src_rect); DVector::Write wp = data.write(); - unsigned char *dst_data_ptr=wp.ptr(); + unsigned char *dst_data_ptr = wp.ptr(); DVector::Read rp = p_src.data.read(); - const unsigned char *src_data_ptr=rp.ptr(); + 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)) { + 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= height) + if (i < 0 || i >= height) continue; - for(int j=0;j=width) + 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]; + 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= height) + if (i < 0 || i >= height) continue; - for(int j=0;j=width) + 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); + _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; -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; +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 (*Image::lossy_packer)(const Image& ,float )=NULL; -Image (*Image::lossy_unpacker)(const DVector& )=NULL; -DVector (*Image::lossless_packer)(const Image& )=NULL; -Image (*Image::lossless_unpacker)(const DVector& )=NULL; +DVector (*Image::lossy_packer)(const Image &, float) = NULL; +Image (*Image::lossy_unpacker)(const DVector &) = NULL; +DVector (*Image::lossless_packer)(const Image &) = NULL; +Image (*Image::lossless_unpacker)(const DVector &) = NULL; void Image::set_compress_bc_func(void (*p_compress_func)(Image *)) { - _image_compress_bc_func=p_compress_func; + _image_compress_bc_func = p_compress_func; } - - void Image::normalmap_to_xy() { convert(Image::FORMAT_RGBA); { - int len = data.size()/4; + int len = data.size() / 4; DVector::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); + unsigned char *data_ptr = wp.ptr(); - for(int i=0;i::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); + unsigned char *data_ptr = wp.ptr(); - for(int i=0;i::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); + unsigned char *data_ptr = wp.ptr(); - for(int i=0;i::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); - + unsigned char *data_ptr = wp.ptr(); - for(int i=0;i>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); + 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) + if (data.size() == 0) return; - if (format!=FORMAT_RGBA) + if (format != FORMAT_RGBA) return; //not needed DVector dcopy = data; DVector::Read rp = data.read(); - const uint8_t *rptr=rp.ptr(); + const uint8_t *rptr = rp.ptr(); DVector::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); + unsigned char *data_ptr = wp.ptr(); - const int max_radius=4; - const int alpha_treshold=20; - const int max_dist=0x7FFFFFFF; + const int max_radius = 4; + const int alpha_treshold = 20; + const int max_dist = 0x7FFFFFFF; - for(int i=0;i=alpha_treshold) + BColor bc = _get_pixel(j, i, rptr, 0); + if (bc.a >= alpha_treshold) continue; - int closest_dist=max_dist; + 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) + 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]; + const uint8_t *rp = &rptr[(k * width + l) << 2]; - if (rp[3]