diff options
Diffstat (limited to '')
| -rw-r--r-- | core/image.cpp | 2044 |
1 files changed, 956 insertions, 1088 deletions
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 <stdio.h> - -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); + 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); + 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<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]); + 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<uint8_t>& p_data) { - +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)); + 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<uint8_t>::Write wp = data.write(); - unsigned char *dst=wp.ptr() + pal_ofs; + unsigned char *dst = wp.ptr() + pal_ofs; DVector<uint8_t>::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<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 ); + 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<uint8_t>::Read r = data.read(); DVector<uint8_t>::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<dataend;i++) - dst32[i]=palpos[rptr[i]]; //since this is read/write, endianness is not a problem + 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); + 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; + 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<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) { - +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; + 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<CC;i++) { - color[i]=0; + for (int i = 0; i < CC; i++) { + color[i] = 0; } - - - for ( int n = -1; n < 3; n++ ) { + for (int n = -1; n < 3; n++) { // get Y cooefficient - k1 = _bicubic_interp_kernel( dy - (double) n ); + k1 = _bicubic_interp_kernel(dy - (double)n); oy2 = oy1 + n; - if ( oy2 < 0 ) + if (oy2 < 0) oy2 = 0; - if ( oy2 > 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<CC;i++) { + for (int i = 0; i < CC; i++) { - color[i]+=p[i]*k2; + color[i] += p[i] * k2; } } } - for(int i=0;i<CC;i++) { - dst[i]=CLAMP(Math::fast_ftoi(color[i]),0,255); + 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) { +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 + FRAC_BITS = 8, + FRAC_LEN = (1 << FRAC_BITS), + FRAC_MASK = FRAC_LEN - 1 }; - for(uint32_t i=0;i<p_dst_height;i++) { + 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_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; + 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<p_dst_width;j++) { + 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_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; + 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<CC;l++) { + 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 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; + 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) { -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++) { - - for(uint32_t i=0;i<p_dst_height;i++) { - - uint32_t src_yofs = i*p_src_height/p_dst_height; + 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++) { + for (uint32_t j = 0; j < p_dst_width; j++) { - uint32_t src_xofs = j*p_src_width/p_dst_width; - src_xofs*=CC; + uint32_t src_xofs = j * p_src_width / p_dst_width; + src_xofs *= CC; - for(uint32_t l=0;l<CC;l++) { + 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; + 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)) { @@ -614,16 +580,16 @@ void Image::resize_to_po2(bool p_square) { int w = nearest_power_of_2(width); int h = nearest_power_of_2(height); - if (w==width && h==height) { + if (w == width && h == height) { - if (!p_square || w==h) + if (!p_square || w == h) return; //nothing to do } - resize(w,h); + resize(w, h); } -Image Image::resized( int p_width, int p_height, int p_interpolation ) { +Image Image::resized(int p_width, int p_height, int p_interpolation) { Image ret = *this; ret.resize(p_width, p_height, (Interpolation)p_interpolation); @@ -631,113 +597,105 @@ Image Image::resized( int p_width, int p_height, int p_interpolation ) { return ret; }; - -void Image::resize( int p_width, int p_height, Interpolation p_interpolation ) { +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); - + 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<uint8_t>::Read r = data.read(); - const unsigned char*r_ptr=r.ptr(); + const unsigned char *r_ptr = r.ptr(); DVector<uint8_t>::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<uint8_t>::Read(); w = DVector<uint8_t>::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<p_height;y++) { + for (int x = 0; x < p_width; x++) { - 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); + 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<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); + put_pixel(x, y, down); + put_pixel(x, height - y - 1, up); } } if (gm) generate_mipmaps(); - } void Image::flip_x() { @@ -778,78 +732,82 @@ void Image::flip_x() { ERR_FAIL(); } - bool gm=mipmaps; + bool gm = mipmaps; if (gm) clear_mipmaps(); - for (int y=0;y<(height/2);y++) { + for (int y = 0; y < (height / 2); y++) { - for (int x=0;x<width;x++) { + for (int x = 0; x < width; x++) { - Color up = get_pixel(x,y); - Color down = get_pixel(width-x-1,y); + 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); + 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 Image::_get_dst_image_size(int p_width, int p_height, Format p_format, int &r_mipmaps, int p_mipmaps) { - 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); + 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) { + switch (p_format) { - case FORMAT_INDEXED: pixsize=1; size=256*3; break; - case FORMAT_INDEXED_ALPHA: pixsize=1; size=256*4;break; + case FORMAT_INDEXED: + pixsize = 1; + size = 256 * 3; + break; + case FORMAT_INDEXED_ALPHA: + pixsize = 1; + size = 256 * 4; + break; default: {} - } ; + }; - while(true) { + while (true) { - int s = w*h; - s*=pixsize; - s>>=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<int CC> -static void _generate_po2_mipmap(const uint8_t* p_src, uint8_t* p_dst, uint32_t p_width, uint32_t p_height) { +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++) { + for (uint32_t i = 0; i < dst_h; i++) { - const uint8_t *rup_ptr = &p_src[i*2*p_width*CC]; + 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; + uint8_t *dst_ptr = &p_dst[i * dst_w * CC]; + uint32_t count = dst_w; + while (count--) { - 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; + 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<uint8_t> dest; - dest.resize(width*2*height*2*4); + 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()); - + 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<uint8_t>::Write w=new_img.write(); - DVector<uint8_t>::Read r=data.read(); + DVector<uint8_t>::Write w = new_img.write(); + DVector<uint8_t>::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<uint8_t> 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<uint8_t>::Write w=new_img.write(); - DVector<uint8_t>::Read r=data.read(); + DVector<uint8_t>::Write w = new_img.write(); + DVector<uint8_t>::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<uint8_t>::Write wp=data.write(); + DVector<uint8_t>::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<mipmaps;i++) { + 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); + int ofs, w, h; + _get_mipmap_offset_and_size(i, ofs, w, h); - if (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<mipmaps;i++) { + for (int i = 1; i < mipmaps; i++) { + int ofs, w, h; + _get_mipmap_offset_and_size(i, ofs, w, h); - int ofs,w,h; - _get_mipmap_offset_and_size(i,ofs, w,h); + if (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<uint8_t> pallete; - ERR_FAIL_COND(ofs+palsize > data.size()); //bug? + 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); + copymem(&w[0], &r[data.size() - palsize], palsize); } - data.resize(ofs+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); + 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<height;y++) { for (int x=0;x<width;x++) { @@ -1160,12 +1098,12 @@ void Image::make_normalmap(float p_height_scale) { } */ - *this=normalmap; + *this = normalmap; } bool Image::empty() const { - return (data.size()==0); + return (data.size() == 0); } DVector<uint8_t> Image::get_data() const { @@ -1173,55 +1111,50 @@ 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) { - +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<uint8_t>::Write w= data.write(); - zeromem(w.ptr(),size); + DVector<uint8_t>::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<uint8_t>& p_data) { +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); + 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<String,Color> colormap; + HashMap<String, Color> 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<pixelchars;i++) { + String colorstring; + for (int i = 0; i < pixelchars; i++) { - colorstring+=*line_ptr; - line_ptr++; - } + 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) + while (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == 0) { + if (*line_ptr == 0) break; line_ptr++; } + if (*line_ptr == 'c') { - if (*line_ptr=='#') { line_ptr++; - uint8_t col_r; - uint8_t col_g; - uint8_t col_b; -// uint8_t col_a=255; + while (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == 0) { + if (*line_ptr == 0) + break; + line_ptr++; + } - for (int i=0;i<6;i++) { + if (*line_ptr == '#') { + line_ptr++; + uint8_t col_r; + uint8_t col_g; + uint8_t col_b; + // uint8_t col_a=255; - char v = line_ptr[i]; + for (int i = 0; i < 6; 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; + char v = line_ptr[i]; - 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; - }; + 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) { + // 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(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); + 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;x<size_width;x++) { + status = READING_PIXELS; + create(size_width, size_height, 0, has_alpha ? FORMAT_RGBA : FORMAT_RGB); + } + } break; + case READING_PIXELS: { - char pixelstr[6]={0,0,0,0,0,0}; - for (int i=0;i<pixelchars;i++) - pixelstr[i]=line_ptr[x*pixelchars+i]; + int y = line - colormap_size - 1; + for (int x = 0; x < size_width; x++) { - Color *colorptr = colormap.getptr(pixelstr); - ERR_FAIL_COND(!colorptr); - put_pixel(x,y,*colorptr); + 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:{} + if (y == (size_height - 1)) + status = DONE; + } break; + default: {} } line++; @@ -1357,71 +1286,69 @@ void Image::create( const char ** p_xpm ) { #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;\ - }\ -} +#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<uint8_t>::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<len;i++) { + 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]); + 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<uint8_t>::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<len;i++) { + 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]); + 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<uint8_t> newdata; newdata.resize(size); @@ -1753,352 +1667,333 @@ Error Image::_decompress_bc() { DVector<uint8_t>::Write w = newdata.write(); DVector<uint8_t>::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 < len; j++) { - 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]; + 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} + uint8_t table[4][4] = { + { (col_a >> 11) << 3, ((col_a >> 5) & 0x3f) << 2, ((col_a)&0x1f) << 3, 255 }, + { (col_b >> 11) << 3, ((col_b >> 5) & 0x3f) << 2, ((col_b)&0x1f) << 3, 255 }, + { 0, 0, 0, 255 }, + { 0, 0, 0, 255 } }; - if (col_a<col_b) { + 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 + 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]; + 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; + 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; + 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 < len; j++) { - 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]; + 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]; + 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} + 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; + 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]; + 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; + 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; + 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;j<len;j++) { + uint8_t a_start = src[1]; + uint8_t a_end = src[0]; - 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]; + 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) { + 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]; - 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} + 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]; + 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; - int y = (j/(wd/4))*4; - int x = (j%(wd/4))*4; - int pixofs = (y*wd+x)*4; + 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; + 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<uint8_t>::Write(); - r=DVector<uint8_t>::Read(); + w = DVector<uint8_t>::Write(); + r = DVector<uint8_t>::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<uint8_t>& 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<uint8_t> &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<uint8_t>::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;i<width;i++) { - for(int j=0;j<height;j++) { + 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; + 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 (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<uint8_t>::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<uint8_t>::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<uint8_t>::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<dy+bh;i++) { + for (int i = dy; i < dy + bh; i++) { - if (i<0 || i >= height) + if (i < 0 || i >= height) continue; - for(int j=dx;j<dx+bw;j++) { + for (int j = dx; j < dx + bw; j++) { - if (j<0 || 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<uint8_t>::Write wp = data.write(); - unsigned char *dst_data_ptr=wp.ptr(); + unsigned char *dst_data_ptr = wp.ptr(); DVector<uint8_t>::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<rrect.size.y;i++) { + for (int i = 0; i < rrect.size.y; i++) { - if (i<0 || i >= height) + if (i < 0 || i >= height) continue; - for(int j=0;j<rrect.size.x;j++) { + for (int j = 0; j < rrect.size.x; j++) { - if (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<rrect.size.y;i++) { + for (int i = 0; i < rrect.size.y; i++) { - if (i<0 || i >= height) + if (i < 0 || i >= height) continue; - for(int j=0;j<rrect.size.x;j++) { + for (int j = 0; j < rrect.size.x; j++) { - if (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<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; +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; + _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<uint8_t>::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); + unsigned char *data_ptr = wp.ptr(); - for(int i=0;i<len;i++) { + 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]; + 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]; } } @@ -2371,165 +2250,154 @@ void Image::normalmap_to_xy() { void Image::srgb_to_linear() { - if (data.size()==0) + 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}; - + 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 ); + ERR_FAIL_COND(format != FORMAT_RGB && format != FORMAT_RGBA); - if (format==FORMAT_RGBA) { + if (format == FORMAT_RGBA) { - int len = data.size()/4; + int len = data.size() / 4; DVector<uint8_t>::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); + unsigned char *data_ptr = wp.ptr(); - for(int i=0;i<len;i++) { + 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] ]; + 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) { + } else if (format == FORMAT_RGB) { - int len = data.size()/3; + int len = data.size() / 3; DVector<uint8_t>::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); + unsigned char *data_ptr = wp.ptr(); - for(int i=0;i<len;i++) { + 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] ]; + 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) + if (data.size() == 0) return; - if (format!=FORMAT_RGBA) + if (format != FORMAT_RGBA) return; //not needed DVector<uint8_t>::Write wp = data.write(); - unsigned char *data_ptr=wp.ptr(); - + unsigned char *data_ptr = wp.ptr(); - for(int i=0;i<height;i++) { - for(int j=0;j<width;j++) { + 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); + 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<uint8_t> dcopy = data; DVector<uint8_t>::Read rp = data.read(); - const uint8_t *rptr=rp.ptr(); + const uint8_t *rptr = rp.ptr(); DVector<uint8_t>::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<height;i++) { - for(int j=0;j<width;j++) { + 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) + 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); + 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++) { + 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) + 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]<alpha_treshold) + if (rp[3] < alpha_treshold) continue; - closest_dist=dist; - closest_color.r=rp[0]; - closest_color.g=rp[1]; - closest_color.b=rp[2]; - + 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); - + 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()); + 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) { +Image::Image(const uint8_t *p_mem_png_jpg, int p_len) { - width=0; - height=0; - mipmaps=0; - format=FORMAT_GRAYSCALE; + 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); + *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); + *this = _jpg_mem_loader_func(p_mem_png_jpg, p_len); } - } Image::Image() { - width=0; - height=0; - mipmaps=0; + width = 0; + height = 0; + mipmaps = 0; format = FORMAT_GRAYSCALE; } Image::~Image() { - } - - |