mirror of
https://github.com/godotengine/godot.git
synced 2024-11-26 06:03:38 +00:00
a7f49ac9a1
Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
377 lines
13 KiB
C++
377 lines
13 KiB
C++
/*************************************************************************/
|
|
/* image.h */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#ifndef IMAGE_H
|
|
#define IMAGE_H
|
|
|
|
#include "core/color.h"
|
|
#include "core/math/rect2.h"
|
|
#include "core/pool_vector.h"
|
|
#include "core/resource.h"
|
|
|
|
/**
|
|
* @author Juan Linietsky <reduzio@gmail.com>
|
|
*
|
|
* Image storage class. This is used to store an image in user memory, as well as
|
|
* providing some basic methods for image manipulation.
|
|
* Images can be loaded from a file, or registered into the Render object as textures.
|
|
*/
|
|
|
|
class Image;
|
|
|
|
typedef Error (*SavePNGFunc)(const String &p_path, const Ref<Image> &p_img);
|
|
typedef Ref<Image> (*ImageMemLoadFunc)(const uint8_t *p_png, int p_size);
|
|
|
|
typedef Error (*SaveEXRFunc)(const String &p_path, const Ref<Image> &p_img, bool p_grayscale);
|
|
|
|
class Image : public Resource {
|
|
GDCLASS(Image, Resource);
|
|
|
|
public:
|
|
static SavePNGFunc save_png_func;
|
|
static SaveEXRFunc save_exr_func;
|
|
|
|
enum {
|
|
MAX_WIDTH = 16384, // force a limit somehow
|
|
MAX_HEIGHT = 16384 // force a limit somehow
|
|
};
|
|
|
|
enum Format {
|
|
|
|
FORMAT_L8, //luminance
|
|
FORMAT_LA8, //luminance-alpha
|
|
FORMAT_R8,
|
|
FORMAT_RG8,
|
|
FORMAT_RGB8,
|
|
FORMAT_RGBA8,
|
|
FORMAT_RGBA4444,
|
|
FORMAT_RGBA5551,
|
|
FORMAT_RF, //float
|
|
FORMAT_RGF,
|
|
FORMAT_RGBF,
|
|
FORMAT_RGBAF,
|
|
FORMAT_RH, //half float
|
|
FORMAT_RGH,
|
|
FORMAT_RGBH,
|
|
FORMAT_RGBAH,
|
|
FORMAT_RGBE9995,
|
|
FORMAT_DXT1, //s3tc bc1
|
|
FORMAT_DXT3, //bc2
|
|
FORMAT_DXT5, //bc3
|
|
FORMAT_RGTC_R,
|
|
FORMAT_RGTC_RG,
|
|
FORMAT_BPTC_RGBA, //btpc bc7
|
|
FORMAT_BPTC_RGBF, //float bc6h
|
|
FORMAT_BPTC_RGBFU, //unsigned float bc6hu
|
|
FORMAT_PVRTC2, //pvrtc
|
|
FORMAT_PVRTC2A,
|
|
FORMAT_PVRTC4,
|
|
FORMAT_PVRTC4A,
|
|
FORMAT_ETC, //etc1
|
|
FORMAT_ETC2_R11, //etc2
|
|
FORMAT_ETC2_R11S, //signed, NOT srgb.
|
|
FORMAT_ETC2_RG11,
|
|
FORMAT_ETC2_RG11S,
|
|
FORMAT_ETC2_RGB8,
|
|
FORMAT_ETC2_RGBA8,
|
|
FORMAT_ETC2_RGB8A1,
|
|
FORMAT_MAX
|
|
};
|
|
|
|
static const char *format_names[FORMAT_MAX];
|
|
enum Interpolation {
|
|
|
|
INTERPOLATE_NEAREST,
|
|
INTERPOLATE_BILINEAR,
|
|
INTERPOLATE_CUBIC,
|
|
INTERPOLATE_TRILINEAR,
|
|
INTERPOLATE_LANCZOS,
|
|
/* INTERPOLATE_TRICUBIC, */
|
|
/* INTERPOLATE GAUSS */
|
|
};
|
|
|
|
enum CompressSource {
|
|
COMPRESS_SOURCE_GENERIC,
|
|
COMPRESS_SOURCE_SRGB,
|
|
COMPRESS_SOURCE_NORMAL,
|
|
COMPRESS_SOURCE_LAYERED,
|
|
};
|
|
|
|
//some functions provided by something else
|
|
|
|
static ImageMemLoadFunc _png_mem_loader_func;
|
|
static ImageMemLoadFunc _jpg_mem_loader_func;
|
|
static ImageMemLoadFunc _webp_mem_loader_func;
|
|
|
|
static void (*_image_compress_bc_func)(Image *, float, CompressSource p_source);
|
|
static void (*_image_compress_bptc_func)(Image *, float p_lossy_quality, CompressSource p_source);
|
|
static void (*_image_compress_pvrtc2_func)(Image *);
|
|
static void (*_image_compress_pvrtc4_func)(Image *);
|
|
static void (*_image_compress_etc1_func)(Image *, float);
|
|
static void (*_image_compress_etc2_func)(Image *, float, CompressSource p_source);
|
|
|
|
static void (*_image_decompress_pvrtc)(Image *);
|
|
static void (*_image_decompress_bc)(Image *);
|
|
static void (*_image_decompress_bptc)(Image *);
|
|
static void (*_image_decompress_etc1)(Image *);
|
|
static void (*_image_decompress_etc2)(Image *);
|
|
|
|
static PoolVector<uint8_t> (*lossy_packer)(const Ref<Image> &p_image, float p_quality);
|
|
static Ref<Image> (*lossy_unpacker)(const PoolVector<uint8_t> &p_buffer);
|
|
static PoolVector<uint8_t> (*lossless_packer)(const Ref<Image> &p_image);
|
|
static Ref<Image> (*lossless_unpacker)(const PoolVector<uint8_t> &p_buffer);
|
|
|
|
PoolVector<uint8_t>::Write write_lock;
|
|
|
|
protected:
|
|
static void _bind_methods();
|
|
|
|
private:
|
|
void _create_empty(int p_width, int p_height, bool p_use_mipmaps, Format p_format) {
|
|
create(p_width, p_height, p_use_mipmaps, p_format);
|
|
}
|
|
|
|
void _create_from_data(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const PoolVector<uint8_t> &p_data) {
|
|
create(p_width, p_height, p_use_mipmaps, p_format, p_data);
|
|
}
|
|
|
|
Format format;
|
|
PoolVector<uint8_t> data;
|
|
int width, height;
|
|
bool mipmaps;
|
|
|
|
void _copy_internals_from(const Image &p_image) {
|
|
format = p_image.format;
|
|
width = p_image.width;
|
|
height = p_image.height;
|
|
mipmaps = p_image.mipmaps;
|
|
data = p_image.data;
|
|
}
|
|
|
|
_FORCE_INLINE_ void _get_mipmap_offset_and_size(int p_mipmap, int &r_offset, int &r_width, int &r_height) const; //get where the mipmap begins in data
|
|
|
|
static int _get_dst_image_size(int p_width, int p_height, Format p_format, int &r_mipmaps, int p_mipmaps = -1);
|
|
bool _can_modify(Format p_format) const;
|
|
|
|
_FORCE_INLINE_ void _put_pixelb(int p_x, int p_y, uint32_t p_pixelsize, uint8_t *p_data, const uint8_t *p_pixel);
|
|
_FORCE_INLINE_ void _get_pixelb(int p_x, int p_y, uint32_t p_pixelsize, const uint8_t *p_data, uint8_t *p_pixel);
|
|
|
|
void _set_data(const Dictionary &p_data);
|
|
Dictionary _get_data() const;
|
|
|
|
Error _load_from_buffer(const PoolVector<uint8_t> &p_array, ImageMemLoadFunc p_loader);
|
|
|
|
static void average_4_uint8(uint8_t &p_out, const uint8_t &p_a, const uint8_t &p_b, const uint8_t &p_c, const uint8_t &p_d);
|
|
static void average_4_float(float &p_out, const float &p_a, const float &p_b, const float &p_c, const float &p_d);
|
|
static void average_4_half(uint16_t &p_out, const uint16_t &p_a, const uint16_t &p_b, const uint16_t &p_c, const uint16_t &p_d);
|
|
static void average_4_rgbe9995(uint32_t &p_out, const uint32_t &p_a, const uint32_t &p_b, const uint32_t &p_c, const uint32_t &p_d);
|
|
static void renormalize_uint8(uint8_t *p_rgb);
|
|
static void renormalize_float(float *p_rgb);
|
|
static void renormalize_half(uint16_t *p_rgb);
|
|
static void renormalize_rgbe9995(uint32_t *p_rgb);
|
|
|
|
public:
|
|
int get_width() const; ///< Get image width
|
|
int get_height() const; ///< Get image height
|
|
Vector2 get_size() const;
|
|
bool has_mipmaps() const;
|
|
int get_mipmap_count() const;
|
|
|
|
/**
|
|
* Convert the image to another format, conversion only to raw byte format
|
|
*/
|
|
void convert(Format p_new_format);
|
|
|
|
/**
|
|
* Get the current image format.
|
|
*/
|
|
Format get_format() const;
|
|
|
|
int get_mipmap_offset(int p_mipmap) const; //get where the mipmap begins in data
|
|
void get_mipmap_offset_and_size(int p_mipmap, int &r_ofs, int &r_size) const; //get where the mipmap begins in data
|
|
void get_mipmap_offset_size_and_dimensions(int p_mipmap, int &r_ofs, int &r_size, int &w, int &h) const; //get where the mipmap begins in data
|
|
|
|
/**
|
|
* Resize the image, using the preferred interpolation method.
|
|
*/
|
|
void resize_to_po2(bool p_square = false);
|
|
void resize(int p_width, int p_height, Interpolation p_interpolation = INTERPOLATE_BILINEAR);
|
|
void shrink_x2();
|
|
void expand_x2_hq2x();
|
|
bool is_size_po2() const;
|
|
/**
|
|
* Crop the image to a specific size, if larger, then the image is filled by black
|
|
*/
|
|
void crop_from_point(int p_x, int p_y, int p_width, int p_height);
|
|
void crop(int p_width, int p_height);
|
|
|
|
void flip_x();
|
|
void flip_y();
|
|
|
|
/**
|
|
* Generate a mipmap to an image (creates an image 1/4 the size, with averaging of 4->1)
|
|
*/
|
|
Error generate_mipmaps(bool p_renormalize = false);
|
|
|
|
void clear_mipmaps();
|
|
void normalize(); //for normal maps
|
|
|
|
/**
|
|
* Create a new image of a given size and format. Current image will be lost
|
|
*/
|
|
void create(int p_width, int p_height, bool p_use_mipmaps, Format p_format);
|
|
void create(int p_width, int p_height, bool p_use_mipmaps, Format p_format, const PoolVector<uint8_t> &p_data);
|
|
|
|
void create(const char **p_xpm);
|
|
/**
|
|
* returns true when the image is empty (0,0) in size
|
|
*/
|
|
bool empty() const;
|
|
|
|
PoolVector<uint8_t> get_data() const;
|
|
|
|
Error load(const String &p_path);
|
|
Error save_png(const String &p_path) const;
|
|
Error save_exr(const String &p_path, bool p_grayscale) const;
|
|
|
|
/**
|
|
* create an empty image
|
|
*/
|
|
Image();
|
|
/**
|
|
* create an empty image of a specific size and format
|
|
*/
|
|
Image(int p_width, int p_height, bool p_use_mipmaps, Format p_format);
|
|
/**
|
|
* import an image of a specific size and format from a pointer
|
|
*/
|
|
Image(int p_width, int p_height, bool p_mipmaps, Format p_format, const PoolVector<uint8_t> &p_data);
|
|
|
|
enum AlphaMode {
|
|
ALPHA_NONE,
|
|
ALPHA_BIT,
|
|
ALPHA_BLEND
|
|
};
|
|
|
|
AlphaMode detect_alpha() const;
|
|
bool is_invisible() const;
|
|
|
|
static int get_format_pixel_size(Format p_format);
|
|
static int get_format_pixel_rshift(Format p_format);
|
|
static int get_format_block_size(Format p_format);
|
|
static void get_format_min_pixel_size(Format p_format, int &r_w, int &r_h);
|
|
|
|
static int get_image_data_size(int p_width, int p_height, Format p_format, bool p_mipmaps = false);
|
|
static int get_image_required_mipmaps(int p_width, int p_height, Format p_format);
|
|
static int get_image_mipmap_offset(int p_width, int p_height, Format p_format, int p_mipmap);
|
|
|
|
enum CompressMode {
|
|
COMPRESS_S3TC,
|
|
COMPRESS_PVRTC2,
|
|
COMPRESS_PVRTC4,
|
|
COMPRESS_ETC,
|
|
COMPRESS_ETC2,
|
|
COMPRESS_BPTC
|
|
};
|
|
|
|
Error compress(CompressMode p_mode = COMPRESS_S3TC, CompressSource p_source = COMPRESS_SOURCE_GENERIC, float p_lossy_quality = 0.7);
|
|
Error decompress();
|
|
bool is_compressed() const;
|
|
|
|
void fix_alpha_edges();
|
|
void premultiply_alpha();
|
|
void srgb_to_linear();
|
|
void normalmap_to_xy();
|
|
Ref<Image> rgbe_to_srgb();
|
|
void bumpmap_to_normalmap(float bump_scale = 1.0);
|
|
|
|
void blit_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Point2 &p_dest);
|
|
void blit_rect_mask(const Ref<Image> &p_src, const Ref<Image> &p_mask, const Rect2 &p_src_rect, const Point2 &p_dest);
|
|
void blend_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Point2 &p_dest);
|
|
void blend_rect_mask(const Ref<Image> &p_src, const Ref<Image> &p_mask, const Rect2 &p_src_rect, const Point2 &p_dest);
|
|
void fill(const Color &c);
|
|
|
|
Rect2 get_used_rect() const;
|
|
Ref<Image> get_rect(const Rect2 &p_area) const;
|
|
|
|
static void set_compress_bc_func(void (*p_compress_func)(Image *, float, CompressSource));
|
|
static void set_compress_bptc_func(void (*p_compress_func)(Image *, float, CompressSource));
|
|
static String get_format_name(Format p_format);
|
|
|
|
Error load_png_from_buffer(const PoolVector<uint8_t> &p_array);
|
|
Error load_jpg_from_buffer(const PoolVector<uint8_t> &p_array);
|
|
Error load_webp_from_buffer(const PoolVector<uint8_t> &p_array);
|
|
|
|
Image(const uint8_t *p_mem_png_jpg, int p_len = -1);
|
|
Image(const char **p_xpm);
|
|
|
|
virtual Ref<Resource> duplicate(bool p_subresources = false) const;
|
|
|
|
void lock();
|
|
void unlock();
|
|
|
|
//this is used for compression
|
|
enum DetectChannels {
|
|
DETECTED_L,
|
|
DETECTED_LA,
|
|
DETECTED_R,
|
|
DETECTED_RG,
|
|
DETECTED_RGB,
|
|
DETECTED_RGBA,
|
|
};
|
|
|
|
DetectChannels get_detected_channels();
|
|
void optimize_channels();
|
|
|
|
Color get_pixelv(const Point2 &p_src) const;
|
|
Color get_pixel(int p_x, int p_y) const;
|
|
void set_pixelv(const Point2 &p_dst, const Color &p_color);
|
|
void set_pixel(int p_x, int p_y, const Color &p_color);
|
|
|
|
void copy_internals_from(const Ref<Image> &p_image) {
|
|
ERR_FAIL_COND_MSG(p_image.is_null(), "It's not a reference to a valid Image object.");
|
|
format = p_image->format;
|
|
width = p_image->width;
|
|
height = p_image->height;
|
|
mipmaps = p_image->mipmaps;
|
|
data = p_image->data;
|
|
}
|
|
|
|
~Image();
|
|
};
|
|
|
|
VARIANT_ENUM_CAST(Image::Format)
|
|
VARIANT_ENUM_CAST(Image::Interpolation)
|
|
VARIANT_ENUM_CAST(Image::CompressMode)
|
|
VARIANT_ENUM_CAST(Image::CompressSource)
|
|
VARIANT_ENUM_CAST(Image::AlphaMode)
|
|
|
|
#endif
|