summaryrefslogtreecommitdiff
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/bind/core_bind.cpp2
-rw-r--r--core/bind/core_bind.h3
-rw-r--r--core/global_constants.cpp13
-rw-r--r--core/image.cpp230
-rw-r--r--core/image.h75
-rw-r--r--core/io/image_loader.cpp3
-rw-r--r--core/io/image_loader.h4
-rw-r--r--core/io/marshalls.cpp56
-rw-r--r--core/io/resource_format_binary.cpp140
-rw-r--r--core/method_bind.h2
-rw-r--r--core/method_ptrcall.h1
-rw-r--r--core/os/os.cpp2
-rw-r--r--core/os/os.h3
-rw-r--r--core/packed_data_container.cpp1
-rw-r--r--core/register_core_types.cpp2
-rw-r--r--core/resource.cpp2
-rw-r--r--core/resource.h2
-rw-r--r--core/ring_buffer.h26
-rw-r--r--core/script_debugger_remote.cpp4
-rw-r--r--core/variant.cpp38
-rw-r--r--core/variant.h17
-rw-r--r--core/variant_call.cpp94
-rw-r--r--core/variant_op.cpp59
-rw-r--r--core/variant_parser.cpp241
24 files changed, 310 insertions, 710 deletions
diff --git a/core/bind/core_bind.cpp b/core/bind/core_bind.cpp
index 7a03ceb64c..2752391901 100644
--- a/core/bind/core_bind.cpp
+++ b/core/bind/core_bind.cpp
@@ -505,7 +505,7 @@ int _OS::get_dynamic_memory_usage() const {
return OS::get_singleton()->get_dynamic_memory_usage();
}
-void _OS::set_icon(const Image &p_icon) {
+void _OS::set_icon(const Ref<Image> &p_icon) {
OS::get_singleton()->set_icon(p_icon);
}
diff --git a/core/bind/core_bind.h b/core/bind/core_bind.h
index 222339bce1..e48b5c85ad 100644
--- a/core/bind/core_bind.h
+++ b/core/bind/core_bind.h
@@ -30,6 +30,7 @@
#ifndef CORE_BIND_H
#define CORE_BIND_H
+#include "image.h"
#include "io/resource_loader.h"
#include "io/resource_saver.h"
#include "os/dir_access.h"
@@ -226,7 +227,7 @@ public:
void set_use_file_access_save_and_swap(bool p_enable);
- void set_icon(const Image &p_icon);
+ void set_icon(const Ref<Image> &p_icon);
int get_exit_code() const;
void set_exit_code(int p_code);
diff --git a/core/global_constants.cpp b/core/global_constants.cpp
index 9bc98c5ad7..18f34b5d37 100644
--- a/core/global_constants.cpp
+++ b/core/global_constants.cpp
@@ -506,22 +506,21 @@ static _GlobalConstant _global_constants[] = {
{ "TYPE_TRANSFORM2D", Variant::TRANSFORM2D },
{ "TYPE_PLANE", Variant::PLANE },
{ "TYPE_QUAT", Variant::QUAT }, // 10
- { "TYPE_RECT3", Variant::RECT3 }, //sorry naming convention fail :( not like it's used often
+ { "TYPE_RECT3", Variant::RECT3 },
{ "TYPE_BASIS", Variant::BASIS },
{ "TYPE_TRANSFORM", Variant::TRANSFORM },
{ "TYPE_COLOR", Variant::COLOR },
- { "TYPE_IMAGE", Variant::IMAGE }, // 15
- { "TYPE_NODE_PATH", Variant::NODE_PATH },
+ { "TYPE_NODE_PATH", Variant::NODE_PATH }, // 15
{ "TYPE_RID", Variant::_RID },
{ "TYPE_OBJECT", Variant::OBJECT },
{ "TYPE_INPUT_EVENT", Variant::INPUT_EVENT },
- { "TYPE_DICTIONARY", Variant::DICTIONARY }, // 20
- { "TYPE_ARRAY", Variant::ARRAY },
+ { "TYPE_DICTIONARY", Variant::DICTIONARY },
+ { "TYPE_ARRAY", Variant::ARRAY }, // 20
{ "TYPE_RAW_ARRAY", Variant::POOL_BYTE_ARRAY },
{ "TYPE_INT_ARRAY", Variant::POOL_INT_ARRAY },
{ "TYPE_REAL_ARRAY", Variant::POOL_REAL_ARRAY },
- { "TYPE_STRING_ARRAY", Variant::POOL_STRING_ARRAY }, // 25
- { "TYPE_VECTOR2_ARRAY", Variant::POOL_VECTOR2_ARRAY },
+ { "TYPE_STRING_ARRAY", Variant::POOL_STRING_ARRAY },
+ { "TYPE_VECTOR2_ARRAY", Variant::POOL_VECTOR2_ARRAY }, // 25
{ "TYPE_VECTOR3_ARRAY", Variant::POOL_VECTOR3_ARRAY },
{ "TYPE_COLOR_ARRAY", Variant::POOL_COLOR_ARRAY },
{ "TYPE_MAX", Variant::VARIANT_MAX },
diff --git a/core/image.cpp b/core/image.cpp
index b81d92fa33..85ca63be5e 100644
--- a/core/image.cpp
+++ b/core/image.cpp
@@ -415,7 +415,7 @@ void Image::convert(Format p_new_format) {
//mipmaps=false;
- *this = new_img;
+ _copy_internals_from(new_img);
if (gen_mipmaps)
generate_mipmaps();
@@ -611,14 +611,6 @@ void Image::resize_to_po2(bool p_square) {
resize(w, h);
}
-Image Image::resized(int p_width, int p_height, int p_interpolation) {
-
- Image ret = *this;
- ret.resize(p_width, p_height, (Interpolation)p_interpolation);
-
- return ret;
-};
-
void Image::resize(int p_width, int p_height, Interpolation p_interpolation) {
if (!_can_modify(format)) {
@@ -681,7 +673,7 @@ void Image::resize(int p_width, int p_height, Interpolation p_interpolation) {
if (mipmaps > 0)
dst.generate_mipmaps();
- *this = dst;
+ _copy_internals_from(dst);
}
void Image::crop(int p_width, int p_height) {
@@ -728,7 +720,7 @@ void Image::crop(int p_width, int p_height) {
if (mipmaps > 0)
dst.generate_mipmaps();
- *this = dst;
+ _copy_internals_from(dst);
}
void Image::flip_y() {
@@ -1383,17 +1375,7 @@ Error Image::save_png(const String &p_path) {
if (save_png_func == NULL)
return ERR_UNAVAILABLE;
- return save_png_func(p_path, *this);
-}
-
-bool Image::operator==(const Image &p_image) const {
-
- if (data.size() == 0 && p_image.data.size() == 0)
- return true;
- PoolVector<uint8_t>::Read r = data.read();
- PoolVector<uint8_t>::Read pr = p_image.data.read();
-
- return r.ptr() == pr.ptr();
+ return save_png_func(p_path, Ref<Image>(this));
}
int Image::get_image_data_size(int p_width, int p_height, Format p_format, int p_mipmaps) {
@@ -1736,13 +1718,6 @@ bool Image::is_compressed() const {
return format >= FORMAT_RGB565;
}
-Image Image::decompressed() const {
-
- Image img = *this;
- img.decompress();
- return img;
-}
-
Error Image::decompress() {
if (format >= FORMAT_DXT1 && format <= FORMAT_ATI2)
@@ -1797,14 +1772,6 @@ Error Image::compress(CompressMode p_mode) {
return OK;
}
-Image Image::compressed(int p_mode) {
-
- Image ret = *this;
- ret.compress((Image::CompressMode)p_mode);
-
- return ret;
-}
-
Image::Image(const char **p_xpm) {
width = 0;
@@ -1875,21 +1842,21 @@ Rect2 Image::get_used_rect() const {
return Rect2(minx, miny, maxx - minx + 1, maxy - miny + 1);
}
-Image Image::get_rect(const Rect2 &p_area) const {
-
- Image img(p_area.size.x, p_area.size.y, mipmaps, format);
- img.blit_rect(*this, p_area, Point2(0, 0));
+Ref<Image> Image::get_rect(const Rect2 &p_area) const {
+ Ref<Image> img = memnew(Image(p_area.size.x, p_area.size.y, mipmaps, format));
+ img->blit_rect(Ref<Image>(this), p_area, Point2(0, 0));
return img;
}
-void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 &p_dest) {
+void Image::blit_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Point2 &p_dest) {
+ ERR_FAIL_COND(p_src.is_null());
int dsize = data.size();
- int srcdsize = p_src.data.size();
+ int srcdsize = p_src->data.size();
ERR_FAIL_COND(dsize == 0);
ERR_FAIL_COND(srcdsize == 0);
- ERR_FAIL_COND(format != p_src.format);
+ ERR_FAIL_COND(format != p_src->format);
Rect2i local_src_rect = Rect2i(0, 0, width, height).clip(Rect2i(p_dest + p_src_rect.pos, p_src_rect.size));
@@ -1900,7 +1867,7 @@ void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2
PoolVector<uint8_t>::Write wp = data.write();
uint8_t *dst_data_ptr = wp.ptr();
- PoolVector<uint8_t>::Read rp = p_src.data.read();
+ PoolVector<uint8_t>::Read rp = p_src->data.read();
const uint8_t *src_data_ptr = rp.ptr();
int pixel_size = get_format_pixel_size(format);
@@ -1915,7 +1882,7 @@ void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2
int dst_x = local_src_rect.pos.x + j;
int dst_y = local_src_rect.pos.y + i;
- const uint8_t *src = &src_data_ptr[(src_y * p_src.width + src_x) * pixel_size];
+ const uint8_t *src = &src_data_ptr[(src_y * p_src->width + src_x) * pixel_size];
uint8_t *dst = &dst_data_ptr[(dst_y * width + dst_x) * pixel_size];
for (int k = 0; k < pixel_size; k++) {
@@ -1925,8 +1892,8 @@ void Image::blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2
}
}
-Image (*Image::_png_mem_loader_func)(const uint8_t *, int) = NULL;
-Image (*Image::_jpg_mem_loader_func)(const uint8_t *, int) = NULL;
+Ref<Image> (*Image::_png_mem_loader_func)(const uint8_t *, int) = NULL;
+Ref<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;
@@ -1938,10 +1905,157 @@ void (*Image::_image_decompress_bc)(Image *) = NULL;
void (*Image::_image_decompress_etc)(Image *) = NULL;
void (*Image::_image_decompress_etc2)(Image *) = NULL;
-PoolVector<uint8_t> (*Image::lossy_packer)(const Image &, float) = NULL;
-Image (*Image::lossy_unpacker)(const PoolVector<uint8_t> &) = NULL;
-PoolVector<uint8_t> (*Image::lossless_packer)(const Image &) = NULL;
-Image (*Image::lossless_unpacker)(const PoolVector<uint8_t> &) = NULL;
+PoolVector<uint8_t> (*Image::lossy_packer)(const Ref<Image> &, float) = NULL;
+Ref<Image> (*Image::lossy_unpacker)(const PoolVector<uint8_t> &) = NULL;
+PoolVector<uint8_t> (*Image::lossless_packer)(const Ref<Image> &) = NULL;
+Ref<Image> (*Image::lossless_unpacker)(const PoolVector<uint8_t> &) = NULL;
+
+void Image::_set_data(const Dictionary &p_data) {
+
+ ERR_FAIL_COND(!p_data.has("width"));
+ ERR_FAIL_COND(!p_data.has("height"));
+ ERR_FAIL_COND(!p_data.has("format"));
+ ERR_FAIL_COND(!p_data.has("mipmaps"));
+ ERR_FAIL_COND(!p_data.has("data"));
+
+ int dwidth = p_data["width"];
+ int dheight = p_data["height"];
+ String dformat = p_data["format"];
+ bool dmipmaps = p_data["mipmaps"];
+ PoolVector<uint8_t> ddata = p_data["data"];
+ Format ddformat = FORMAT_MAX;
+ for (int i = 0; i < FORMAT_MAX; i++) {
+ if (dformat == get_format_name(Format(i))) {
+ ddformat = Format(i);
+ break;
+ }
+ }
+
+ ERR_FAIL_COND(ddformat == FORMAT_MAX);
+
+ create(dwidth, dheight, dmipmaps, ddformat, ddata);
+}
+
+Dictionary Image::_get_data() const {
+
+ Dictionary d;
+ d["width"] = width;
+ d["height"] = height;
+ d["format"] = get_format_name(format);
+ d["mipmaps"] = mipmaps;
+ d["data"] = data;
+ return d;
+}
+
+void Image::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("get_width"), &Image::get_width);
+ ClassDB::bind_method(D_METHOD("get_height"), &Image::get_height);
+ ClassDB::bind_method(D_METHOD("has_mipmaps"), &Image::has_mipmaps);
+ ClassDB::bind_method(D_METHOD("get_format"), &Image::get_format);
+ ClassDB::bind_method(D_METHOD("get_data"), &Image::get_data);
+
+ ClassDB::bind_method(D_METHOD("convert", "format"), &Image::convert);
+
+ ClassDB::bind_method(D_METHOD("get_mipmap_offset", "mipmap"), &Image::get_mipmap_offset);
+
+ ClassDB::bind_method(D_METHOD("resize_to_po2", "square"), &Image::resize_to_po2, DEFVAL("false"));
+ ClassDB::bind_method(D_METHOD("resize", "width", "height", "interpolation"), &Image::resize, DEFVAL(INTERPOLATE_BILINEAR));
+ ClassDB::bind_method(D_METHOD("shrink_x2"), &Image::shrink_x2);
+ ClassDB::bind_method(D_METHOD("expand_x2_hq2x"), &Image::expand_x2_hq2x);
+
+ ClassDB::bind_method(D_METHOD("crop", "width", "height"), &Image::crop);
+ ClassDB::bind_method(D_METHOD("flip_x"), &Image::flip_x);
+ ClassDB::bind_method(D_METHOD("flip_y"), &Image::flip_y);
+ ClassDB::bind_method(D_METHOD("generate_mipmaps"), &Image::generate_mipmaps);
+ ClassDB::bind_method(D_METHOD("clear_mipmaps"), &Image::clear_mipmaps);
+
+ ClassDB::bind_method(D_METHOD("create", "width", "height", "use_mipmaps", "format"), &Image::_create_empty);
+ ClassDB::bind_method(D_METHOD("create_from_data", "width", "height", "use_mipmaps", "format", "data"), &Image::_create_from_data);
+
+ ClassDB::bind_method(D_METHOD("is_empty"), &Image::empty);
+
+ ClassDB::bind_method(D_METHOD("load", "path"), &Image::load);
+ ClassDB::bind_method(D_METHOD("save_png", "path"), &Image::save_png);
+
+ ClassDB::bind_method(D_METHOD("detect_alpha"), &Image::detect_alpha);
+ ClassDB::bind_method(D_METHOD("is_invisible"), &Image::is_invisible);
+
+ ClassDB::bind_method(D_METHOD("compress", "mode"), &Image::compress);
+ ClassDB::bind_method(D_METHOD("decompress"), &Image::decompress);
+ ClassDB::bind_method(D_METHOD("is_compressed"), &Image::is_compressed);
+
+ ClassDB::bind_method(D_METHOD("fix_alpha_edges"), &Image::fix_alpha_edges);
+ ClassDB::bind_method(D_METHOD("premultiply_alpha"), &Image::premultiply_alpha);
+ ClassDB::bind_method(D_METHOD("srgb_to_linear"), &Image::srgb_to_linear);
+ ClassDB::bind_method(D_METHOD("normalmap_to_xy"), &Image::normalmap_to_xy);
+
+ ClassDB::bind_method(D_METHOD("blit_rect", "src:Image", "src_rect", "dst"), &Image::blit_rect);
+
+ ClassDB::bind_method(D_METHOD("get_used_rect"), &Image::get_used_rect);
+ ClassDB::bind_method(D_METHOD("get_rect:Image", "rect"), &Image::get_rect);
+
+ ClassDB::bind_method(D_METHOD("copy_from", "src:Image"), &Image::copy_internals_from);
+
+ ClassDB::bind_method(D_METHOD("_set_data", "data"), &Image::_set_data);
+ ClassDB::bind_method(D_METHOD("_get_data"), &Image::_get_data);
+
+ ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE), "_set_data", "_get_data");
+
+ BIND_CONSTANT(FORMAT_L8); //luminance
+ BIND_CONSTANT(FORMAT_LA8); //luminance-alpha
+ BIND_CONSTANT(FORMAT_R8);
+ BIND_CONSTANT(FORMAT_RG8);
+ BIND_CONSTANT(FORMAT_RGB8);
+ BIND_CONSTANT(FORMAT_RGBA8);
+ BIND_CONSTANT(FORMAT_RGB565); //16 bit
+ BIND_CONSTANT(FORMAT_RGBA4444);
+ BIND_CONSTANT(FORMAT_RGBA5551);
+ BIND_CONSTANT(FORMAT_RF); //float
+ BIND_CONSTANT(FORMAT_RGF);
+ BIND_CONSTANT(FORMAT_RGBF);
+ BIND_CONSTANT(FORMAT_RGBAF);
+ BIND_CONSTANT(FORMAT_RH); //half float
+ BIND_CONSTANT(FORMAT_RGH);
+ BIND_CONSTANT(FORMAT_RGBH);
+ BIND_CONSTANT(FORMAT_RGBAH);
+ BIND_CONSTANT(FORMAT_DXT1); //s3tc bc1
+ BIND_CONSTANT(FORMAT_DXT3); //bc2
+ BIND_CONSTANT(FORMAT_DXT5); //bc3
+ BIND_CONSTANT(FORMAT_ATI1); //bc4
+ BIND_CONSTANT(FORMAT_ATI2); //bc5
+ BIND_CONSTANT(FORMAT_BPTC_RGBA); //btpc bc6h
+ BIND_CONSTANT(FORMAT_BPTC_RGBF); //float /
+ BIND_CONSTANT(FORMAT_BPTC_RGBFU); //unsigned float
+ BIND_CONSTANT(FORMAT_PVRTC2); //pvrtc
+ BIND_CONSTANT(FORMAT_PVRTC2A);
+ BIND_CONSTANT(FORMAT_PVRTC4);
+ BIND_CONSTANT(FORMAT_PVRTC4A);
+ BIND_CONSTANT(FORMAT_ETC); //etc1
+ BIND_CONSTANT(FORMAT_ETC2_R11); //etc2
+ BIND_CONSTANT(FORMAT_ETC2_R11S); //signed ); NOT srgb.
+ BIND_CONSTANT(FORMAT_ETC2_RG11);
+ BIND_CONSTANT(FORMAT_ETC2_RG11S);
+ BIND_CONSTANT(FORMAT_ETC2_RGB8);
+ BIND_CONSTANT(FORMAT_ETC2_RGBA8);
+ BIND_CONSTANT(FORMAT_ETC2_RGB8A1);
+ BIND_CONSTANT(FORMAT_MAX);
+
+ BIND_CONSTANT(INTERPOLATE_NEAREST);
+ BIND_CONSTANT(INTERPOLATE_BILINEAR);
+ BIND_CONSTANT(INTERPOLATE_CUBIC);
+
+ BIND_CONSTANT(ALPHA_NONE);
+ BIND_CONSTANT(ALPHA_BIT);
+ BIND_CONSTANT(ALPHA_BLEND);
+
+ BIND_CONSTANT(COMPRESS_16BIT);
+ BIND_CONSTANT(COMPRESS_S3TC);
+ BIND_CONSTANT(COMPRESS_PVRTC2);
+ BIND_CONSTANT(COMPRESS_PVRTC4);
+ BIND_CONSTANT(COMPRESS_ETC);
+ BIND_CONSTANT(COMPRESS_ETC2);
+}
void Image::set_compress_bc_func(void (*p_compress_func)(Image *)) {
@@ -2108,14 +2222,22 @@ Image::Image(const uint8_t *p_mem_png_jpg, int p_len) {
format = FORMAT_L8;
if (_png_mem_loader_func) {
- *this = _png_mem_loader_func(p_mem_png_jpg, p_len);
+ copy_internals_from(_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);
+ copy_internals_from(_jpg_mem_loader_func(p_mem_png_jpg, p_len));
}
}
+Ref<Resource> Image::duplicate(bool p_subresources) const {
+
+ Ref<Image> copy;
+ copy.instance();
+ copy->_copy_internals_from(*this);
+ return copy;
+}
+
Image::Image() {
width = 0;
diff --git a/core/image.h b/core/image.h
index fc87ee8847..4decaa3436 100644
--- a/core/image.h
+++ b/core/image.h
@@ -33,6 +33,8 @@
#include "color.h"
#include "dvector.h"
#include "math_2d.h"
+#include "resource.h"
+
/**
* @author Juan Linietsky <reduzio@gmail.com>
*
@@ -43,9 +45,10 @@
class Image;
-typedef Error (*SavePNGFunc)(const String &p_path, Image &p_img);
+typedef Error (*SavePNGFunc)(const String &p_path, const Ref<Image> &p_img);
-class Image {
+class Image : public Resource {
+ GDCLASS(Image, Resource);
enum {
MAX_WIDTH = 16384, // force a limit somehow
@@ -108,8 +111,8 @@ public:
//some functions provided by something else
- static Image (*_png_mem_loader_func)(const uint8_t *p_png, int p_size);
- static Image (*_jpg_mem_loader_func)(const uint8_t *p_png, int p_size);
+ static Ref<Image> (*_png_mem_loader_func)(const uint8_t *p_png, int p_size);
+ static Ref<Image> (*_jpg_mem_loader_func)(const uint8_t *p_png, int p_size);
static void (*_image_compress_bc_func)(Image *);
static void (*_image_compress_pvrtc2_func)(Image *);
@@ -124,17 +127,36 @@ public:
Error _decompress_bc();
- static PoolVector<uint8_t> (*lossy_packer)(const Image &p_image, float p_quality);
- static Image (*lossy_unpacker)(const PoolVector<uint8_t> &p_buffer);
- static PoolVector<uint8_t> (*lossless_packer)(const Image &p_image);
- static Image (*lossless_unpacker)(const PoolVector<uint8_t> &p_buffer);
+ 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);
+
+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);
@@ -143,6 +165,9 @@ private:
_FORCE_INLINE_ void _put_pixelb(int p_x, int p_y, uint32_t p_pixelsize, uint8_t *p_dst, const uint8_t *p_src);
_FORCE_INLINE_ void _get_pixelb(int p_x, int p_y, uint32_t p_pixelsize, const uint8_t *p_src, uint8_t *p_dst);
+ void _set_data(const Dictionary &p_data);
+ Dictionary _get_data() const;
+
public:
int get_width() const; ///< Get image width
int get_height() const; ///< Get image height
@@ -154,14 +179,6 @@ public:
*/
void convert(Format p_new_format);
- Image converted(int p_new_format) {
- ERR_FAIL_INDEX_V(p_new_format, FORMAT_MAX, Image());
-
- Image ret = *this;
- ret.convert((Format)p_new_format);
- return ret;
- };
-
/**
* Get the current image format.
*/
@@ -178,7 +195,6 @@ public:
void resize_to_po2(bool p_square = false);
void resize(int p_width, int p_height, Interpolation p_interpolation = INTERPOLATE_BILINEAR);
- Image resized(int p_width, int p_height, int p_interpolation = INTERPOLATE_BILINEAR);
void shrink_x2();
void expand_x2_hq2x();
/**
@@ -242,8 +258,6 @@ public:
static int get_image_data_size(int p_width, int p_height, Format p_format, int p_mipmaps = 0);
static int get_image_required_mipmaps(int p_width, int p_height, Format p_format);
- bool operator==(const Image &p_image) const;
-
enum CompressMode {
COMPRESS_16BIT,
COMPRESS_S3TC,
@@ -254,9 +268,7 @@ public:
};
Error compress(CompressMode p_mode = COMPRESS_S3TC);
- Image compressed(int p_mode); /* from the Image::CompressMode enum */
Error decompress();
- Image decompressed() const;
bool is_compressed() const;
void fix_alpha_edges();
@@ -264,17 +276,34 @@ public:
void srgb_to_linear();
void normalmap_to_xy();
- void blit_rect(const Image &p_src, const Rect2 &p_src_rect, const Point2 &p_dest);
+ void blit_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Point2 &p_dest);
Rect2 get_used_rect() const;
- Image get_rect(const Rect2 &p_area) const;
+ Ref<Image> get_rect(const Rect2 &p_area) const;
static void set_compress_bc_func(void (*p_compress_func)(Image *));
static String get_format_name(Format p_format);
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 copy_internals_from(const Ref<Image> &p_image) {
+ ERR_FAIL_COND(p_image.is_null());
+ 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::AlphaMode)
+
#endif
diff --git a/core/io/image_loader.cpp b/core/io/image_loader.cpp
index 4864c18831..6ed20ac015 100644
--- a/core/io/image_loader.cpp
+++ b/core/io/image_loader.cpp
@@ -43,7 +43,8 @@ bool ImageFormatLoader::recognize(const String &p_extension) const {
return false;
}
-Error ImageLoader::load_image(String p_file, Image *p_image, FileAccess *p_custom) {
+Error ImageLoader::load_image(String p_file, Ref<Image> p_image, FileAccess *p_custom) {
+ ERR_FAIL_COND_V(p_image.is_null(), ERR_INVALID_PARAMETER);
FileAccess *f = p_custom;
if (!f) {
diff --git a/core/io/image_loader.h b/core/io/image_loader.h
index 37149dbe9d..7114cbf8ad 100644
--- a/core/io/image_loader.h
+++ b/core/io/image_loader.h
@@ -56,7 +56,7 @@ class ImageFormatLoader {
friend class ImageLoader;
protected:
- virtual Error load_image(Image *p_image, FileAccess *p_fileaccess) = 0;
+ virtual Error load_image(Ref<Image> p_image, FileAccess *p_fileaccess) = 0;
virtual void get_recognized_extensions(List<String> *p_extensions) const = 0;
bool recognize(const String &p_extension) const;
@@ -75,7 +75,7 @@ class ImageLoader {
protected:
public:
- static Error load_image(String p_file, Image *p_image, FileAccess *p_custom = NULL);
+ static Error load_image(String p_file, Ref<Image> p_image, FileAccess *p_custom = NULL);
static void get_recognized_extensions(List<String> *p_extensions);
static bool recognize(const String &p_extension);
diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp
index 5e66b7f7f5..fd14011a81 100644
--- a/core/io/marshalls.cpp
+++ b/core/io/marshalls.cpp
@@ -276,38 +276,6 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
(*r_len) += 4 * 4;
} break;
- case Variant::IMAGE: {
-
- ERR_FAIL_COND_V(len < (int)5 * 4, ERR_INVALID_DATA);
- Image::Format fmt = (Image::Format)decode_uint32(&buf[0]);
- ERR_FAIL_INDEX_V(fmt, Image::FORMAT_MAX, ERR_INVALID_DATA);
- uint32_t mipmaps = decode_uint32(&buf[4]);
- uint32_t w = decode_uint32(&buf[8]);
- uint32_t h = decode_uint32(&buf[12]);
- uint32_t datalen = decode_uint32(&buf[16]);
-
- Image img;
- if (datalen > 0) {
- len -= 5 * 4;
- ERR_FAIL_COND_V(len < datalen, ERR_INVALID_DATA);
- PoolVector<uint8_t> data;
- data.resize(datalen);
- PoolVector<uint8_t>::Write wr = data.write();
- copymem(&wr[0], &buf[20], datalen);
- wr = PoolVector<uint8_t>::Write();
-
- img = Image(w, h, mipmaps, fmt, data);
- }
-
- r_variant = img;
- if (r_len) {
- if (datalen % 4)
- (*r_len) += 4 - datalen % 4;
-
- (*r_len) += 4 * 5 + datalen;
- }
-
- } break;
case Variant::NODE_PATH: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
@@ -1078,30 +1046,6 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len) {
r_len += 4 * 4;
} break;
- case Variant::IMAGE: {
-
- Image image = p_variant;
- PoolVector<uint8_t> data = image.get_data();
-
- if (buf) {
-
- encode_uint32(image.get_format(), &buf[0]);
- encode_uint32(image.has_mipmaps(), &buf[4]);
- encode_uint32(image.get_width(), &buf[8]);
- encode_uint32(image.get_height(), &buf[12]);
- int ds = data.size();
- encode_uint32(ds, &buf[16]);
- PoolVector<uint8_t>::Read r = data.read();
- copymem(&buf[20], &r[0], ds);
- }
-
- int pad = 0;
- if (data.size() % 4)
- pad = 4 - data.size() % 4;
-
- r_len += data.size() + 5 * 4 + pad;
-
- } break;
/*case Variant::RESOURCE: {
ERR_EXPLAIN("Can't marshallize resources");
diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp
index fc18a44ed3..4ad3d261b2 100644
--- a/core/io/resource_format_binary.cpp
+++ b/core/io/resource_format_binary.cpp
@@ -49,12 +49,12 @@ enum {
VARIANT_VECTOR3 = 12,
VARIANT_PLANE = 13,
VARIANT_QUAT = 14,
- VARIANT_AABB = 15,
+ VARIANT_RECT3 = 15,
VARIANT_MATRIX3 = 16,
VARIANT_TRANSFORM = 17,
VARIANT_MATRIX32 = 18,
VARIANT_COLOR = 20,
- VARIANT_IMAGE = 21,
+ //VARIANT_IMAGE = 21, - no longer variant type
VARIANT_NODE_PATH = 22,
VARIANT_RID = 23,
VARIANT_OBJECT = 24,
@@ -71,11 +71,6 @@ enum {
VARIANT_INT64 = 40,
VARIANT_DOUBLE = 41,
- IMAGE_ENCODING_EMPTY = 0,
- IMAGE_ENCODING_RAW = 1,
- IMAGE_ENCODING_LOSSLESS = 2,
- IMAGE_ENCODING_LOSSY = 3,
-
OBJECT_EMPTY = 0,
OBJECT_EXTERNAL_RESOURCE = 1,
OBJECT_INTERNAL_RESOURCE = 2,
@@ -193,7 +188,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
r_v = v;
} break;
- case VARIANT_AABB: {
+ case VARIANT_RECT3: {
Rect3 v;
v.pos.x = f->get_real();
@@ -259,74 +254,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
r_v = v;
} break;
- case VARIANT_IMAGE: {
-
- uint32_t encoding = f->get_32();
- if (encoding == IMAGE_ENCODING_EMPTY) {
- r_v = Variant();
- break;
- } else if (encoding == IMAGE_ENCODING_RAW) {
- uint32_t width = f->get_32();
- uint32_t height = f->get_32();
- uint32_t mipmaps = f->get_32();
- uint32_t format = f->get_32();
- const uint32_t format_version_shift = 24;
- const uint32_t format_version_mask = format_version_shift - 1;
-
- uint32_t format_version = format >> format_version_shift;
-
- const uint32_t current_version = 0;
- if (format_version > current_version) {
-
- ERR_PRINT("Format version for encoded binary image is too new");
- return ERR_PARSE_ERROR;
- }
-
- Image::Format fmt = Image::Format(format & format_version_mask); //if format changes, we can add a compatibility bit on top
-
- uint32_t datalen = f->get_32();
- print_line("image format: " + String(Image::get_format_name(fmt)) + " datalen " + itos(datalen));
-
- PoolVector<uint8_t> imgdata;
- imgdata.resize(datalen);
- PoolVector<uint8_t>::Write w = imgdata.write();
- f->get_buffer(w.ptr(), datalen);
- _advance_padding(datalen);
- w = PoolVector<uint8_t>::Write();
-
-#ifdef TOOLS_ENABLED
- //compatibility
- int correct_size = Image::get_image_data_size(width, height, fmt, mipmaps ? -1 : 0);
- if (correct_size < datalen) {
- WARN_PRINT("Image data was too large, shrinking for compatibility")
- imgdata.resize(correct_size);
- }
-#endif
- r_v = Image(width, height, mipmaps, fmt, imgdata);
-
- } else {
- //compressed
- PoolVector<uint8_t> data;
- data.resize(f->get_32());
- PoolVector<uint8_t>::Write w = data.write();
- f->get_buffer(w.ptr(), data.size());
- w = PoolVector<uint8_t>::Write();
-
- Image img;
-
- if (encoding == IMAGE_ENCODING_LOSSY && Image::lossy_unpacker) {
-
- img = Image::lossy_unpacker(data);
- } else if (encoding == IMAGE_ENCODING_LOSSLESS && Image::lossless_unpacker) {
-
- img = Image::lossless_unpacker(data);
- }
- _advance_padding(data.size());
-
- r_v = img;
- }
- } break;
case VARIANT_NODE_PATH: {
Vector<StringName> names;
@@ -1404,7 +1332,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant &p_property,
} break;
case Variant::RECT3: {
- f->store_32(VARIANT_AABB);
+ f->store_32(VARIANT_RECT3);
Rect3 val = p_property;
f->store_real(val.pos.x);
f->store_real(val.pos.y);
@@ -1469,67 +1397,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant &p_property,
f->store_real(val.a);
} break;
- case Variant::IMAGE: {
-
- f->store_32(VARIANT_IMAGE);
- Image val = p_property;
- if (val.empty()) {
- f->store_32(IMAGE_ENCODING_EMPTY);
- break;
- }
-
- int encoding = IMAGE_ENCODING_RAW;
- float quality = 0.7;
-
- if (!val.is_compressed()) {
- //can only compress uncompressed stuff
-
- if (p_hint.hint == PROPERTY_HINT_IMAGE_COMPRESS_LOSSY && Image::lossy_packer) {
- encoding = IMAGE_ENCODING_LOSSY;
- float qs = p_hint.hint_string.to_double();
- if (qs != 0.0)
- quality = qs;
-
- } else if (p_hint.hint == PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS && Image::lossless_packer) {
- encoding = IMAGE_ENCODING_LOSSLESS;
- }
- }
-
- f->store_32(encoding); //raw encoding
-
- if (encoding == IMAGE_ENCODING_RAW) {
-
- f->store_32(val.get_width());
- f->store_32(val.get_height());
- f->store_32(val.has_mipmaps());
- f->store_32(val.get_format()); //if format changes we can add a compatibility version bit
- int dlen = val.get_data().size();
- f->store_32(dlen);
- PoolVector<uint8_t>::Read r = val.get_data().read();
- f->store_buffer(r.ptr(), dlen);
- _pad_buffer(dlen);
- } else {
-
- PoolVector<uint8_t> data;
- if (encoding == IMAGE_ENCODING_LOSSY) {
- data = Image::lossy_packer(val, quality);
-
- } else if (encoding == IMAGE_ENCODING_LOSSLESS) {
- data = Image::lossless_packer(val);
- }
-
- int ds = data.size();
- f->store_32(ds);
- if (ds > 0) {
- PoolVector<uint8_t>::Read r = data.read();
- f->store_buffer(r.ptr(), ds);
-
- _pad_buffer(ds);
- }
- }
-
- } break;
case Variant::NODE_PATH: {
f->store_32(VARIANT_NODE_PATH);
NodePath np = p_property;
diff --git a/core/method_bind.h b/core/method_bind.h
index 749d8b4fda..5b8a458736 100644
--- a/core/method_bind.h
+++ b/core/method_bind.h
@@ -146,7 +146,7 @@ struct VariantCaster<const T &> {
// some helpers
VARIANT_ENUM_CAST(Vector3::Axis);
-VARIANT_ENUM_CAST(Image::Format);
+
VARIANT_ENUM_CAST(Error);
VARIANT_ENUM_CAST(wchar_t);
VARIANT_ENUM_CAST(Margin);
diff --git a/core/method_ptrcall.h b/core/method_ptrcall.h
index 8cb2903842..d3f6143638 100644
--- a/core/method_ptrcall.h
+++ b/core/method_ptrcall.h
@@ -103,7 +103,6 @@ MAKE_PTRARG(Rect3);
MAKE_PTRARG(Basis);
MAKE_PTRARG(Transform);
MAKE_PTRARG(Color);
-MAKE_PTRARG(Image);
MAKE_PTRARG(NodePath);
MAKE_PTRARG(RID);
MAKE_PTRARG(InputEvent);
diff --git a/core/os/os.cpp b/core/os/os.cpp
index e323e03829..8bee725813 100644
--- a/core/os/os.cpp
+++ b/core/os/os.cpp
@@ -389,7 +389,7 @@ void OS::_ensure_data_dir() {
memdelete(da);
}
-void OS::set_icon(const Image &p_icon) {
+void OS::set_icon(const Ref<Image> &p_icon) {
}
String OS::get_model_name() const {
diff --git a/core/os/os.h b/core/os/os.h
index ff2a24f40d..037ce436c1 100644
--- a/core/os/os.h
+++ b/core/os/os.h
@@ -31,6 +31,7 @@
#define OS_H
#include "engine.h"
+#include "image.h"
#include "list.h"
#include "os/main_loop.h"
#include "power.h"
@@ -357,7 +358,7 @@ public:
virtual void make_rendering_thread();
virtual void swap_buffers();
- virtual void set_icon(const Image &p_icon);
+ virtual void set_icon(const Ref<Image> &p_icon);
virtual int get_exit_code() const;
virtual void set_exit_code(int p_code);
diff --git a/core/packed_data_container.cpp b/core/packed_data_container.cpp
index addb0841f4..836bcb7287 100644
--- a/core/packed_data_container.cpp
+++ b/core/packed_data_container.cpp
@@ -237,7 +237,6 @@ uint32_t PackedDataContainer::_pack(const Variant &p_data, Vector<uint8_t> &tmpd
case Variant::RECT3:
case Variant::BASIS:
case Variant::TRANSFORM:
- case Variant::IMAGE:
case Variant::INPUT_EVENT:
case Variant::POOL_BYTE_ARRAY:
case Variant::POOL_INT_ARRAY:
diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp
index 4d12e42895..634751b0bb 100644
--- a/core/register_core_types.cpp
+++ b/core/register_core_types.cpp
@@ -108,6 +108,8 @@ void register_core_types() {
ClassDB::register_class<Reference>();
ClassDB::register_class<WeakRef>();
ClassDB::register_class<Resource>();
+ ClassDB::register_class<Image>();
+
ClassDB::register_class<FuncRef>();
ClassDB::register_virtual_class<StreamPeer>();
ClassDB::register_class<StreamPeerBuffer>();
diff --git a/core/resource.cpp b/core/resource.cpp
index aa070558f5..559d4c1201 100644
--- a/core/resource.cpp
+++ b/core/resource.cpp
@@ -185,7 +185,7 @@ Ref<Resource> Resource::duplicate_for_local_scene(Node *p_for_scene, Map<Ref<Res
return Ref<Resource>(r);
}
-Ref<Resource> Resource::duplicate(bool p_subresources) {
+Ref<Resource> Resource::duplicate(bool p_subresources) const {
List<PropertyInfo> plist;
get_property_list(&plist);
diff --git a/core/resource.h b/core/resource.h
index ab3404df8f..903edeff52 100644
--- a/core/resource.h
+++ b/core/resource.h
@@ -103,7 +103,7 @@ public:
void set_subindex(int p_sub_index);
int get_subindex() const;
- Ref<Resource> duplicate(bool p_subresources = false);
+ virtual Ref<Resource> duplicate(bool p_subresources = false) const;
Ref<Resource> duplicate_for_local_scene(Node *p_scene, Map<Ref<Resource>, Ref<Resource> > &remap_cache);
void set_local_to_scene(bool p_enable);
diff --git a/core/ring_buffer.h b/core/ring_buffer.h
index d5085e9560..8b32bb5e10 100644
--- a/core/ring_buffer.h
+++ b/core/ring_buffer.h
@@ -101,6 +101,32 @@ public:
return p_size;
};
+ int find(const T &t, int p_offset, int p_max_size) {
+
+ int left = data_left();
+ if ((p_offset + p_max_size) > left) {
+ p_max_size -= left - p_offset;
+ if (p_max_size <= 0)
+ return 0;
+ }
+ p_max_size = MIN(left, p_max_size);
+ int pos = read_pos;
+ inc(pos, p_offset);
+ int to_read = p_max_size;
+ while (to_read) {
+ int end = pos + to_read;
+ end = MIN(end, size());
+ int total = end - pos;
+ for (int i = 0; i < total; i++) {
+ if (data[pos + i] == t)
+ return i + (p_max_size - to_read);
+ };
+ to_read -= total;
+ pos = 0;
+ }
+ return -1;
+ }
+
inline int advance_read(int p_n) {
p_n = MIN(p_n, data_left());
inc(read_pos, p_n);
diff --git a/core/script_debugger_remote.cpp b/core/script_debugger_remote.cpp
index bd0352b7a4..f230a4bc95 100644
--- a/core/script_debugger_remote.cpp
+++ b/core/script_debugger_remote.cpp
@@ -586,9 +586,7 @@ void ScriptDebuggerRemote::_send_object_id(ObjectID p_id) {
packet_peer_stream->put_var(E->get().hint);
packet_peer_stream->put_var(E->get().hint_string);
//only send information that can be sent..
- if (var.get_type() == Variant::IMAGE) {
- var = Image();
- }
+
if (var.get_type() >= Variant::DICTIONARY) {
var = Array(); //send none for now, may be to big
}
diff --git a/core/variant.cpp b/core/variant.cpp
index 67ce8af483..9c05dbaca0 100644
--- a/core/variant.cpp
+++ b/core/variant.cpp
@@ -120,11 +120,6 @@ String Variant::get_type_name(Variant::Type p_type) {
return "Color";
} break;
- case IMAGE: {
-
- return "Image";
-
- } break;
case _RID: {
return "RID";
@@ -249,7 +244,6 @@ bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) {
static const Type invalid[] = {
OBJECT,
- IMAGE,
NIL
};
@@ -791,11 +785,6 @@ bool Variant::is_zero() const {
return *reinterpret_cast<const Color *>(_data._mem) == Color();
} break;
- case IMAGE: {
-
- return _data._image->empty();
-
- } break;
case _RID: {
return *reinterpret_cast<const RID *>(_data._mem) == RID();
@@ -1016,11 +1005,6 @@ void Variant::reference(const Variant &p_variant) {
memnew_placement(_data._mem, Color(*reinterpret_cast<const Color *>(p_variant._data._mem)));
} break;
- case IMAGE: {
-
- _data._image = memnew(Image(*p_variant._data._image));
-
- } break;
case _RID: {
memnew_placement(_data._mem, RID(*reinterpret_cast<const RID *>(p_variant._data._mem)));
@@ -1141,11 +1125,6 @@ void Variant::clear() {
} break;
// misc types
- case IMAGE: {
-
- memdelete(_data._image);
-
- } break;
case NODE_PATH: {
reinterpret_cast<NodePath *>(_data._mem)->~NodePath();
@@ -1760,13 +1739,6 @@ Variant::operator Color() const {
else
return Color();
}
-Variant::operator Image() const {
-
- if (type == IMAGE)
- return *_data._image;
- else
- return Image();
-}
Variant::operator NodePath() const {
@@ -2306,11 +2278,6 @@ Variant::Variant(const Color &p_color) {
type = COLOR;
memnew_placement(_data._mem, Color(p_color));
}
-Variant::Variant(const Image &p_image) {
-
- type = IMAGE;
- _data._image = memnew(Image(p_image));
-}
Variant::Variant(const NodePath &p_node_path) {
@@ -2711,11 +2678,6 @@ uint32_t Variant::hash() const {
return hash_djb2_one_float(reinterpret_cast<const Color *>(_data._mem)->a, hash);
} break;
- case IMAGE: {
-
- return 0;
-
- } break;
case _RID: {
return hash_djb2_one_64(reinterpret_cast<const RID *>(_data._mem)->get_id());
diff --git a/core/variant.h b/core/variant.h
index e1a2b89a07..76097dfbdd 100644
--- a/core/variant.h
+++ b/core/variant.h
@@ -39,7 +39,6 @@
#include "dictionary.h"
#include "dvector.h"
#include "face3.h"
-#include "image.h"
#include "io/ip_address.h"
#include "math_2d.h"
#include "matrix3.h"
@@ -92,26 +91,25 @@ public:
TRANSFORM2D,
PLANE,
QUAT, // 10
- RECT3, //sorry naming convention fail :( not like it's used often
+ RECT3,
BASIS,
TRANSFORM,
// misc types
COLOR,
- IMAGE, // 15
- NODE_PATH,
+ NODE_PATH, // 15
_RID,
OBJECT,
INPUT_EVENT,
- DICTIONARY, // 20
- ARRAY,
+ DICTIONARY,
+ ARRAY, // 20
// arrays
POOL_BYTE_ARRAY,
POOL_INT_ARRAY,
POOL_REAL_ARRAY,
- POOL_STRING_ARRAY, // 25
- POOL_VECTOR2_ARRAY,
+ POOL_STRING_ARRAY,
+ POOL_VECTOR2_ARRAY, // 25
POOL_VECTOR3_ARRAY,
POOL_COLOR_ARRAY,
@@ -146,7 +144,6 @@ private:
Transform *_transform;
RefPtr *_resource;
InputEvent *_input_event;
- Image *_image;
void *_ptr; //generic pointer
uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)];
} _data;
@@ -207,7 +204,6 @@ public:
operator Transform2D() const;
operator Color() const;
- operator Image() const;
operator NodePath() const;
operator RefPtr() const;
operator RID() const;
@@ -276,7 +272,6 @@ public:
Variant(const Transform2D &p_transform);
Variant(const Transform &p_transform);
Variant(const Color &p_color);
- Variant(const Image &p_image);
Variant(const NodePath &p_path);
Variant(const RefPtr &p_resource);
Variant(const RID &p_rid);
diff --git a/core/variant_call.cpp b/core/variant_call.cpp
index beaee188eb..8bc9f085ad 100644
--- a/core/variant_call.cpp
+++ b/core/variant_call.cpp
@@ -37,9 +37,6 @@
typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args);
typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args);
-VARIANT_ENUM_CAST(Image::CompressMode);
-//VARIANT_ENUM_CAST(Image::Format);
-
struct _VariantCall {
static void Vector3_dot(Variant &r_ret, Variant &p_self, const Variant **p_args) {
@@ -614,22 +611,6 @@ struct _VariantCall {
#define VCALL_PTR5R(m_type, m_method) \
static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3], *p_args[4]); }
- VCALL_PTR0R(Image, get_format);
- VCALL_PTR0R(Image, get_width);
- VCALL_PTR0R(Image, get_height);
- VCALL_PTR0R(Image, empty);
- VCALL_PTR0R(Image, get_used_rect);
- VCALL_PTR1R(Image, load);
- VCALL_PTR1R(Image, save_png);
- VCALL_PTR1R(Image, get_rect);
- VCALL_PTR1R(Image, compressed);
- VCALL_PTR0R(Image, decompressed);
- VCALL_PTR3R(Image, resized);
- VCALL_PTR0R(Image, get_data);
- VCALL_PTR3(Image, blit_rect);
- VCALL_PTR1R(Image, converted);
- VCALL_PTR0(Image, fix_alpha_edges);
-
VCALL_PTR0R(Rect3, get_area);
VCALL_PTR0R(Rect3, has_no_area);
VCALL_PTR0R(Rect3, has_no_surface);
@@ -901,11 +882,6 @@ struct _VariantCall {
r_ret = Transform(p_args[0]->operator Basis(), p_args[1]->operator Vector3());
}
- static void Image_init1(Variant &r_ret, const Variant **p_args) {
-
- r_ret = Image(*p_args[0], *p_args[1], *p_args[2], Image::Format(p_args[3]->operator int()));
- }
-
static void add_constructor(VariantConstructFunc p_func, const Variant::Type p_type,
const String &p_name1 = "", const Variant::Type p_type1 = Variant::NIL,
const String &p_name2 = "", const Variant::Type p_type2 = Variant::NIL,
@@ -1056,7 +1032,6 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i
// misc types
case COLOR: return Color();
- case IMAGE: return Image();
case NODE_PATH:
return NodePath(); // 15
case _RID: return RID();
@@ -1138,7 +1113,6 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i
// misc types
case COLOR: return p_args[0]->type == Variant::STRING ? Color::html(*p_args[0]) : Color::hex(*p_args[0]);
- case IMAGE: return (Image(*p_args[0]));
case NODE_PATH:
return (NodePath(p_args[0]->operator NodePath())); // 15
case _RID: return (RID(*p_args[0]));
@@ -1527,22 +1501,6 @@ void register_variant_methods() {
ADDFUNC1(COLOR, COLOR, Color, blend, COLOR, "over", varray());
ADDFUNC1(COLOR, STRING, Color, to_html, BOOL, "with_alpha", varray(true));
- ADDFUNC0(IMAGE, INT, Image, get_format, varray());
- ADDFUNC0(IMAGE, INT, Image, get_width, varray());
- ADDFUNC0(IMAGE, INT, Image, get_height, varray());
- ADDFUNC0(IMAGE, BOOL, Image, empty, varray());
- ADDFUNC1(IMAGE, INT, Image, load, STRING, "path", varray(0));
- ADDFUNC1(IMAGE, INT, Image, save_png, STRING, "path", varray(0));
- ADDFUNC0(IMAGE, RECT2, Image, get_used_rect, varray(0));
- ADDFUNC1(IMAGE, IMAGE, Image, get_rect, RECT2, "area", varray(0));
- ADDFUNC1(IMAGE, IMAGE, Image, compressed, INT, "format", varray(0));
- ADDFUNC0(IMAGE, IMAGE, Image, decompressed, varray(0));
- ADDFUNC3(IMAGE, IMAGE, Image, resized, INT, "x", INT, "y", INT, "interpolation", varray(((int)Image::INTERPOLATE_BILINEAR)));
- ADDFUNC0(IMAGE, POOL_BYTE_ARRAY, Image, get_data, varray());
- ADDFUNC3(IMAGE, NIL, Image, blit_rect, IMAGE, "src", RECT2, "src_rect", VECTOR2, "dest", varray(0));
- ADDFUNC1(IMAGE, IMAGE, Image, converted, INT, "format", varray(0));
- ADDFUNC0(IMAGE, NIL, Image, fix_alpha_edges, varray());
-
ADDFUNC0(_RID, INT, RID, get_id, varray());
ADDFUNC0(NODE_PATH, BOOL, NodePath, is_absolute, varray());
@@ -1771,8 +1729,6 @@ void register_variant_methods() {
_VariantCall::add_constructor(_VariantCall::Transform_init1, Variant::TRANSFORM, "x_axis", Variant::VECTOR3, "y_axis", Variant::VECTOR3, "z_axis", Variant::VECTOR3, "origin", Variant::VECTOR3);
_VariantCall::add_constructor(_VariantCall::Transform_init2, Variant::TRANSFORM, "basis", Variant::BASIS, "origin", Variant::VECTOR3);
- _VariantCall::add_constructor(_VariantCall::Image_init1, Variant::IMAGE, "width", Variant::INT, "height", Variant::INT, "mipmaps", Variant::BOOL, "format", Variant::INT);
-
/* REGISTER CONSTANTS */
_VariantCall::add_constant(Variant::VECTOR3, "AXIS_X", Vector3::AXIS_X);
@@ -1788,56 +1744,6 @@ void register_variant_methods() {
_VariantCall::add_constant(Variant::INPUT_EVENT, "SCREEN_TOUCH", InputEvent::SCREEN_TOUCH);
_VariantCall::add_constant(Variant::INPUT_EVENT, "SCREEN_DRAG", InputEvent::SCREEN_DRAG);
_VariantCall::add_constant(Variant::INPUT_EVENT, "ACTION", InputEvent::ACTION);
-
- _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_16BIT", Image::COMPRESS_16BIT);
- _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_S3TC", Image::COMPRESS_S3TC);
- _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_PVRTC2", Image::COMPRESS_PVRTC2);
- _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_PVRTC4", Image::COMPRESS_PVRTC4);
- _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_ETC", Image::COMPRESS_ETC);
- _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_ETC2", Image::COMPRESS_ETC2);
-
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_L8", Image::FORMAT_L8);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_LA8", Image::FORMAT_LA8);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_R8", Image::FORMAT_R8);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RG8", Image::FORMAT_RG8);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGB8", Image::FORMAT_RGB8);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBA8", Image::FORMAT_RGBA8);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGB565", Image::FORMAT_RGB565);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBA4444", Image::FORMAT_RGBA4444);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBA5551", Image::FORMAT_DXT1);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RF", Image::FORMAT_RF);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGF", Image::FORMAT_RGF);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBF", Image::FORMAT_RGBF);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBAF", Image::FORMAT_RGBAF);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RH", Image::FORMAT_RH);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGH", Image::FORMAT_RGH);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBH", Image::FORMAT_RGBH);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBAH", Image::FORMAT_RGBAH);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_DXT1", Image::FORMAT_DXT1);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_DXT3", Image::FORMAT_DXT3);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_DXT5", Image::FORMAT_DXT5);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ATI1", Image::FORMAT_ATI1);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ATI2", Image::FORMAT_ATI2);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BPTC_RGBA", Image::FORMAT_BPTC_RGBA);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BPTC_RGBF", Image::FORMAT_BPTC_RGBF);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BPTC_RGBFU", Image::FORMAT_BPTC_RGBFU);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC2", Image::FORMAT_PVRTC2);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC2A", Image::FORMAT_PVRTC2A);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC4", Image::FORMAT_PVRTC4);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC4A", Image::FORMAT_PVRTC4A);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC", Image::FORMAT_ETC);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_R11", Image::FORMAT_ETC2_R11);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_R11S", Image::FORMAT_ETC2_R11S);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RG11", Image::FORMAT_ETC2_RG11);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RG11S", Image::FORMAT_ETC2_RG11S);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RGB8", Image::FORMAT_ETC2_RGB8);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RGBA8", Image::FORMAT_ETC2_RGBA8);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC2_RGB8A1", Image::FORMAT_ETC2_RGB8A1);
- _VariantCall::add_constant(Variant::IMAGE, "FORMAT_MAX", Image::FORMAT_MAX);
-
- _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_NEAREST", Image::INTERPOLATE_NEAREST);
- _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_BILINEAR", Image::INTERPOLATE_BILINEAR);
- _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_CUBIC", Image::INTERPOLATE_CUBIC);
}
void unregister_variant_methods() {
diff --git a/core/variant_op.cpp b/core/variant_op.cpp
index e8274d10af..8bae6a168b 100644
--- a/core/variant_op.cpp
+++ b/core/variant_op.cpp
@@ -58,7 +58,6 @@ bool Variant::booleanize(bool &r_valid) const {
case BASIS:
case TRANSFORM:
case COLOR:
- case IMAGE: r_valid = false; return false;
case _RID: return (*reinterpret_cast<const RID *>(_data._mem)).is_valid();
case OBJECT: return _get_obj().obj;
case NODE_PATH: return (*reinterpret_cast<const NodePath *>(_data._mem)) != NodePath();
@@ -283,7 +282,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
DEFAULT_OP_PTRREF(==, TRANSFORM, _transform);
DEFAULT_OP_LOCALMEM(==, COLOR, Color);
- DEFAULT_OP_PTRREF(==, IMAGE, _image);
DEFAULT_OP_STR(==, NODE_PATH, NodePath);
DEFAULT_OP_LOCALMEM(==, _RID, RID);
case OBJECT: {
@@ -372,7 +370,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
- DEFAULT_OP_FAIL(IMAGE);
+
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_LOCALMEM(<, _RID, RID);
case OBJECT: {
@@ -437,7 +435,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
- DEFAULT_OP_FAIL(IMAGE);
+
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_LOCALMEM(<=, _RID, RID);
case OBJECT: {
@@ -500,7 +498,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
- DEFAULT_OP_FAIL(IMAGE);
+
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
@@ -557,7 +555,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
- DEFAULT_OP_FAIL(IMAGE);
+
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
@@ -654,7 +652,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
return;
} break;
DEFAULT_OP_FAIL(COLOR);
- DEFAULT_OP_FAIL(IMAGE);
+
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
@@ -727,7 +725,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
- DEFAULT_OP_FAIL(IMAGE);
+
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
@@ -769,7 +767,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
DEFAULT_OP_LOCALMEM_POS(VECTOR2, Vector2);
DEFAULT_OP_FAIL(COLOR);
- DEFAULT_OP_FAIL(IMAGE);
+
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
@@ -809,7 +807,7 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant &
DEFAULT_OP_FAIL(TRANSFORM);
DEFAULT_OP_FAIL(COLOR);
- DEFAULT_OP_FAIL(IMAGE);
+
DEFAULT_OP_FAIL(NODE_PATH);
DEFAULT_OP_FAIL(_RID);
DEFAULT_OP_FAIL(OBJECT);
@@ -1305,7 +1303,7 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
}
}
- } break;
+ } break; // 10
case RECT3: {
if (p_value.type != Variant::VECTOR3)
@@ -1330,7 +1328,7 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
return;
}
}
- } break; //sorry naming convention fail :( not like it's used often // 10
+ } break;
case BASIS: {
if (p_value.type != Variant::VECTOR3)
@@ -1480,8 +1478,6 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
}
} break;
- case IMAGE: {
- } break;
case NODE_PATH: {
} break; // 15
case _RID: {
@@ -1900,13 +1896,13 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
dic->operator[](p_index) = p_value;
valid = true; //always valid, i guess? should this really be ok?
return;
- } break; // 20
- DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index] = p_value; return )
+ } break;
+ DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index] = p_value; return ) // 20
DEFAULT_OP_DVECTOR_SET(POOL_BYTE_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT)
DEFAULT_OP_DVECTOR_SET(POOL_INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT)
DEFAULT_OP_DVECTOR_SET(POOL_REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT)
- DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING) // 25
- DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2)
+ DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING)
+ DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) // 25
DEFAULT_OP_DVECTOR_SET(POOL_VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3)
DEFAULT_OP_DVECTOR_SET(POOL_COLOR_ARRAY, Color, p_value.type != Variant::COLOR)
default: return;
@@ -2107,7 +2103,7 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
}
}
- } break;
+ } break; // 10
case RECT3: {
if (p_index.get_type() == Variant::STRING) {
@@ -2126,7 +2122,7 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
return v->size + v->pos;
}
}
- } break; //sorry naming convention fail :( not like it's used often // 10
+ } break;
case BASIS: {
if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
@@ -2239,8 +2235,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
}
} break;
- case IMAGE: {
- } break;
case NODE_PATH: {
} break; // 15
case _RID: {
@@ -2504,13 +2498,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
valid = true;
return *res;
}
- } break; // 20
- DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index])
+ } break;
+ DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index]) // 20
DEFAULT_OP_DVECTOR_GET(POOL_BYTE_ARRAY, uint8_t)
DEFAULT_OP_DVECTOR_GET(POOL_INT_ARRAY, int)
DEFAULT_OP_DVECTOR_GET(POOL_REAL_ARRAY, real_t)
DEFAULT_OP_DVECTOR_GET(POOL_STRING_ARRAY, String)
- DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2_ARRAY, Vector2)
+ DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2_ARRAY, Vector2) // 25
DEFAULT_OP_DVECTOR_GET(POOL_VECTOR3_ARRAY, Vector3)
DEFAULT_OP_DVECTOR_GET(POOL_COLOR_ARRAY, Color)
default: return Variant();
@@ -2774,12 +2768,12 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::REAL, "z"));
p_list->push_back(PropertyInfo(Variant::REAL, "w"));
- } break;
+ } break; // 10
case RECT3: {
p_list->push_back(PropertyInfo(Variant::VECTOR3, "pos"));
p_list->push_back(PropertyInfo(Variant::VECTOR3, "size"));
p_list->push_back(PropertyInfo(Variant::VECTOR3, "end"));
- } break; //sorry naming convention fail :( not like it's used often // 10
+ } break;
case BASIS: {
p_list->push_back(PropertyInfo(Variant::VECTOR3, "x"));
@@ -2807,8 +2801,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::INT, "a8"));
} break;
- case IMAGE: {
- } break;
case NODE_PATH: {
} break; // 15
case _RID: {
@@ -2929,12 +2921,13 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::STRING, E->get()));
}
}
- } break; // 20
- case ARRAY:
+ } break;
+ case ARRAY: // 20
case POOL_BYTE_ARRAY:
case POOL_INT_ARRAY:
case POOL_REAL_ARRAY:
case POOL_STRING_ARRAY:
+ case POOL_VECTOR2_ARRAY: // 25
case POOL_VECTOR3_ARRAY:
case POOL_COLOR_ARRAY: {
@@ -3631,10 +3624,6 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
r_dst = reinterpret_cast<const Color *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Color *>(b._data._mem), c);
}
return;
- case IMAGE: {
- r_dst = a;
- }
- return;
case NODE_PATH: {
r_dst = a;
}
diff --git a/core/variant_parser.cpp b/core/variant_parser.cpp
index 234156d39f..798a830dd0 100644
--- a/core/variant_parser.cpp
+++ b/core/variant_parser.cpp
@@ -504,39 +504,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
return OK;
} else if (token.type == TK_IDENTIFIER) {
- /*
- VECTOR2, // 5
- RECT2,
- VECTOR3,
- MATRIX32,
- PLANE,
- QUAT, // 10
- _AABB, //sorry naming convention fail :( not like it's used often
- MATRIX3,
- TRANSFORM,
- // misc types
- COLOR,
- IMAGE, // 15
- NODE_PATH,
- _RID,
- OBJECT,
- INPUT_EVENT,
- DICTIONARY, // 20
- ARRAY,
-
- // arrays
- RAW_ARRAY,
- INT_ARRAY,
- REAL_ARRAY,
- STRING_ARRAY, // 25
- VECTOR2_ARRAY,
- VECTOR3_ARRAY,
- COLOR_ARRAY,
-
- VARIANT_MAX
-
-*/
String id = token.value;
if (id == "true")
value = true;
@@ -681,126 +649,6 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
value = Color(args[0], args[1], args[2], args[3]);
return OK;
- } else if (id == "Image") {
-
- //:|
-
- get_token(p_stream, token, line, r_err_str);
- if (token.type != TK_PARENTHESIS_OPEN) {
- r_err_str = "Expected '('";
- return ERR_PARSE_ERROR;
- }
-
- get_token(p_stream, token, line, r_err_str);
- if (token.type == TK_PARENTHESIS_CLOSE) {
- value = Image(); // just an Image()
- return OK;
- } else if (token.type != TK_NUMBER) {
- r_err_str = "Expected number (width)";
- return ERR_PARSE_ERROR;
- }
-
- get_token(p_stream, token, line, r_err_str);
-
- int width = token.value;
- if (token.type != TK_COMMA) {
- r_err_str = "Expected ','";
- return ERR_PARSE_ERROR;
- }
-
- get_token(p_stream, token, line, r_err_str);
- if (token.type != TK_NUMBER) {
- r_err_str = "Expected number (height)";
- return ERR_PARSE_ERROR;
- }
-
- int height = token.value;
-
- get_token(p_stream, token, line, r_err_str);
- if (token.type != TK_COMMA) {
- r_err_str = "Expected ','";
- return ERR_PARSE_ERROR;
- }
-
- get_token(p_stream, token, line, r_err_str);
-
- bool has_mipmaps = false;
-
- if (token.type == TK_NUMBER) {
- has_mipmaps = bool(token.value);
- } else if (token.type == TK_IDENTIFIER && String(token.value) == "true") {
- has_mipmaps = true;
- } else if (token.type == TK_IDENTIFIER && String(token.value) == "false") {
- has_mipmaps = false;
- } else {
- r_err_str = "Expected number/true/false (mipmaps)";
- return ERR_PARSE_ERROR;
- }
-
- int mipmaps = token.value;
-
- get_token(p_stream, token, line, r_err_str);
- if (token.type != TK_COMMA) {
- r_err_str = "Expected ','";
- return ERR_PARSE_ERROR;
- }
-
- get_token(p_stream, token, line, r_err_str);
- if (token.type != TK_IDENTIFIER) {
- r_err_str = "Expected identifier (format)";
- return ERR_PARSE_ERROR;
- }
-
- String sformat = token.value;
-
- Image::Format format = Image::FORMAT_MAX;
-
- for (int i = 0; i < Image::FORMAT_MAX; i++) {
- if (Image::get_format_name(Image::Format(i)) == sformat) {
- format = Image::Format(i);
- }
- }
-
- if (format == Image::FORMAT_MAX) {
- r_err_str = "Unknown image format: " + String(sformat);
- return ERR_PARSE_ERROR;
- }
-
- int len = Image::get_image_data_size(width, height, format, mipmaps);
-
- PoolVector<uint8_t> buffer;
- buffer.resize(len);
-
- if (buffer.size() != len) {
- r_err_str = "Couldn't allocate image buffer of size: " + itos(len);
- }
-
- {
- PoolVector<uint8_t>::Write w = buffer.write();
-
- for (int i = 0; i < len; i++) {
- get_token(p_stream, token, line, r_err_str);
- if (token.type != TK_COMMA) {
- r_err_str = "Expected ','";
- return ERR_PARSE_ERROR;
- }
-
- get_token(p_stream, token, line, r_err_str);
- if (token.type != TK_NUMBER) {
- r_err_str = "Expected number";
- return ERR_PARSE_ERROR;
- }
-
- w[i] = int(token.value);
- }
- }
-
- Image img(width, height, mipmaps, format, buffer);
-
- value = img;
-
- return OK;
-
} else if (id == "NodePath") {
get_token(p_stream, token, line, r_err_str);
@@ -1357,68 +1205,12 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
value = ie;
return OK;
- } else if (id == "img") { // compatibility with project.godot
-
- Token token; // FIXME: no need for this declaration? the first argument in line 509 is a Token& token.
- get_token(p_stream, token, line, r_err_str);
- if (token.type != TK_PARENTHESIS_OPEN) {
- r_err_str = "Expected '(' in old-style project.godot construct";
- return ERR_PARSE_ERROR;
- }
-
- while (true) {
- CharType c = p_stream->get_char();
- if (p_stream->is_eof()) {
- r_err_str = "Unexpected EOF in old style project.godot img()";
- return ERR_PARSE_ERROR;
- }
- if (c == ')')
- break;
- }
-
- value = Image();
-
- return OK;
} else {
r_err_str = "Unexpected identifier: '" + id + "'.";
return ERR_PARSE_ERROR;
}
- /*
- VECTOR2, // 5
- RECT2,
- VECTOR3,
- MATRIX32,
- PLANE,
- QUAT, // 10
- _AABB, //sorry naming convention fail :( not like it's used often
- MATRIX3,
- TRANSFORM,
-
- // misc types
- COLOR,
- IMAGE, // 15
- NODE_PATH,
- _RID,
- OBJECT,
- INPUT_EVENT,
- DICTIONARY, // 20
- ARRAY,
-
- // arrays
- RAW_ARRAY,
- INT_ARRAY,
- REAL_ARRAY,
- STRING_ARRAY, // 25
- VECTOR2_ARRAY,
- VECTOR3_ARRAY,
- COLOR_ARRAY,
-
- VARIANT_MAX
-
- */
-
return OK;
} else if (token.type == TK_NUMBER) {
@@ -1886,39 +1678,6 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str
p_store_string_func(p_store_string_ud, "Color( " + rtosfix(c.r) + ", " + rtosfix(c.g) + ", " + rtosfix(c.b) + ", " + rtosfix(c.a) + " )");
} break;
- case Variant::IMAGE: {
-
- Image img = p_variant;
-
- if (img.empty()) {
- p_store_string_func(p_store_string_ud, "Image()");
- break;
- }
-
- String imgstr = "Image( ";
- imgstr += itos(img.get_width());
- imgstr += ", " + itos(img.get_height());
- imgstr += ", " + String(img.has_mipmaps() ? "true" : "false");
- imgstr += ", " + Image::get_format_name(img.get_format());
-
- String s;
-
- PoolVector<uint8_t> data = img.get_data();
- int len = data.size();
- PoolVector<uint8_t>::Read r = data.read();
- const uint8_t *ptr = r.ptr();
- for (int i = 0; i < len; i++) {
-
- if (i > 0)
- s += ", ";
- s += itos(ptr[i]);
- }
-
- imgstr += ", ";
- p_store_string_func(p_store_string_ud, imgstr);
- p_store_string_func(p_store_string_ud, s);
- p_store_string_func(p_store_string_ud, " )");
- } break;
case Variant::NODE_PATH: {
String str = p_variant;
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-19 23:08:41 +0000