asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removal of Image from Variant, converted to a Resource.

Browse source
This commit is contained in:
Juan Linietsky 2017-05-17 07:36:47 -03:00
parent d801ff2b3d
commit 98a3296702
110 changed files with 690 additions and 3203 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/bind/core_bind.cpp
View file

@ -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);
}

3
core/bind/core_bind.h
View file

@ -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);

1
core/global_constants.cpp
View file

@ -510,7 +510,6 @@ static _GlobalConstant _global_constants[] = {
{ "TYPE_BASIS", Variant::BASIS },
{ "TYPE_TRANSFORM", Variant::TRANSFORM },
{ "TYPE_COLOR", Variant::COLOR },
{ "TYPE_IMAGE", Variant::IMAGE }, // 15
{ "TYPE_NODE_PATH", Variant::NODE_PATH },
{ "TYPE_RID", Variant::_RID },
{ "TYPE_OBJECT", Variant::OBJECT },

230
core/image.cpp
View file

@ -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_to_po2, 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;

75
core/image.h
View file

@ -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

3
core/io/image_loader.cpp
View file

@ -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) {

4
core/io/image_loader.h
View file

@ -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);

56
core/io/marshalls.cpp
View file

@ -275,38 +275,6 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
if (r_len)
(*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: {
@ -1077,30 +1045,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: {

134
core/io/resource_format_binary.cpp
View file

@ -54,7 +54,7 @@ enum {
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,
@ -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;
@ -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;

2
core/method_bind.h
View file

@ -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);

1
core/method_ptrcall.h
View file

@ -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);

2
core/os/os.cpp
View file

@ -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 {

3
core/os/os.h
View file

@ -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);

1
core/packed_data_container.cpp
View file

@ -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:

2
core/register_core_types.cpp
View file

@ -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>();

2
core/resource.cpp
View file

@ -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);

2
core/resource.h
View file

@ -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);

4
core/script_debugger_remote.cpp
View file

@ -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
}

38
core/variant.cpp
View file

@ -119,11 +119,6 @@ String Variant::get_type_name(Variant::Type p_type) {
return "Color";
} break;
case IMAGE: {
return "Image";
} break;
case _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
};
@ -790,11 +784,6 @@ bool Variant::is_zero() const {
return *reinterpret_cast<const Color *>(_data._mem) == Color();
} break;
case IMAGE: {
return _data._image->empty();
} break;
case _RID: {
@ -1015,11 +1004,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: {
@ -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) {
@ -2710,11 +2677,6 @@ uint32_t Variant::hash() const {
hash = hash_djb2_one_float(reinterpret_cast<const Color *>(_data._mem)->b, hash);
return hash_djb2_one_float(reinterpret_cast<const Color *>(_data._mem)->a, hash);
} break;
case IMAGE: {
return 0;
} break;
case _RID: {

13
core/variant.h
View file

@ -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"
@ -98,20 +97,19 @@ public:
// misc types
COLOR,
IMAGE, // 15
NODE_PATH,
_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);

94
core/variant_call.cpp
View file

@ -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() {

28
core/variant_op.cpp
View file

@ -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);
@ -1479,8 +1477,6 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
}
}
} break;
case IMAGE: {
} break;
case NODE_PATH: {
} break; // 15
@ -2238,8 +2234,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
}
}
} break;
case IMAGE: {
} break;
case NODE_PATH: {
} break; // 15
@ -2806,8 +2800,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::INT, "b8"));
p_list->push_back(PropertyInfo(Variant::INT, "a8"));
} break;
case IMAGE: {
} break;
case NODE_PATH: {
} break; // 15
@ -3631,10 +3623,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;
}

175
core/variant_parser.cpp
View file

@ -681,126 +681,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);
@ -1356,28 +1236,6 @@ 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 {
@ -1886,39 +1744,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;

4
drivers/gles2/rasterizer_gles2.cpp
View file

@ -342,12 +342,12 @@ void RasterizerGLES2::_draw_primitive(int p_points, const Vector3 *p_vertices, c
/* TEXTURE API */
Image RasterizerGLES2::_get_gl_image_and_format(const Image &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, int &r_gl_components, bool &r_has_alpha_cache, bool &r_compressed) {
Ref<Image> RasterizerGLES2::_get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, int &r_gl_components, bool &r_has_alpha_cache, bool &r_compressed) {
r_has_alpha_cache = false;
r_compressed = false;
r_gl_format = 0;
Image image = p_image;
Ref<Image> image = p_image;
switch (p_format) {

8
drivers/gles3/rasterizer_gles3.cpp
View file

@ -271,9 +271,9 @@ void RasterizerGLES3::clear_render_target(const Color &p_color) {
storage->frame.clear_request_color = p_color;
}
void RasterizerGLES3::set_boot_image(const Image &p_image, const Color &p_color, bool p_scale) {
void RasterizerGLES3::set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale) {
if (p_image.empty())
if (p_image.is_null() || p_image->empty())
return;
begin_frame();
@ -290,10 +290,10 @@ void RasterizerGLES3::set_boot_image(const Image &p_image, const Color &p_color,
canvas->canvas_begin();
RID texture = storage->texture_create();
storage->texture_allocate(texture, p_image.get_width(), p_image.get_height(), p_image.get_format(), VS::TEXTURE_FLAG_FILTER);
storage->texture_allocate(texture, p_image->get_width(), p_image->get_height(), p_image->get_format(), VS::TEXTURE_FLAG_FILTER);
storage->texture_set_data(texture, p_image);
Rect2 imgrect(0, 0, p_image.get_width(), p_image.get_height());
Rect2 imgrect(0, 0, p_image->get_width(), p_image->get_height());
Rect2 screenrect;
if (p_scale) {

2
drivers/gles3/rasterizer_gles3.h
View file

@ -48,7 +48,7 @@ public:
virtual RasterizerCanvas *get_canvas();
virtual RasterizerScene *get_scene();
virtual void set_boot_image(const Image &p_image, const Color &p_color, bool p_scale);
virtual void set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale);
virtual void initialize();
virtual void begin_frame();

67
drivers/gles3/rasterizer_storage_gles3.cpp
View file

@ -101,11 +101,11 @@
GLuint RasterizerStorageGLES3::system_fbo = 0;
Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool &srgb) {
Ref<Image> RasterizerStorageGLES3::_get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool &srgb) {
r_compressed = false;
r_gl_format = 0;
Image image = p_image;
Ref<Image> image = p_image;
srgb = false;
bool need_decompress = false;
@ -538,16 +538,17 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image &p_image, Ima
} break;
default: {
ERR_FAIL_V(Image());
ERR_FAIL_V(Ref<Image>());
}
}
if (need_decompress) {
if (!image.empty()) {
image.decompress();
ERR_FAIL_COND_V(image.is_compressed(), image);
image.convert(Image::FORMAT_RGBA8);
if (!image.is_null()) {
image = image->duplicate();
image->decompress();
ERR_FAIL_COND_V(image->is_compressed(), image);
image->convert(Image::FORMAT_RGBA8);
}
r_gl_format = GL_RGBA;
@ -607,7 +608,7 @@ void RasterizerStorageGLES3::texture_allocate(RID p_texture, int p_width, int p_
texture->stored_cube_sides = 0;
texture->target = (p_flags & VS::TEXTURE_FLAG_CUBEMAP) ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D;
_get_gl_image_and_format(Image(), texture->format, texture->flags, format, internal_format, type, compressed, srgb);
_get_gl_image_and_format(Ref<Image>(), texture->format, texture->flags, format, internal_format, type, compressed, srgb);
texture->alloc_width = texture->width;
texture->alloc_height = texture->height;
@ -631,15 +632,15 @@ void RasterizerStorageGLES3::texture_allocate(RID p_texture, int p_width, int p_
texture->active = true;
}
void RasterizerStorageGLES3::texture_set_data(RID p_texture, const Image &p_image, VS::CubeMapSide p_cube_side) {
void RasterizerStorageGLES3::texture_set_data(RID p_texture, const Ref<Image> &p_image, VS::CubeMapSide p_cube_side) {
Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND(!texture);
ERR_FAIL_COND(!texture->active);
ERR_FAIL_COND(texture->render_target);
ERR_FAIL_COND(texture->format != p_image.get_format());
ERR_FAIL_COND(p_image.empty());
ERR_FAIL_COND(texture->format != p_image->get_format());
ERR_FAIL_COND(p_image.is_null());
GLenum type;
GLenum format;
@ -651,31 +652,31 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture, const Image &p_imag
texture->images[p_cube_side] = p_image;
}
Image img = _get_gl_image_and_format(p_image, p_image.get_format(), texture->flags, format, internal_format, type, compressed, srgb);
Ref<Image> img = _get_gl_image_and_format(p_image, p_image->get_format(), texture->flags, format, internal_format, type, compressed, srgb);
if (config.shrink_textures_x2 && (p_image.has_mipmaps() || !p_image.is_compressed()) && !(texture->flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
if (config.shrink_textures_x2 && (p_image->has_mipmaps() || !p_image->is_compressed()) && !(texture->flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
texture->alloc_height = MAX(1, texture->alloc_height / 2);
texture->alloc_width = MAX(1, texture->alloc_width / 2);
if (texture->alloc_width == img.get_width() / 2 && texture->alloc_height == img.get_height() / 2) {
if (texture->alloc_width == img->get_width() / 2 && texture->alloc_height == img->get_height() / 2) {
img.shrink_x2();
} else if (img.get_format() <= Image::FORMAT_RGB565) {
img->shrink_x2();
} else if (img->get_format() <= Image::FORMAT_RGB565) {
img.resize(texture->alloc_width, texture->alloc_height, Image::INTERPOLATE_BILINEAR);
img->resize(texture->alloc_width, texture->alloc_height, Image::INTERPOLATE_BILINEAR);
}
};
GLenum blit_target = (texture->target == GL_TEXTURE_CUBE_MAP) ? _cube_side_enum[p_cube_side] : GL_TEXTURE_2D;
texture->data_size = img.get_data().size();
PoolVector<uint8_t>::Read read = img.get_data().read();
texture->data_size = img->get_data().size();
PoolVector<uint8_t>::Read read = img->get_data().read();
glActiveTexture(GL_TEXTURE0);
glBindTexture(texture->target, texture->tex_id);
texture->ignore_mipmaps = compressed && !img.has_mipmaps();
texture->ignore_mipmaps = compressed && !img->has_mipmaps();
if (texture->flags & VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps)
glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, config.use_fast_texture_filter ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR);
@ -761,16 +762,16 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture, const Image &p_imag
}
}
int mipmaps = (texture->flags & VS::TEXTURE_FLAG_MIPMAPS && img.has_mipmaps()) ? img.get_mipmap_count() + 1 : 1;
int mipmaps = (texture->flags & VS::TEXTURE_FLAG_MIPMAPS && img->has_mipmaps()) ? img->get_mipmap_count() + 1 : 1;
int w = img.get_width();
int h = img.get_height();
int w = img->get_width();
int h = img->get_height();
int tsize = 0;
for (int i = 0; i < mipmaps; i++) {
int size, ofs;
img.get_mipmap_offset_and_size(i, ofs, size);
img->get_mipmap_offset_and_size(i, ofs, size);
//print_line("mipmap: "+itos(i)+" size: "+itos(size)+" w: "+itos(mm_w)+", h: "+itos(mm_h));
@ -813,16 +814,16 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture, const Image &p_imag
//texture_set_flags(p_texture,texture->flags);
}
Image RasterizerStorageGLES3::texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side) const {
Ref<Image> RasterizerStorageGLES3::texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side) const {
Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND_V(!texture, Image());
ERR_FAIL_COND_V(!texture->active, Image());
ERR_FAIL_COND_V(texture->data_size == 0, Image());
ERR_FAIL_COND_V(texture->render_target, Image());
ERR_FAIL_COND_V(!texture, Ref<Image>());
ERR_FAIL_COND_V(!texture->active, Ref<Image>());
ERR_FAIL_COND_V(texture->data_size == 0, Ref<Image>());
ERR_FAIL_COND_V(texture->render_target, Ref<Image>());
if (!texture->images[p_cube_side].empty()) {
if (!texture->images[p_cube_side].is_null()) {
return texture->images[p_cube_side];
}
@ -867,13 +868,13 @@ Image RasterizerStorageGLES3::texture_get_data(RID p_texture, VS::CubeMapSide p_
data.resize(data_size);
Image img(texture->alloc_width, texture->alloc_height, texture->mipmaps > 1 ? true : false, texture->format, data);
Image *img = memnew(Image(texture->alloc_width, texture->alloc_height, texture->mipmaps > 1 ? true : false, texture->format, data));
return img;
return Ref<Image>(img);
#else
ERR_EXPLAIN("Sorry, It's not posible to obtain images back in OpenGL ES");
return Image();
return Ref<Image>();
#endif
}

8
drivers/gles3/rasterizer_storage_gles3.h
View file

@ -240,7 +240,7 @@ public:
RenderTarget *render_target;
Image images[6];
Ref<Image> images[6];
VisualServer::TextureDetectCallback detect_3d;
void *detect_3d_ud;
@ -280,12 +280,12 @@ public:
mutable RID_Owner<Texture> texture_owner;
Image _get_gl_image_and_format(const Image &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_type, bool &r_compressed, bool &srgb);
Ref<Image> _get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_type, bool &r_compressed, bool &srgb);
virtual RID texture_create();
virtual void texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags = VS::TEXTURE_FLAGS_DEFAULT);
virtual void texture_set_data(RID p_texture, const Image &p_image, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT);
virtual Image texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT) const;
virtual void texture_set_data(RID p_texture, const Ref<Image> &p_image, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT);
virtual Ref<Image> texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT) const;
virtual void texture_set_flags(RID p_texture, uint32_t p_flags);
virtual uint32_t texture_get_flags(RID p_texture) const;
virtual Image::Format texture_get_format(RID p_texture) const;

42
drivers/png/image_loader_png.cpp
View file

@ -68,7 +68,7 @@ static void _png_warn_function(png_structp, png_const_charp text) {
typedef void(PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));
Error ImageLoaderPNG::_load_image(void *rf_up, png_rw_ptr p_func, Image *p_image) {
Error ImageLoaderPNG::_load_image(void *rf_up, png_rw_ptr p_func, Ref<Image> p_image) {
png_structp png;
png_infop info;
@ -201,7 +201,7 @@ Error ImageLoaderPNG::_load_image(void *rf_up, png_rw_ptr p_func, Image *p_image
return OK;
}
Error ImageLoaderPNG::load_image(Image *p_image, FileAccess *f) {
Error ImageLoaderPNG::load_image(Ref<Image> p_image, FileAccess *f) {
Error err = _load_image(f, _read_png_data, p_image);
f->close();
@ -238,25 +238,26 @@ static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t p_len
}
}
static Image _load_mem_png(const uint8_t *p_png, int p_size) {
static Ref<Image> _load_mem_png(const uint8_t *p_png, int p_size) {
PNGReadStatus prs;
prs.image = p_png;
prs.offset = 0;
prs.size = p_size;
Image img;
Error err = ImageLoaderPNG::_load_image(&prs, user_read_data, &img);
ERR_FAIL_COND_V(err, Image());
Ref<Image> img;
img.instance();
Error err = ImageLoaderPNG::_load_image(&prs, user_read_data, img);
ERR_FAIL_COND_V(err, Ref<Image>());
return img;
}
static Image _lossless_unpack_png(const PoolVector<uint8_t> &p_data) {
static Ref<Image> _lossless_unpack_png(const PoolVector<uint8_t> &p_data) {
int len = p_data.size();
PoolVector<uint8_t>::Read r = p_data.read();
ERR_FAIL_COND_V(r[0] != 'P' || r[1] != 'N' || r[2] != 'G' || r[3] != ' ', Image());
ERR_FAIL_COND_V(r[0] != 'P' || r[1] != 'N' || r[2] != 'G' || r[3] != ' ', Ref<Image>());
return _load_mem_png(&r[4], len - 4);
}
@ -271,13 +272,14 @@ static void _write_png_data(png_structp png_ptr, png_bytep data, png_size_t p_le
//print_line("png write: "+itos(p_length));
}
static PoolVector<uint8_t> _lossless_pack_png(const Image &p_image) {
static PoolVector<uint8_t> _lossless_pack_png(const Ref<Image> &p_image) {
Image img = p_image;
if (img.is_compressed())
img.decompress();
Ref<Image> img = p_image->duplicate();
ERR_FAIL_COND_V(img.is_compressed(), PoolVector<uint8_t>());
if (img->is_compressed())
img->decompress();
ERR_FAIL_COND_V(img->is_compressed(), PoolVector<uint8_t>());
png_structp png_ptr;
png_infop info_ptr;
@ -311,7 +313,7 @@ static PoolVector<uint8_t> _lossless_pack_png(const Image &p_image) {
int pngf = 0;
int cs = 0;
switch (img.get_format()) {
switch (img->get_format()) {
case Image::FORMAT_L8: {
@ -335,22 +337,22 @@ static PoolVector<uint8_t> _lossless_pack_png(const Image &p_image) {
} break;
default: {
if (img.detect_alpha()) {
if (img->detect_alpha()) {
img.convert(Image::FORMAT_RGBA8);
img->convert(Image::FORMAT_RGBA8);
pngf = PNG_COLOR_TYPE_RGB_ALPHA;
cs = 4;
} else {
img.convert(Image::FORMAT_RGB8);
img->convert(Image::FORMAT_RGB8);
pngf = PNG_COLOR_TYPE_RGB;
cs = 3;
}
}
}
int w = img.get_width();
int h = img.get_height();
int w = img->get_width();
int h = img->get_height();
png_set_IHDR(png_ptr, info_ptr, w, h,
8, pngf, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
@ -362,7 +364,7 @@ static PoolVector<uint8_t> _lossless_pack_png(const Image &p_image) {
ERR_FAIL_V(PoolVector<uint8_t>());
}
PoolVector<uint8_t>::Read r = img.get_data().read();
PoolVector<uint8_t>::Read r = img->get_data().read();
row_pointers = (png_bytep *)memalloc(sizeof(png_bytep) * h);
for (int i = 0; i < h; i++) {

4
drivers/png/image_loader_png.h
View file

@ -42,8 +42,8 @@ class ImageLoaderPNG : public ImageFormatLoader {
static void _read_png_data(png_structp png_ptr, png_bytep data, png_size_t p_length);
public:
static Error _load_image(void *rf_up, png_rw_ptr p_func, Image *p_image);
virtual Error load_image(Image *p_image, FileAccess *f);
static Error _load_image(void *rf_up, png_rw_ptr p_func, Ref<Image> p_image);
virtual Error load_image(Ref<Image> p_image, FileAccess *f);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
ImageLoaderPNG();
};

26
drivers/png/resource_saver_png.cpp
View file

@ -50,7 +50,7 @@ Error ResourceSaverPNG::save(const String &p_path, const RES &p_resource, uint32
ERR_EXPLAIN("Can't save empty texture as PNG");
ERR_FAIL_COND_V(!texture->get_width() || !texture->get_height(), ERR_INVALID_PARAMETER);
Image img = texture->get_data();
Ref<Image> img = texture->get_data();
Error err = save_image(p_path, img);
@ -95,12 +95,14 @@ Error ResourceSaverPNG::save(const String &p_path, const RES &p_resource, uint32
return err;
};
Error ResourceSaverPNG::save_image(const String &p_path, Image &p_img) {
Error ResourceSaverPNG::save_image(const String &p_path, const Ref<Image> &p_img) {
if (p_img.is_compressed())
p_img.decompress();
Ref<Image> img = p_img->duplicate();
ERR_FAIL_COND_V(p_img.is_compressed(), ERR_INVALID_PARAMETER);
if (img->is_compressed())
img->decompress();
ERR_FAIL_COND_V(img->is_compressed(), ERR_INVALID_PARAMETER);
png_structp png_ptr;
png_infop info_ptr;
@ -135,7 +137,7 @@ Error ResourceSaverPNG::save_image(const String &p_path, Image &p_img) {
int pngf = 0;
int cs = 0;
switch (p_img.get_format()) {
switch (img->get_format()) {
case Image::FORMAT_L8: {
@ -159,22 +161,22 @@ Error ResourceSaverPNG::save_image(const String &p_path, Image &p_img) {
} break;
default: {
if (p_img.detect_alpha()) {
if (img->detect_alpha()) {
p_img.convert(Image::FORMAT_RGBA8);
img->convert(Image::FORMAT_RGBA8);
pngf = PNG_COLOR_TYPE_RGB_ALPHA;
cs = 4;
} else {
p_img.convert(Image::FORMAT_RGB8);
img->convert(Image::FORMAT_RGB8);
pngf = PNG_COLOR_TYPE_RGB;
cs = 3;
}
}
}
int w = p_img.get_width();
int h = p_img.get_height();
int w = img->get_width();
int h = img->get_height();
png_set_IHDR(png_ptr, info_ptr, w, h,
8, pngf, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
@ -187,7 +189,7 @@ Error ResourceSaverPNG::save_image(const String &p_path, Image &p_img) {
ERR_FAIL_V(ERR_CANT_OPEN);
}
PoolVector<uint8_t>::Read r = p_img.get_data().read();
PoolVector<uint8_t>::Read r = img->get_data().read();
row_pointers = (png_bytep *)memalloc(sizeof(png_bytep) * h);
for (int i = 0; i < h; i++) {

3
drivers/png/resource_saver_png.h
View file

@ -30,11 +30,12 @@
#ifndef RESOURCE_SAVER_PNG_H
#define RESOURCE_SAVER_PNG_H
#include "image.h"
#include "io/resource_saver.h"
class ResourceSaverPNG : public ResourceFormatSaver {
public:
static Error save_image(const String &p_path, Image &p_img);
static Error save_image(const String &p_path, const Ref<Image> &p_img);
virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
virtual bool recognize(const RES &p_resource) const;

9
editor/asset_library_editor_plugin.cpp
View file

@ -683,17 +683,18 @@ void EditorAssetLibrary::_image_update(bool use_cache, bool final, const PoolByt
int len = image_data.size();
PoolByteArray::Read r = image_data.read();
Image image(r.ptr(), len);
if (!image.empty()) {
Ref<Image> image = Ref<Image>(memnew(Image(r.ptr(), len)));
if (!image->empty()) {
float max_height = 10000;
switch (image_queue[p_queue_id].image_type) {
case IMAGE_QUEUE_ICON: max_height = 80; break;
case IMAGE_QUEUE_THUMBNAIL: max_height = 80; break;
case IMAGE_QUEUE_SCREENSHOT: max_height = 345; break;
}
float scale_ratio = max_height / image.get_height();
float scale_ratio = max_height / image->get_height();
if (scale_ratio < 1) {
image.resize(image.get_width() * scale_ratio, image.get_height() * scale_ratio, Image::INTERPOLATE_CUBIC);
image->resize(image->get_width() * scale_ratio, image->get_height() * scale_ratio, Image::INTERPOLATE_CUBIC);
}
Ref<ImageTexture> tex;

2
editor/connections_dialog.cpp
View file

@ -239,7 +239,6 @@ void ConnectDialog::_add_bind() {
case Variant::BASIS: value = Basis(); break;
case Variant::TRANSFORM: value = Transform(); break;
case Variant::COLOR: value = Color(); break;
case Variant::IMAGE: value = Image(); break;
default: { ERR_FAIL(); } break;
}
@ -327,7 +326,6 @@ ConnectDialog::ConnectDialog() {
type_list->add_item("Transform", Variant::TRANSFORM);
//type_list->add_separator();
type_list->add_item("Color", Variant::COLOR);
type_list->add_item("Image", Variant::IMAGE);
type_list->select(0);
Button *add_bind = memnew(Button);

4
editor/doc/doc_data.cpp
View file

@ -335,11 +335,7 @@ void DocData::generate(bool p_basic_types) {
case Variant::DICTIONARY: // 20
case Variant::ARRAY:
case Variant::_RID:
case Variant::IMAGE:
//case Variant::RESOURCE:
default_arg_text = Variant::get_type_name(default_arg.get_type()) + "()";
break;
default: {}
}

4
editor/doc/doc_dump.cpp
View file

@ -198,11 +198,7 @@ void DocDump::dump(const String &p_file) {
case Variant::DICTIONARY: // 20
case Variant::ARRAY:
case Variant::_RID:
case Variant::IMAGE:
//case Variant::RESOURCE:
default_arg_text = Variant::get_type_name(default_arg.get_type()) + "()";
break;
default: {}
}

10
editor/editor_file_dialog.cpp
View file

@ -488,8 +488,9 @@ void EditorFileDialog::update_file_list() {
if (!has_icon("ResizedFolder", "EditorIcons")) {
Ref<ImageTexture> folder = get_icon("FolderBig", "EditorIcons");
Image img = folder->get_data();
img.resize(thumbnail_size, thumbnail_size);
Ref<Image> img = folder->get_data();
img = img->duplicate();
img->resize(thumbnail_size, thumbnail_size);
Ref<ImageTexture> resized_folder = Ref<ImageTexture>(memnew(ImageTexture));
resized_folder->create_from_image(img, 0);
Theme::get_default()->set_icon("ResizedFolder", "EditorIcons", resized_folder);
@ -499,8 +500,9 @@ void EditorFileDialog::update_file_list() {
if (!has_icon("ResizedFile", "EditorIcons")) {
Ref<ImageTexture> file = get_icon("FileBig", "EditorIcons");
Image img = file->get_data();
img.resize(thumbnail_size, thumbnail_size);
Ref<Image> img = file->get_data();
img = img->duplicate();
img->resize(thumbnail_size, thumbnail_size);
Ref<ImageTexture> resized_file = Ref<ImageTexture>(memnew(ImageTexture));
resized_file->create_from_image(img, 0);
Theme::get_default()->set_icon("ResizedFile", "EditorIcons", resized_file);

5
editor/editor_node.cpp
View file

@ -4463,8 +4463,9 @@ Variant EditorNode::drag_resource(const Ref<Resource> &p_res, Control *p_from) {
{
//todo make proper previews
Ref<ImageTexture> pic = gui_base->get_icon("FileBig", "EditorIcons");
Image img = pic->get_data();
img.resize(48, 48); //meh
Ref<Image> img = pic->get_data();
img = img->duplicate();
img->resize(48, 48); //meh
Ref<ImageTexture> resized_pic = Ref<ImageTexture>(memnew(ImageTexture));
resized_pic->create_from_image(img);
preview = resized_pic;

6
editor/editor_profiler.cpp
View file

@ -344,14 +344,16 @@ void EditorProfiler::_update_plot() {
wr = PoolVector<uint8_t>::Write();
Image img(w, h, 0, Image::FORMAT_RGBA8, graph_image);
Ref<Image> img;
img.instance();
img->create(w, h, 0, Image::FORMAT_RGBA8, graph_image);
if (reset_texture) {
if (graph_texture.is_null()) {
graph_texture.instance();
}
graph_texture->create(img.get_width(), img.get_height(), img.get_format(), Texture::FLAG_VIDEO_SURFACE);
graph_texture->create(img->get_width(), img->get_height(), img->get_format(), Texture::FLAG_VIDEO_SURFACE);
}
graph_texture->set_data(img);

9
editor/editor_run_native.cpp
View file

@ -43,11 +43,12 @@ void EditorRunNative::_notification(int p_what) {
continue;
Ref<ImageTexture> icon = eep->get_logo();
if (!icon.is_null()) {
Image im = icon->get_data();
im.clear_mipmaps();
if (!im.empty()) {
Ref<Image> im = icon->get_data();
im = im->duplicate();
im->clear_mipmaps();
if (!im->empty()) {
im.resize(16, 16);
im->resize(16, 16);
Ref<ImageTexture> small_icon;
small_icon.instance();
small_icon->create_from_image(im, 0);

9
editor/filesystem_dock.cpp
View file

@ -416,8 +416,9 @@ void FileSystemDock::_update_files(bool p_keep_selection) {
if (!has_icon("ResizedFolder", "EditorIcons")) {
Ref<ImageTexture> folder = get_icon("FolderBig", "EditorIcons");
Image img = folder->get_data();
img.resize(thumbnail_size, thumbnail_size);
Ref<Image> img = folder->get_data();
img = img->duplicate();
img->resize(thumbnail_size, thumbnail_size);
Ref<ImageTexture> resized_folder = Ref<ImageTexture>(memnew(ImageTexture));
resized_folder->create_from_image(img, 0);
Theme::get_default()->set_icon("ResizedFolder", "EditorIcons", resized_folder);
@ -427,8 +428,8 @@ void FileSystemDock::_update_files(bool p_keep_selection) {
if (!has_icon("ResizedFile", "EditorIcons")) {
Ref<ImageTexture> file = get_icon("FileBig", "EditorIcons");
Image img = file->get_data();
img.resize(thumbnail_size, thumbnail_size);
Ref<Image> img = file->get_data();
img->resize(thumbnail_size, thumbnail_size);
Ref<ImageTexture> resized_file = Ref<ImageTexture>(memnew(ImageTexture));
resized_file->create_from_image(img, 0);
Theme::get_default()->set_icon("ResizedFile", "EditorIcons", resized_file);

6
editor/icons/SCsub
View file

@ -62,9 +62,9 @@ def make_editor_icons_action(target, source, env):
s.write("static Ref<ImageTexture> make_icon(const uint8_t* p_png,const uint8_t* p_hidpi_png) {\n")
s.write("\tRef<ImageTexture> texture( memnew( ImageTexture ) );\n")
s.write("\tbool use_hidpi_image=(editor_get_scale()>1.0&&p_hidpi_png);\n")
s.write("\tImage img(use_hidpi_image?p_hidpi_png:p_png);\n")
s.write("\tif (editor_get_scale()>1.0 && !p_hidpi_png) { img.convert(Image::FORMAT_RGBA8); img.expand_x2_hq2x(); use_hidpi_image=true;}\n")
s.write("\timg.resize(img.get_width()*EDSCALE/(use_hidpi_image?2:1),img.get_height()*EDSCALE/(use_hidpi_image?2:1));\n")
s.write("\tRef<Image> img = memnew(Image(use_hidpi_image?p_hidpi_png:p_png));\n")
s.write("\tif (editor_get_scale()>1.0 && !p_hidpi_png) { img->convert(Image::FORMAT_RGBA8); img->expand_x2_hq2x(); use_hidpi_image=true;}\n")
s.write("\timg->resize(img->get_width()*EDSCALE/(use_hidpi_image?2:1),img->get_height()*EDSCALE/(use_hidpi_image?2:1));\n")
s.write("\ttexture->create_from_image( img,ImageTexture::FLAG_FILTER );\n")
s.write("\treturn texture;\n")
s.write("}\n\n")

67
editor/import/resource_importer_texture.cpp
View file

@ -181,7 +181,7 @@ void ResourceImporterTexture::get_import_options(List<ImportOption> *r_options,
r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "detect_3d"), p_preset == PRESET_DETECT));
}
void ResourceImporterTexture::_save_stex(const Image &p_image, const String &p_to_path, int p_compress_mode, float p_lossy_quality, Image::CompressMode p_vram_compression, bool p_mipmaps, int p_texture_flags, bool p_streamable, bool p_detect_3d, bool p_detect_srgb) {
void ResourceImporterTexture::_save_stex(const Ref<Image> &p_image, const String &p_to_path, int p_compress_mode, float p_lossy_quality, Image::CompressMode p_vram_compression, bool p_mipmaps, int p_texture_flags, bool p_streamable, bool p_detect_3d, bool p_detect_srgb) {
FileAccess *f = FileAccess::open(p_to_path, FileAccess::WRITE);
f->store_8('G');
@ -189,8 +189,8 @@ void ResourceImporterTexture::_save_stex(const Image &p_image, const String &p_t
f->store_8('S');
f->store_8('T'); //godot streamable texture
f->store_32(p_image.get_width());
f->store_32(p_image.get_height());
f->store_32(p_image->get_width());
f->store_32(p_image->get_height());
f->store_32(p_texture_flags);
uint32_t format = 0;
@ -207,14 +207,14 @@ void ResourceImporterTexture::_save_stex(const Image &p_image, const String &p_t
switch (p_compress_mode) {
case COMPRESS_LOSSLESS: {
Image image = p_image;
Ref<Image> image = p_image->duplicate();
if (p_mipmaps) {
image.generate_mipmaps();
image->generate_mipmaps();
} else {
image.clear_mipmaps();
image->clear_mipmaps();
}
int mmc = image.get_mipmap_count() + 1;
int mmc = image->get_mipmap_count() + 1;
format |= StreamTexture::FORMAT_BIT_LOSSLESS;
f->store_32(format);
@ -223,7 +223,7 @@ void ResourceImporterTexture::_save_stex(const Image &p_image, const String &p_t
for (int i = 0; i < mmc; i++) {
if (i > 0) {
image.shrink_x2();
image->shrink_x2();
}
PoolVector<uint8_t> data = Image::lossless_packer(image);
@ -236,14 +236,14 @@ void ResourceImporterTexture::_save_stex(const Image &p_image, const String &p_t
} break;
case COMPRESS_LOSSY: {
Image image = p_image;
Ref<Image> image = p_image->duplicate();
if (p_mipmaps) {
image.generate_mipmaps();
image->generate_mipmaps();
} else {
image.clear_mipmaps();
image->clear_mipmaps();
}
int mmc = image.get_mipmap_count() + 1;
int mmc = image->get_mipmap_count() + 1;
format |= StreamTexture::FORMAT_BIT_LOSSY;
f->store_32(format);
@ -252,7 +252,7 @@ void ResourceImporterTexture::_save_stex(const Image &p_image, const String &p_t
for (int i = 0; i < mmc; i++) {
if (i > 0) {
image.shrink_x2();
image->shrink_x2();
}
PoolVector<uint8_t> data = Image::lossy_packer(image, p_lossy_quality);
@ -265,15 +265,15 @@ void ResourceImporterTexture::_save_stex(const Image &p_image, const String &p_t
} break;
case COMPRESS_VIDEO_RAM: {
Image image = p_image;
image.generate_mipmaps();
image.compress(p_vram_compression);
Ref<Image> image = p_image->duplicate();
image->generate_mipmaps();
image->compress(p_vram_compression);
format |= image.get_format();
format |= image->get_format();
f->store_32(format);
PoolVector<uint8_t> data = image.get_data();
PoolVector<uint8_t> data = image->get_data();
int dl = data.size();
PoolVector<uint8_t>::Read r = data.read();
f->store_buffer(r.ptr(), dl);
@ -281,17 +281,17 @@ void ResourceImporterTexture::_save_stex(const Image &p_image, const String &p_t
} break;
case COMPRESS_UNCOMPRESSED: {
Image image = p_image;
Ref<Image> image = p_image->duplicate();
if (p_mipmaps) {
image.generate_mipmaps();
image->generate_mipmaps();
} else {
image.clear_mipmaps();
image->clear_mipmaps();
}
format |= image.get_format();
format |= image->get_format();
f->store_32(format);
PoolVector<uint8_t> data = image.get_data();
PoolVector<uint8_t> data = image->get_data();
int dl = data.size();
PoolVector<uint8_t>::Read r = data.read();
@ -317,8 +317,9 @@ Error ResourceImporterTexture::import(const String &p_source_file, const String
bool stream = p_options["stream"];
int size_limit = p_options["size_limit"];
Image image;
Error err = ImageLoader::load_image(p_source_file, &image);
Ref<Image> image;
image.instance();
Error err = ImageLoader::load_image(p_source_file, image);
if (err != OK)
return err;
@ -336,28 +337,28 @@ Error ResourceImporterTexture::import(const String &p_source_file, const String
if (srgb == 1)
tex_flags |= Texture::FLAG_CONVERT_TO_LINEAR;
if (size_limit > 0 && (image.get_width() > size_limit || image.get_height() > size_limit)) {
if (size_limit > 0 && (image->get_width() > size_limit || image->get_height() > size_limit)) {
//limit size
if (image.get_width() >= image.get_height()) {
if (image->get_width() >= image->get_height()) {
int new_width = size_limit;
int new_height = image.get_height() * new_width / image.get_width();
int new_height = image->get_height() * new_width / image->get_width();
image.resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
image->resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
} else {
int new_height = size_limit;
int new_width = image.get_width() * new_height / image.get_height();
int new_width = image->get_width() * new_height / image->get_height();
image.resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
image->resize(new_width, new_height, Image::INTERPOLATE_CUBIC);
}
}
if (fix_alpha_border) {
image.fix_alpha_edges();
image->fix_alpha_edges();
}
if (premult_alpha) {
image.premultiply_alpha();
image->premultiply_alpha();
}
bool detect_3d = p_options["detect_3d"];

4
editor/import/resource_importer_texture.h
View file

@ -30,7 +30,9 @@
#ifndef RESOURCEIMPORTTEXTURE_H
#define RESOURCEIMPORTTEXTURE_H
#include "image.h"
#include "io/resource_import.h"
class StreamTexture;
class ResourceImporterTexture : public ResourceImporter {
@ -78,7 +80,7 @@ public:
virtual void get_import_options(List<ImportOption> *r_options, int p_preset = 0) const;
virtual bool get_option_visibility(const String &p_option, const Map<StringName, Variant> &p_options) const;
void _save_stex(const Image &p_image, const String &p_to_path, int p_compress_mode, float p_lossy_quality, Image::CompressMode p_vram_compression, bool p_mipmaps, int p_texture_flags, bool p_streamable, bool p_detect_3d, bool p_detect_srgb);
void _save_stex(const Ref<Image> &p_image, const String &p_to_path, int p_compress_mode, float p_lossy_quality, Image::CompressMode p_vram_compression, bool p_mipmaps, int p_texture_flags, bool p_streamable, bool p_detect_3d, bool p_detect_srgb);
virtual Error import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files = NULL);

2
editor/plugins/baked_light_baker.h
View file

@ -31,7 +31,7 @@
#define BAKED_LIGHT_BAKER_H
#include "os/thread.h"
#include "scene/3d/baked_light_instance.h"
#include "scene/3d/light.h"
#include "scene/3d/mesh_instance.h"

3
editor/plugins/gradient_texture_editor_plugin.cpp
View file

@ -48,7 +48,8 @@ GradientTextureEdit::GradientTextureEdit() {
add_child(popup);
checker = Ref<ImageTexture>(memnew(ImageTexture));
checker->create_from_image(Image(checker_bg_png), ImageTexture::FLAG_REPEAT);
Ref<Image> checker_bg = memnew(Image(checker_bg_png));
checker->create_from_image(checker_bg, ImageTexture::FLAG_REPEAT);
}
int GradientTextureEdit::_get_point_from_pos(int x) {

15
editor/plugins/particles_2d_editor_plugin.cpp
View file

@ -64,17 +64,18 @@ void Particles2DEditorPlugin::_file_selected(const String &p_file) {
int epc = epoints->get_value();
Image img;
Error err = ImageLoader::load_image(p_file, &img);
Ref<Image> img;
img.instance();
Error err = ImageLoader::load_image(p_file, img);
ERR_EXPLAIN(TTR("Error loading image:") + " " + p_file);
ERR_FAIL_COND(err != OK);
img.convert(Image::FORMAT_LA8);
ERR_FAIL_COND(img.get_format() != Image::FORMAT_LA8);
Size2i s = Size2(img.get_width(), img.get_height());
img->convert(Image::FORMAT_LA8);
ERR_FAIL_COND(img->get_format() != Image::FORMAT_LA8);
Size2i s = Size2(img->get_width(), img->get_height());
ERR_FAIL_COND(s.width == 0 || s.height == 0);
PoolVector<uint8_t> data = img.get_data();
PoolVector<uint8_t> data = img->get_data();
PoolVector<uint8_t>::Read r = data.read();
Vector<Point2i> valid_positions;
@ -98,7 +99,7 @@ void Particles2DEditorPlugin::_file_selected(const String &p_file) {
epoints.resize(epc);
PoolVector<Point2>::Write w = epoints.write();
Size2 extents = Size2(img.get_width() * 0.5, img.get_height() * 0.5);
Size2 extents = Size2(img->get_width() * 0.5, img->get_height() * 0.5);
for (int i = 0; i < epc; i++) {

4
editor/plugins/particles_editor_plugin.cpp
View file

@ -329,7 +329,7 @@ void ParticlesEditor::_generate_emission_points() {
copymem(iw.ptr(), r.ptr(), point_count * sizeof(float) * 3);
}
Image image(w, h, false, Image::FORMAT_RGBF, point_img);
Ref<Image> image = memnew(Image(w, h, false, Image::FORMAT_RGBF, point_img));
Ref<ImageTexture> tex;
tex.instance();
@ -354,7 +354,7 @@ void ParticlesEditor::_generate_emission_points() {
copymem(iw.ptr(), r.ptr(), point_count * sizeof(float) * 3);
}
Image image2(w, h, false, Image::FORMAT_RGBF, point_img2);
Ref<Image> image2 = memnew(Image(w, h, false, Image::FORMAT_RGBF, point_img2));
Ref<ImageTexture> tex2;
tex2.instance();

2
editor/plugins/spatial_editor_plugin.h
View file

@ -428,7 +428,7 @@ private:
ViewportContainer *settings_light_base;
Viewport *settings_light_vp;
ColorPickerButton *settings_ambient_color;
Image settings_light_dir_image;
Ref<Image> settings_light_dir_image;
void _xform_dialog_action();
void _menu_item_pressed(int p_option);

9
editor/plugins/texture_region_editor_plugin.cpp
View file

@ -678,12 +678,13 @@ void TextureRegionEditor::_edit_region() {
}
autoslice_cache.clear();
Image i;
if (i.load(texture->get_path()) == OK) {
Ref<Image> i;
i.instance();
if (i->load(texture->get_path()) == OK) {
BitMap bm;
bm.create_from_image_alpha(i);
for (int y = 0; y < i.get_height(); y++) {
for (int x = 0; x < i.get_width(); x++) {
for (int y = 0; y < i->get_height(); y++) {
for (int x = 0; x < i->get_width(); x++) {
if (bm.get_bit(Point2(x, y))) {
bool found = false;
for (List<Rect2>::Element *E = autoslice_cache.front(); E; E = E->next()) {

7
editor/project_manager.cpp
View file

@ -806,11 +806,12 @@ void ProjectManager::_load_recent_projects() {
if (cf->has_section_key("application", "icon")) {
String appicon = cf->get_value("application", "icon");
if (appicon != "") {
Image img;
Error err = img.load(appicon.replace_first("res://", path + "/"));
Ref<Image> img;
img.instance();
Error err = img->load(appicon.replace_first("res://", path + "/"));
if (err == OK) {
img.resize(64, 64);
img->resize(64, 64);
Ref<ImageTexture> it = memnew(ImageTexture);
it->create_from_image(img);
icon = it;

72
editor/property_editor.cpp
View file

@ -861,15 +861,7 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
*/
} break;
case Variant::IMAGE: {
List<String> names;
names.push_back(TTR("New"));
names.push_back(TTR("Load"));
names.push_back(TTR("Clear"));
config_action_buttons(names);
} break;
case Variant::NODE_PATH: {
List<String> names;
@ -1061,16 +1053,6 @@ void CustomPropertyEditor::_file_selected(String p_file) {
emit_signal("variant_changed");
hide();
} break;
case Variant::IMAGE: {
Image image;
Error err = ImageLoader::load_image(p_file, &image);
ERR_EXPLAIN(TTR("Couldn't load image"));
ERR_FAIL_COND(err);
v = image;
emit_signal("variant_changed");
hide();
} break;
default: {}
}
}
@ -1387,36 +1369,7 @@ void CustomPropertyEditor::_action_pressed(int p_which) {
}
} break;
case Variant::IMAGE: {
if (p_which == 0) {
//new image too difficult
ERR_PRINT("New Image Unimplemented");
} else if (p_which == 1) {
file->set_access(EditorFileDialog::ACCESS_RESOURCES);
file->set_mode(EditorFileDialog::MODE_OPEN_FILE);
List<String> extensions;
ImageLoader::get_recognized_extensions(&extensions);
file->clear_filters();
for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
file->add_filter("*." + E->get() + " ; " + E->get().to_upper());
}
file->popup_centered_ratio();
} else if (p_which == 2) {
v = Image();
emit_signal("variant_changed");
hide();
}
} break;
default: {};
}
}
@ -1756,9 +1709,7 @@ void CustomPropertyEditor::_modified(String p_string) {
emit_signal("variant_changed");
*/
} break;
case Variant::IMAGE: {
} break;
case Variant::NODE_PATH: {
v = NodePath(value_editor[0]->get_text());
@ -2356,15 +2307,6 @@ void PropertyEditor::set_item_text(TreeItem *p_item, int p_type, const String &p
tree->update();
//p_item->set_text(1,obj->get(p_name));
} break;
case Variant::IMAGE: {
Image img = obj->get(p_name);
if (img.empty())
p_item->set_text(1, "[Image (empty)]");
else
p_item->set_text(1, "[Image " + itos(img.get_width()) + "x" + itos(img.get_height()) + "-" + String(Image::get_format_name(img.get_format())) + "]");
} break;
case Variant::NODE_PATH: {
@ -3588,19 +3530,7 @@ void PropertyEditor::update_tree() {
item->set_icon(0, get_icon("Color", "EditorIcons"));
} break;
case Variant::IMAGE: {
item->set_cell_mode(1, TreeItem::CELL_MODE_CUSTOM);
item->set_editable(1, !read_only);
Image img = obj->get(p.name);
if (img.empty())
item->set_text(1, "[Image (empty)]");
else
item->set_text(1, "[Image " + itos(img.get_width()) + "x" + itos(img.get_height()) + "-" + String(Image::get_format_name(img.get_format())) + "]");
if (show_type_icons)
item->set_icon(0, get_icon("Image", "EditorIcons"));
} break;
case Variant::NODE_PATH: {
item->set_cell_mode(1, TreeItem::CELL_MODE_STRING);
@ -3922,9 +3852,7 @@ void PropertyEditor::_item_edited() {
case Variant::COLOR: {
//_edit_set(name,item->get_custom_bg_color(0));
} break;
case Variant::IMAGE: {
} break;
case Variant::NODE_PATH: {
_edit_set(name, NodePath(item->get_text(1)), refresh_all);

1
editor/property_selector.cpp
View file

@ -136,7 +136,6 @@ void PropertySelector::_update_search() {
Control::get_icon("MiniMatrix3", "EditorIcons"),
Control::get_icon("MiniTransform", "EditorIcons"),
Control::get_icon("MiniColor", "EditorIcons"),
Control::get_icon("MiniImage", "EditorIcons"),
Control::get_icon("MiniPath", "EditorIcons"),
Control::get_icon("MiniRid", "EditorIcons"),
Control::get_icon("MiniObject", "EditorIcons"),

4
editor/pvrtc_compress.cpp
View file

@ -89,7 +89,7 @@ static void _compress_image(Image::CompressMode p_mode, Image *p_image) {
args.push_back("-m");
Ref<ImageTexture> t = memnew(ImageTexture);
t->create_from_image(*p_image, 0);
t->create_from_image(Ref<Image>(p_image), 0);
ResourceSaver::save(src_img, t);
Error err = OS::get_singleton()->execute(ttpath, args, true);
@ -101,7 +101,7 @@ static void _compress_image(Image::CompressMode p_mode, Image *p_image) {
ERR_EXPLAIN(TTR("Can't load back converted image using PVRTC tool:") + " " + dst_img);
ERR_FAIL_COND(t.is_null());
*p_image = t->get_data();
p_image->copy_internals_from(t->get_data());
}
static void _compress_pvrtc2(Image *p_image) {

15
main/main.cpp
View file

@ -917,18 +917,19 @@ Error Main::setup2() {
bool boot_logo_scale = GLOBAL_DEF("application/boot_splash_fullsize", true);
GlobalConfig::get_singleton()->set_custom_property_info("application/boot_splash", PropertyInfo(Variant::STRING, "application/boot_splash", PROPERTY_HINT_FILE, "*.png"));
Image boot_logo;
Ref<Image> boot_logo;
boot_logo_path = boot_logo_path.strip_edges();
if (boot_logo_path != String() /*&& FileAccess::exists(boot_logo_path)*/) {
print_line("Boot splash path: " + boot_logo_path);
Error err = boot_logo.load(boot_logo_path);
boot_logo.instance();
Error err = boot_logo->load(boot_logo_path);
if (err)
ERR_PRINTS("Non-existing or invalid boot splash at: " + boot_logo_path + ". Loading default splash.");
}
if (!boot_logo.empty()) {
if (boot_logo.is_valid()) {
OS::get_singleton()->_msec_splash = OS::get_singleton()->get_ticks_msec();
Color boot_bg = GLOBAL_DEF("application/boot_bg_color", clear);
VisualServer::get_singleton()->set_boot_image(boot_logo, boot_bg, boot_logo_scale);
@ -941,7 +942,7 @@ Error Main::setup2() {
#ifndef NO_DEFAULT_BOOT_LOGO
MAIN_PRINT("Main: Create bootsplash");
Image splash(boot_splash_png);
Ref<Image> splash = memnew(Image(boot_splash_png));
MAIN_PRINT("Main: ClearColor");
VisualServer::get_singleton()->set_default_clear_color(boot_splash_bg_color);
@ -950,7 +951,7 @@ Error Main::setup2() {
#endif
}
Image icon(app_icon_png);
Ref<Image> icon = memnew(Image(app_icon_png));
OS::get_singleton()->set_icon(icon);
}
@ -1464,8 +1465,8 @@ bool Main::start() {
String iconpath = GLOBAL_DEF("application/icon", "Variant()");
if (iconpath != "") {
Image icon;
if (icon.load(iconpath) == OK)
Ref<Image> icon;
if (icon->load(iconpath) == OK)
OS::get_singleton()->set_icon(icon);
}
}

12
main/tests/test_containers.cpp
View file

@ -55,18 +55,6 @@ MainLoop *test() {
{
Image img;
img.create(default_mouse_cursor_xpm);
{
for (int i = 0; i < 8; i++) {
Image mipmap;
//img.make_mipmap(mipmap);
img = mipmap;
if (img.get_width() <= 4) break;
};
};
};
#if 0

5
main/tests/test_image.cpp
View file

@ -63,11 +63,6 @@ public:
MainLoop *test() {
Image img;
ImageLoader::load_image("as1.png", &img);
img.resize(512, 512);
return memnew(TestMainLoop);
}
}

10
main/tests/test_physics_2d.cpp
View file

@ -82,7 +82,7 @@ class TestPhysics2DMainLoop : public MainLoop {
}
}
Image image(32, 2, 0, Image::FORMAT_LA8, pixels);
Ref<Image> image = memnew(Image(32, 2, 0, Image::FORMAT_LA8, pixels));
body_shape_data[Physics2DServer::SHAPE_SEGMENT].image = vs->texture_create_from_image(image);
@ -109,7 +109,7 @@ class TestPhysics2DMainLoop : public MainLoop {
}
}
Image image(32, 32, 0, Image::FORMAT_LA8, pixels);
Ref<Image> image = memnew(Image(32, 32, 0, Image::FORMAT_LA8, pixels));
body_shape_data[Physics2DServer::SHAPE_CIRCLE].image = vs->texture_create_from_image(image);
@ -136,7 +136,7 @@ class TestPhysics2DMainLoop : public MainLoop {
}
}
Image image(32, 32, 0, Image::FORMAT_LA8, pixels);
Ref<Image> image = memnew(Image(32, 32, 0, Image::FORMAT_LA8, pixels));
body_shape_data[Physics2DServer::SHAPE_RECTANGLE].image = vs->texture_create_from_image(image);
@ -164,7 +164,7 @@ class TestPhysics2DMainLoop : public MainLoop {
}
}
Image image(32, 64, 0, Image::FORMAT_LA8, pixels);
Ref<Image> image = memnew(Image(32, 64, 0, Image::FORMAT_LA8, pixels));
body_shape_data[Physics2DServer::SHAPE_CAPSULE].image = vs->texture_create_from_image(image);
@ -178,7 +178,7 @@ class TestPhysics2DMainLoop : public MainLoop {
{
Image image(convex_png);
Ref<Image> image = memnew(Image(convex_png));
body_shape_data[Physics2DServer::SHAPE_CONVEX_POLYGON].image = vs->texture_create_from_image(image);

2
modules/dds/texture_loader_dds.cpp
View file

@ -441,7 +441,7 @@ RES ResourceFormatDDS::load(const String &p_path, const String &p_original_path,
wb = PoolVector<uint8_t>::Write();
}
Image img(width, height, mipmaps - 1, info.format, src_data);
Ref<Image> img = memnew(Image(width, height, mipmaps - 1, info.format, src_data));
Ref<ImageTexture> texture = memnew(ImageTexture);
texture->create_from_image(img);

19
modules/etc1/image_etc.cpp
View file

@ -88,25 +88,26 @@ static void _decompress_etc(Image *p_img) {
r = PoolVector<uint8_t>::Read();
//print_line("Re Creating ETC into regular image: w "+itos(p_img->get_width())+" h "+itos(p_img->get_height())+" mm "+itos(p_img->get_mipmaps()));
*p_img = Image(p_img->get_width(), p_img->get_height(), p_img->has_mipmaps(), Image::FORMAT_RGB8, dst);
if (p_img->has_mipmaps())
bool needs_mipmaps = p_img->has_mipmaps();
p_img->create(p_img->get_width(), p_img->get_height(), p_img->has_mipmaps(), Image::FORMAT_RGB8, dst);
if (needs_mipmaps)
p_img->generate_mipmaps();
}
static void _compress_etc(Image *p_img) {
Image img = *p_img;
Ref<Image> img = p_img->duplicate();
int imgw = img.get_width(), imgh = img.get_height();
int imgw = img->get_width(), imgh = img->get_height();
ERR_FAIL_COND(nearest_power_of_2(imgw) != imgw || nearest_power_of_2(imgh) != imgh);
if (img.get_format() != Image::FORMAT_RGB8)
img.convert(Image::FORMAT_RGB8);
if (img->get_format() != Image::FORMAT_RGB8)
img->convert(Image::FORMAT_RGB8);
PoolVector<uint8_t> res_data;
PoolVector<uint8_t> dst_data;
PoolVector<uint8_t>::Read r = img.get_data().read();
PoolVector<uint8_t>::Read r = img->get_data().read();
int target_size = Image::get_image_data_size(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC, p_img->has_mipmaps() ? -1 : 0);
int mmc = p_img->has_mipmaps() ? Image::get_image_required_mipmaps(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC) : 0;
@ -122,7 +123,7 @@ static void _compress_etc(Image *p_img) {
int bw = MAX(imgw / 4, 1);
int bh = MAX(imgh / 4, 1);
const uint8_t *src = &r[img.get_mipmap_offset(i)];
const uint8_t *src = &r[img->get_mipmap_offset(i)];
int mmsize = MAX(bw, 1) * MAX(bh, 1) * 8;
uint8_t *dst = &w[ofs];
@ -171,7 +172,7 @@ static void _compress_etc(Image *p_img) {
mc++;
}
*p_img = Image(p_img->get_width(), p_img->get_height(), (mc - 1) ? true : false, Image::FORMAT_ETC, dst_data);
p_img->create(p_img->get_width(), p_img->get_height(), (mc - 1) ? true : false, Image::FORMAT_ETC, dst_data);
}
void _register_etc1_compress_func() {

2
modules/etc1/texture_loader_pkm.cpp
View file

@ -85,7 +85,7 @@ RES ResourceFormatPKM::load(const String &p_path, const String &p_original_path,
int width = h.origWidth;
int height = h.origHeight;
Image img(width, height, mipmaps, Image::FORMAT_ETC, src_data);
Ref<Image> img = memnew(Image(width, height, mipmaps, Image::FORMAT_ETC, src_data));
Ref<ImageTexture> texture = memnew(ImageTexture);
texture->create_from_image(img);

2
modules/gdnative/config.py
View file

@ -1,7 +1,7 @@
def can_build(platform):
return True
return False
def configure(env):

2
modules/gdscript/gd_editor.cpp
View file

@ -1321,7 +1321,7 @@ static void _find_identifiers(GDCompletionContext &context, int p_line, bool p_o
static const char *_type_names[Variant::VARIANT_MAX] = {
"null", "bool", "int", "float", "String", "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform",
"Color", "Image", "NodePath", "RID", "Object", "InputEvent", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray",
"Color", "NodePath", "RID", "Object", "InputEvent", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray",
"Vector2Array", "Vector3Array", "ColorArray"
};

1
modules/gdscript/gd_tokenizer.cpp
View file

@ -800,7 +800,6 @@ void GDTokenizerText::_advance() {
{ Variant::BASIS, "Basis" },
{ Variant::TRANSFORM, "Transform" },
{ Variant::COLOR, "Color" },
{ Variant::IMAGE, "Image" },
{ Variant::_RID, "RID" },
{ Variant::OBJECT, "Object" },
{ Variant::INPUT_EVENT, "InputEvent" },

11
modules/jpg/image_loader_jpegd.cpp
View file

@ -89,7 +89,7 @@ Error jpeg_load_image_from_buffer(Image *p_image, const uint8_t *p_buffer, int p
return OK;
}
Error ImageLoaderJPG::load_image(Image *p_image, FileAccess *f) {
Error ImageLoaderJPG::load_image(Ref<Image> p_image, FileAccess *f) {
PoolVector<uint8_t> src_image;
int src_image_len = f->get_len();
@ -102,7 +102,7 @@ Error ImageLoaderJPG::load_image(Image *p_image, FileAccess *f) {
f->close();
Error err = jpeg_load_image_from_buffer(p_image, w.ptr(), src_image_len);
Error err = jpeg_load_image_from_buffer(p_image.ptr(), w.ptr(), src_image_len);
w = PoolVector<uint8_t>::Write();
@ -115,10 +115,11 @@ void ImageLoaderJPG::get_recognized_extensions(List<String> *p_extensions) const
p_extensions->push_back("jpeg");
}
static Image _jpegd_mem_loader_func(const uint8_t *p_png, int p_size) {
static Ref<Image> _jpegd_mem_loader_func(const uint8_t *p_png, int p_size) {
Image img;
Error err = jpeg_load_image_from_buffer(&img, p_png, p_size);
Ref<Image> img;
img.instance();
Error err = jpeg_load_image_from_buffer(img.ptr(), p_png, p_size);
if (err)
ERR_PRINT("Couldn't initialize ImageLoaderJPG with the given resource.");

2
modules/jpg/image_loader_jpegd.h
View file

@ -38,7 +38,7 @@
class ImageLoaderJPG : public ImageFormatLoader {
public:
virtual Error load_image(Image *p_image, FileAccess *f);
virtual Error load_image(Ref<Image> p_image, FileAccess *f);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
ImageLoaderJPG();
};

43
modules/pvr/texture_loader_pvr.cpp
View file

@ -164,8 +164,8 @@ RES ResourceFormatPVR::load(const String &p_path, const String &p_original_path,
print_line("flip: " + itos(flags & PVR_VFLIP));
Image image(width, height, mipmaps, format, data);
ERR_FAIL_COND_V(image.empty(), RES());
Ref<Image> image = memnew(Image(width, height, mipmaps, format, data));
ERR_FAIL_COND_V(image->empty(), RES());
Ref<ImageTexture> texture = memnew(ImageTexture);
texture->create_from_image(image, tex_flags);
@ -193,30 +193,32 @@ String ResourceFormatPVR::get_resource_type(const String &p_path) const {
static void _compress_pvrtc4(Image *p_img) {
Image img = *p_img;
Ref<Image> img = p_img->duplicate();
bool make_mipmaps = false;
if (img.get_width() % 8 || img.get_height() % 8) {
make_mipmaps = img.has_mipmaps();
img.resize(img.get_width() + (8 - (img.get_width() % 8)), img.get_height() + (8 - (img.get_height() % 8)));
if (img->get_width() % 8 || img->get_height() % 8) {
make_mipmaps = img->has_mipmaps();
img->resize(img->get_width() + (8 - (img->get_width() % 8)), img->get_height() + (8 - (img->get_height() % 8)));
}
img.convert(Image::FORMAT_RGBA8);
if (!img.has_mipmaps() && make_mipmaps)
img.generate_mipmaps();
img->convert(Image::FORMAT_RGBA8);
if (!img->has_mipmaps() && make_mipmaps)
img->generate_mipmaps();
bool use_alpha = img.detect_alpha();
bool use_alpha = img->detect_alpha();
Image new_img;
new_img.create(img.get_width(), img.get_height(), true, use_alpha ? Image::FORMAT_PVRTC4A : Image::FORMAT_PVRTC4);
PoolVector<uint8_t> data = new_img.get_data();
Ref<Image> new_img;
new_img.instance();
new_img->create(img->get_width(), img->get_height(), true, use_alpha ? Image::FORMAT_PVRTC4A : Image::FORMAT_PVRTC4);
PoolVector<uint8_t> data = new_img->get_data();
{
PoolVector<uint8_t>::Write wr = data.write();
PoolVector<uint8_t>::Read r = img.get_data().read();
PoolVector<uint8_t>::Read r = img->get_data().read();
for (int i = 0; i <= new_img.get_mipmap_count(); i++) {
for (int i = 0; i <= new_img->get_mipmap_count(); i++) {
int ofs, size, w, h;
img.get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h);
img->get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h);
Javelin::RgbaBitmap bm(w, h);
copymem(bm.GetData(), &r[ofs], size);
{
@ -226,12 +228,12 @@ static void _compress_pvrtc4(Image *p_img) {
}
}
new_img.get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h);
new_img->get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h);
Javelin::PvrTcEncoder::EncodeRgba4Bpp(&wr[ofs], bm);
}
}
*p_img = Image(new_img.get_width(), new_img.get_height(), new_img.has_mipmaps(), new_img.get_format(), data);
p_img->create(new_img->get_width(), new_img->get_height(), new_img->has_mipmaps(), new_img->get_format(), data);
}
ResourceFormatPVR::ResourceFormatPVR() {
@ -676,8 +678,7 @@ static void _pvrtc_decompress(Image *p_img) {
r = PoolVector<uint8_t>::Read();
bool make_mipmaps = p_img->has_mipmaps();
Image newimg(p_img->get_width(), p_img->get_height(), false, Image::FORMAT_RGBA8, newdata);
p_img->create(p_img->get_width(), p_img->get_height(), false, Image::FORMAT_RGBA8, newdata);
if (make_mipmaps)
newimg.generate_mipmaps();
*p_img = newimg;
p_img->generate_mipmaps();
}

2
modules/theora/video_stream_theora.cpp
View file

@ -138,7 +138,7 @@ void VideoStreamPlaybackTheora::video_write(void) {
format = Image::FORMAT_RGBA8;
}
Image img(size.x, size.y, 0, Image::FORMAT_RGBA8, frame_data); //zero copy image creation
Ref<Image> img = memnew(Image(size.x, size.y, 0, Image::FORMAT_RGBA8, frame_data)); //zero copy image creation
texture->set_data(img); //zero copy send to visual server

3
modules/visual_script/visual_script_editor.cpp
View file

@ -346,7 +346,6 @@ static Color _color_from_type(Variant::Type p_type) {
case Variant::TRANSFORM: color = Color::html("f6a86e"); break;
case Variant::COLOR: color = Color::html("9dff70"); break;
case Variant::IMAGE: color = Color::html("93f1b9"); break;
case Variant::NODE_PATH: color = Color::html("6993ec"); break;
case Variant::_RID: color = Color::html("69ec9a"); break;
case Variant::OBJECT: color = Color::html("79f3e8"); break;
@ -451,7 +450,6 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
Control::get_icon("MiniBasis", "EditorIcons"),
Control::get_icon("MiniTransform", "EditorIcons"),
Control::get_icon("MiniColor", "EditorIcons"),
Control::get_icon("MiniImage", "EditorIcons"),
Control::get_icon("MiniPath", "EditorIcons"),
Control::get_icon("MiniRid", "EditorIcons"),
Control::get_icon("MiniObject", "EditorIcons"),
@ -735,7 +733,6 @@ void VisualScriptEditor::_update_members() {
Control::get_icon("MiniMatrix3", "EditorIcons"),
Control::get_icon("MiniTransform", "EditorIcons"),
Control::get_icon("MiniColor", "EditorIcons"),
Control::get_icon("MiniImage", "EditorIcons"),
Control::get_icon("MiniPath", "EditorIcons"),
Control::get_icon("MiniRid", "EditorIcons"),
Control::get_icon("MiniObject", "EditorIcons"),

35
modules/webp/image_loader_webp.cpp
View file

@ -37,23 +37,23 @@
#include <webp/decode.h>
#include <webp/encode.h>
static PoolVector<uint8_t> _webp_lossy_pack(const Image &p_image, float p_quality) {
static PoolVector<uint8_t> _webp_lossy_pack(const Ref<Image> &p_image, float p_quality) {
ERR_FAIL_COND_V(p_image.empty(), PoolVector<uint8_t>());
ERR_FAIL_COND_V(p_image.is_null() || p_image->empty(), PoolVector<uint8_t>());
Image img = p_image;
if (img.detect_alpha())
img.convert(Image::FORMAT_RGBA8);
Ref<Image> img = p_image->duplicate();
if (img->detect_alpha())
img->convert(Image::FORMAT_RGBA8);
else
img.convert(Image::FORMAT_RGB8);
img->convert(Image::FORMAT_RGB8);
Size2 s(img.get_width(), img.get_height());
PoolVector<uint8_t> data = img.get_data();
Size2 s(img->get_width(), img->get_height());
PoolVector<uint8_t> data = img->get_data();
PoolVector<uint8_t>::Read r = data.read();
uint8_t *dst_buff = NULL;
size_t dst_size = 0;
if (img.get_format() == Image::FORMAT_RGB8) {
if (img->get_format() == Image::FORMAT_RGB8) {
dst_size = WebPEncodeRGB(r.ptr(), s.width, s.height, 3 * s.width, CLAMP(p_quality * 100.0, 0, 100.0), &dst_buff);
} else {
@ -74,17 +74,17 @@ static PoolVector<uint8_t> _webp_lossy_pack(const Image &p_image, float p_qualit
return dst;
}
static Image _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) {
static Ref<Image> _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) {
int size = p_buffer.size() - 4;
ERR_FAIL_COND_V(size <= 0, Image());
ERR_FAIL_COND_V(size <= 0, Ref<Image>());
PoolVector<uint8_t>::Read r = p_buffer.read();
ERR_FAIL_COND_V(r[0] != 'W' || r[1] != 'E' || r[2] != 'B' || r[3] != 'P', Image());
ERR_FAIL_COND_V(r[0] != 'W' || r[1] != 'E' || r[2] != 'B' || r[3] != 'P', Ref<Image>());
WebPBitstreamFeatures features;
if (WebPGetFeatures(&r[4], size, &features) != VP8_STATUS_OK) {
ERR_EXPLAIN("Error unpacking WEBP image:");
ERR_FAIL_V(Image());
ERR_FAIL_V(Ref<Image>());
}
/*
@ -107,14 +107,15 @@ static Image _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) {
}
//ERR_EXPLAIN("Error decoding webp! - "+p_file);
ERR_FAIL_COND_V(errdec, Image());
ERR_FAIL_COND_V(errdec, Ref<Image>());
dst_w = PoolVector<uint8_t>::Write();
return Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image);
Ref<Image> img = memnew(Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image));
return img;
}
Error ImageLoaderWEBP::load_image(Image *p_image, FileAccess *f) {
Error ImageLoaderWEBP::load_image(Ref<Image> p_image, FileAccess *f) {
uint32_t size = f->get_len();
PoolVector<uint8_t> src_image;
@ -160,7 +161,7 @@ Error ImageLoaderWEBP::load_image(Image *p_image, FileAccess *f) {
src_r = PoolVector<uint8_t>::Read();
dst_w = PoolVector<uint8_t>::Write();
*p_image = Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image);
p_image->create(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image);
return OK;
}

2
modules/webp/image_loader_webp.h
View file

@ -38,7 +38,7 @@
class ImageLoaderWEBP : public ImageFormatLoader {
public:
virtual Error load_image(Image *p_image, FileAccess *f);
virtual Error load_image(Ref<Image> p_image, FileAccess *f);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
ImageLoaderWEBP();
};

2
platform/android/export/export.cpp
View file

@ -3523,7 +3523,7 @@ public:
EditorExportAndroid() {
Image img(_android_logo);
Ref<Image> img = memnew(Image(_android_logo));
logo = Ref<ImageTexture>(memnew(ImageTexture));
logo->create_from_image(img);

2
platform/javascript/export/export.cpp
View file

@ -316,7 +316,7 @@ Error EditorExportPlatformJavaScript::run(const Ref<EditorExportPreset> &p_prese
EditorExportPlatformJavaScript::EditorExportPlatformJavaScript() {
Image img(_javascript_logo);
Ref<Image> img = memnew(Image(_javascript_logo));
logo.instance();
logo->create_from_image(img);
}

2
platform/osx/os_osx.h
View file

@ -151,7 +151,7 @@ public:
virtual Size2 get_window_size() const;
virtual void set_icon(const Image &p_icon);
virtual void set_icon(const Ref<Image> &p_icon);
virtual MainLoop *get_main_loop() const;

19
platform/osx/os_osx.mm
View file

@ -1227,26 +1227,27 @@ void OS_OSX::set_window_title(const String &p_title) {
[window_object setTitle:[NSString stringWithUTF8String:p_title.utf8().get_data()]];
}
void OS_OSX::set_icon(const Image &p_icon) {
void OS_OSX::set_icon(const Ref<Image> &p_icon) {
Image img = p_icon;
img.convert(Image::FORMAT_RGBA8);
Ref<Image> img = p_icon;
img = img->duplicate();
img->convert(Image::FORMAT_RGBA8);
NSBitmapImageRep *imgrep = [[[NSBitmapImageRep alloc]
initWithBitmapDataPlanes:NULL
pixelsWide:p_icon.get_width()
pixelsHigh:p_icon.get_height()
pixelsWide:img->get_width()
pixelsHigh:img->get_height()
bitsPerSample:8
samplesPerPixel:4
hasAlpha:YES
isPlanar:NO
colorSpaceName:NSDeviceRGBColorSpace
bytesPerRow:p_icon.get_width() * 4
bytesPerRow:img->get_width() * 4
bitsPerPixel:32] autorelease];
ERR_FAIL_COND(imgrep == nil);
uint8_t *pixels = [imgrep bitmapData];
int len = img.get_width() * img.get_height();
PoolVector<uint8_t> data = img.get_data();
int len = img->get_width() * img->get_height();
PoolVector<uint8_t> data = img->get_data();
PoolVector<uint8_t>::Read r = data.read();
/* Premultiply the alpha channel */
@ -1258,7 +1259,7 @@ void OS_OSX::set_icon(const Image &p_icon) {
pixels[i * 4 + 3] = alpha;
}
NSImage *nsimg = [[[NSImage alloc] initWithSize:NSMakeSize(img.get_width(), img.get_height())] autorelease];
NSImage *nsimg = [[[NSImage alloc] initWithSize:NSMakeSize(img->get_width(), img->get_height())] autorelease];
ERR_FAIL_COND(nsimg == nil);
[nsimg addRepresentation:imgrep];

2
platform/uwp/os_uwp.cpp
View file

@ -746,7 +746,7 @@ String OSUWP::get_executable_path() const {
return "";
}
void OSUWP::set_icon(const Image &p_icon) {
void OSUWP::set_icon(const Ref<Image> &p_icon) {
}
bool OSUWP::has_environment(const String &p_var) const {

2
platform/uwp/os_uwp.h
View file

@ -227,7 +227,7 @@ public:
virtual String get_clipboard() const;
void set_cursor_shape(CursorShape p_shape);
void set_icon(const Image &p_icon);
void set_icon(const Ref<Image> &p_icon);
virtual String get_executable_path() const;

2
platform/windows/export/export.cpp
View file

@ -35,7 +35,7 @@ void register_windows_exporter() {
Ref<EditorExportPlatformPC> platform;
platform.instance();
Image img(_windows_logo);
Ref<Image> img = memnew(Image(_windows_logo));
Ref<ImageTexture> logo;
logo.instance();
logo->create_from_image(img);

15
platform/windows/os_windows.cpp
View file

@ -1996,13 +1996,14 @@ String OS_Windows::get_executable_path() const {
return s;
}
void OS_Windows::set_icon(const Image &p_icon) {
void OS_Windows::set_icon(const Ref<Image> &p_icon) {
Image icon = p_icon;
if (icon.get_format() != Image::FORMAT_RGBA8)
icon.convert(Image::FORMAT_RGBA8);
int w = icon.get_width();
int h = icon.get_height();
ERR_FAIL_COND(!p_icon.is_valid());
Ref<Image> icon = p_icon->duplicate();
if (icon->get_format() != Image::FORMAT_RGBA8)
icon->convert(Image::FORMAT_RGBA8);
int w = icon->get_width();
int h = icon->get_height();
/* Create temporary bitmap buffer */
int icon_len = 40 + h * w * 4;
@ -2023,7 +2024,7 @@ void OS_Windows::set_icon(const Image &p_icon) {
encode_uint32(0, &icon_bmp[36]);
uint8_t *wr = &icon_bmp[40];
PoolVector<uint8_t>::Read r = icon.get_data().read();
PoolVector<uint8_t>::Read r = icon->get_data().read();
for (int i = 0; i < h; i++) {

2
platform/windows/os_windows.h
View file

@ -254,7 +254,7 @@ public:
virtual String get_clipboard() const;
void set_cursor_shape(CursorShape p_shape);
void set_icon(const Image &p_icon);
void set_icon(const Ref<Image> &p_icon);
virtual String get_executable_path() const;

2
platform/x11/export/export.cpp
View file

@ -37,7 +37,7 @@ void register_x11_exporter() {
Ref<EditorExportPlatformPC> platform;
platform.instance();
Image img(_x11_logo);
Ref<Image> img = memnew(Image(_x11_logo));
Ref<ImageTexture> logo;
logo.instance();
logo->create_from_image(img);

14
platform/x11/os_x11.cpp
View file

@ -1857,15 +1857,15 @@ void OS_X11::alert(const String &p_alert, const String &p_title) {
execute("/usr/bin/xmessage", args, true);
}
void OS_X11::set_icon(const Image &p_icon) {
void OS_X11::set_icon(const Ref<Image> &p_icon) {
Atom net_wm_icon = XInternAtom(x11_display, "_NET_WM_ICON", False);
if (!p_icon.empty()) {
Image img = p_icon;
img.convert(Image::FORMAT_RGBA8);
if (p_icon.is_valid()) {
Ref<Image> img = p_icon->duplicate();
img->convert(Image::FORMAT_RGBA8);
int w = img.get_width();
int h = img.get_height();
int w = img->get_width();
int h = img->get_height();
// We're using long to have wordsize (32Bit build -> 32 Bits, 64 Bit build -> 64 Bits
Vector<long> pd;
@ -1875,7 +1875,7 @@ void OS_X11::set_icon(const Image &p_icon) {
pd[0] = w;
pd[1] = h;
PoolVector<uint8_t>::Read r = img.get_data().read();
PoolVector<uint8_t>::Read r = img->get_data().read();
long *wr = &pd[2];
uint8_t const *pr = r.ptr();

2
platform/x11/os_x11.h
View file

@ -206,7 +206,7 @@ public:
virtual int get_mouse_button_state() const;
virtual void set_window_title(const String &p_title);
virtual void set_icon(const Image &p_icon);
virtual void set_icon(const Ref<Image> &p_icon);
virtual MainLoop *get_main_loop() const;

1754
scene/3d/baked_light_instance.cpp
View file

File diff suppressed because it is too large Load diff

199
scene/3d/baked_light_instance.h
View file

@ -1,199 +0,0 @@
/*************************************************************************/
/* baked_light_instance.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2017 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 BAKED_LIGHT_INSTANCE_H
#define BAKED_LIGHT_INSTANCE_H
#include "scene/3d/multimesh_instance.h"
#include "scene/3d/visual_instance.h"
#include "scene/resources/baked_light.h"
class BakedLightBaker;
class Light;
class BakedLight : public VisualInstance {
GDCLASS(BakedLight, VisualInstance);
public:
enum DebugMode {
DEBUG_ALBEDO,
DEBUG_LIGHT
};
private:
RID baked_light;
int cell_subdiv;
Rect3 bounds;
int cells_per_axis;
enum {
CHILD_EMPTY = 0xFFFFFFFF,
};
/* BAKE DATA */
struct BakeCell {
uint32_t childs[8];
float albedo[3]; //albedo in RGB24
float light[3]; //accumulated light in 16:16 fixed point (needs to be integer for moving lights fast)
float radiance[3]; //accumulated light in 16:16 fixed point (needs to be integer for moving lights fast)
uint32_t used_sides;
float alpha; //used for upsampling
uint32_t light_pass; //used for baking light
BakeCell() {
for (int i = 0; i < 8; i++) {
childs[i] = 0xFFFFFFFF;
}
for (int i = 0; i < 3; i++) {
light[i] = 0;
albedo[i] = 0;
radiance[i] = 0;
}
alpha = 0;
light_pass = 0;
used_sides = 0;
}
};
int bake_texture_size;
int color_scan_cell_width;
struct MaterialCache {
//128x128 textures
Vector<Color> albedo;
Vector<Color> emission;
};
Vector<Color> _get_bake_texture(Image &p_image, const Color &p_color);
Map<Ref<Material>, MaterialCache> material_cache;
MaterialCache _get_material_cache(Ref<Material> p_material);
int bake_cells_alloc;
int bake_cells_used;
int zero_alphas;
Vector<int> bake_cells_level_used;
PoolVector<BakeCell> bake_cells;
PoolVector<BakeCell>::Write bake_cells_write;
void _plot_face(int p_idx, int p_level, const Vector3 *p_vtx, const Vector2 *p_uv, const MaterialCache &p_material, const Rect3 &p_aabb);
void _fixup_plot(int p_idx, int p_level, int p_x, int p_y, int p_z);
void _bake_add_mesh(const Transform &p_xform, Ref<Mesh> &p_mesh);
void _bake_add_to_aabb(const Transform &p_xform, Ref<Mesh> &p_mesh, bool &first);
void _debug_mesh(int p_idx, int p_level, const Rect3 &p_aabb, DebugMode p_mode, Ref<MultiMesh> &p_multimesh, int &idx);
void _debug_mesh_albedo();
void _debug_mesh_light();
_FORCE_INLINE_ int _find_cell(int x, int y, int z);
int _plot_ray(const Vector3 &p_from, const Vector3 &p_to);
uint32_t light_pass;
void _bake_directional(int p_idx, int p_level, int p_x, int p_y, int p_z, const Vector3 &p_dir, const Color &p_color, int p_sign);
void _upscale_light(int p_idx, int p_level);
void _bake_light(Light *p_light);
Color _cone_trace(const Vector3 &p_from, const Vector3 &p_dir, float p_half_angle);
void _bake_radiance(int p_idx, int p_level, int p_x, int p_y, int p_z);
friend class GeometryInstance;
Set<GeometryInstance *> geometries;
friend class Light;
Set<Light *> lights;
protected:
static void _bind_methods();
public:
void set_cell_subdiv(int p_subdiv);
int get_cell_subdiv() const;
void bake();
void bake_lights();
void bake_radiance();
void create_debug_mesh(DebugMode p_mode);
virtual Rect3 get_aabb() const;
virtual PoolVector<Face3> get_faces(uint32_t p_usage_flags) const;
String get_configuration_warning() const;
BakedLight();
~BakedLight();
};
#if 0
class BakedLightSampler : public VisualInstance {
GDCLASS(BakedLightSampler,VisualInstance);
public:
enum Param {
PARAM_RADIUS=VS::BAKED_LIGHT_SAMPLER_RADIUS,
PARAM_STRENGTH=VS::BAKED_LIGHT_SAMPLER_STRENGTH,
PARAM_ATTENUATION=VS::BAKED_LIGHT_SAMPLER_ATTENUATION,
PARAM_DETAIL_RATIO=VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO,
PARAM_MAX=VS::BAKED_LIGHT_SAMPLER_MAX
};
protected:
RID base;
float params[PARAM_MAX];
int resolution;
static void _bind_methods();
public:
virtual AABB get_aabb() const;
virtual PoolVector<Face3> get_faces(uint32_t p_usage_flags) const;
void set_param(Param p_param,float p_value);
float get_param(Param p_param) const;
void set_resolution(int p_resolution);
int get_resolution() const;
BakedLightSampler();
~BakedLightSampler();
};
VARIANT_ENUM_CAST( BakedLightSampler::Param );
#endif
#endif // BAKED_LIGHT_H

20
scene/3d/gi_probe.cpp
View file

@ -881,11 +881,11 @@ void GIProbe::_fixup_plot(int p_idx, int p_level, int p_x, int p_y, int p_z, Bak
}
}
Vector<Color> GIProbe::_get_bake_texture(Image &p_image, const Color &p_color) {
Vector<Color> GIProbe::_get_bake_texture(Ref<Image> p_image, const Color &p_color) {
Vector<Color> ret;
if (p_image.empty()) {
if (p_image.is_null()) {
ret.resize(bake_texture_size * bake_texture_size);
for (int i = 0; i < bake_texture_size * bake_texture_size; i++) {
@ -895,14 +895,14 @@ Vector<Color> GIProbe::_get_bake_texture(Image &p_image, const Color &p_color) {
return ret;
}
if (p_image.is_compressed()) {
if (p_image->is_compressed()) {
print_line("DECOMPRESSING!!!!");
p_image.decompress();
p_image->decompress();
}
p_image.convert(Image::FORMAT_RGBA8);
p_image.resize(bake_texture_size, bake_texture_size, Image::INTERPOLATE_CUBIC);
p_image->convert(Image::FORMAT_RGBA8);
p_image->resize(bake_texture_size, bake_texture_size, Image::INTERPOLATE_CUBIC);
PoolVector<uint8_t>::Read r = p_image.get_data().read();
PoolVector<uint8_t>::Read r = p_image->get_data().read();
ret.resize(bake_texture_size * bake_texture_size);
for (int i = 0; i < bake_texture_size * bake_texture_size; i++) {
@ -934,7 +934,7 @@ GIProbe::Baker::MaterialCache GIProbe::_get_material_cache(Ref<Material> p_mater
Ref<Texture> albedo_tex = mat->get_texture(SpatialMaterial::TEXTURE_ALBEDO);
Image img_albedo;
Ref<Image> img_albedo;
if (albedo_tex.is_valid()) {
img_albedo = albedo_tex->get_data();
@ -950,7 +950,7 @@ GIProbe::Baker::MaterialCache GIProbe::_get_material_cache(Ref<Material> p_mater
emission_col.g *= mat->get_emission_energy();
emission_col.b *= mat->get_emission_energy();
Image img_emission;
Ref<Image> img_emission;
if (emission_tex.is_valid()) {
@ -960,7 +960,7 @@ GIProbe::Baker::MaterialCache GIProbe::_get_material_cache(Ref<Material> p_mater
mc.emission = _get_bake_texture(img_emission, emission_col);
} else {
Image empty;
Ref<Image> empty;
mc.albedo = _get_bake_texture(empty, Color(0.7, 0.7, 0.7));
mc.emission = _get_bake_texture(empty, Color(0, 0, 0));

4
scene/3d/gi_probe.h
View file

@ -134,7 +134,7 @@ private:
Vector<Color> emission;
};
Vector<Color> _get_bake_texture(Image &p_image, const Color &p_color);
Vector<Color> _get_bake_texture(Ref<Image> p_image, const Color &p_color);
Map<Ref<Material>, MaterialCache> material_cache;
MaterialCache _get_material_cache(Ref<Material> p_material);
int leaf_voxel_count;
@ -170,7 +170,7 @@ private:
int color_scan_cell_width;
int bake_texture_size;
Vector<Color> _get_bake_texture(Image &p_image, const Color &p_color);
Vector<Color> _get_bake_texture(Ref<Image> p_image, const Color &p_color);
Baker::MaterialCache _get_material_cache(Ref<Material> p_material, Baker *p_baker);
void _plot_face(int p_idx, int p_level, int p_x, int p_y, int p_z, const Vector3 *p_vtx, const Vector2 *p_uv, const Baker::MaterialCache &p_material, const Rect3 &p_aabb, Baker *p_baker);
void _plot_mesh(const Transform &p_xform, Ref<Mesh> &p_mesh, Baker *p_baker, const Vector<Ref<Material> > &p_materials, const Ref<Material> &p_override_material);

20
scene/3d/light.cpp
View file

@ -29,7 +29,6 @@
/*************************************************************************/
#include "light.h"
#include "baked_light_instance.h"
#include "global_config.h"
#include "scene/resources/surface_tool.h"
@ -166,26 +165,9 @@ void Light::_notification(int p_what) {
if (p_what == NOTIFICATION_ENTER_TREE) {
_update_visibility();
Node *node = this;
while (node) {
baked_light = node->cast_to<BakedLight>();
if (baked_light) {
baked_light->lights.insert(this);
break;
}
node = node->get_parent();
}
}
if (p_what == NOTIFICATION_EXIT_TREE) {
if (baked_light) {
baked_light->lights.erase(this);
}
}
}
@ -262,8 +244,6 @@ Light::Light(VisualServer::LightType p_type) {
light = VisualServer::get_singleton()->light_create(p_type);
VS::get_singleton()->instance_set_base(get_instance(), light);
baked_light = NULL;
editor_only = false;
set_color(Color(1, 1, 1, 1));
set_shadow(false);

1
scene/3d/light.h
View file

@ -75,7 +75,6 @@ private:
bool editor_only;
void _update_visibility();
BakedLight *baked_light;
// bind helpers
protected:

14
scene/gui/color_picker.cpp
View file

@ -178,7 +178,7 @@ void ColorPicker::_update_presets() {
}
}
Image i(size.x * presets.size(), size.y, false, Image::FORMAT_RGB8, img);
Ref<Image> i = memnew(Image(size.x * presets.size(), size.y, false, Image::FORMAT_RGB8, img));
Ref<ImageTexture> t;
t.instance();
@ -399,16 +399,16 @@ void ColorPicker::_screen_input(const InputEvent &ev) {
Viewport *r = get_tree()->get_root();
if (!r->get_visible_rect().has_point(Point2(mev.global_x, mev.global_y)))
return;
Image img = r->get_screen_capture();
if (!img.empty()) {
Ref<Image> img = r->get_screen_capture();
if (!img.is_null()) {
last_capture = img;
r->queue_screen_capture();
}
if (!last_capture.empty()) {
int pw = last_capture.get_format() == Image::FORMAT_RGBA8 ? 4 : 3;
int ofs = (mev.global_y * last_capture.get_width() + mev.global_x) * pw;
if (last_capture.is_valid() && !last_capture->empty()) {
int pw = last_capture->get_format() == Image::FORMAT_RGBA8 ? 4 : 3;
int ofs = (mev.global_y * last_capture->get_width() + mev.global_x) * pw;
PoolVector<uint8_t>::Read r = last_capture.get_data().read();
PoolVector<uint8_t>::Read r = last_capture->get_data().read();
Color c(r[ofs + 0] / 255.0, r[ofs + 1] / 255.0, r[ofs + 2] / 255.0);

2
scene/gui/color_picker.h
View file

@ -47,7 +47,7 @@ class ColorPicker : public BoxContainer {
private:
Control *screen;
Image last_capture;
Ref<Image> last_capture;
Control *uv_edit;
Control *w_edit;
TextureRect *sample;

3
scene/gui/color_ramp_edit.cpp
View file

@ -42,7 +42,8 @@ ColorRampEdit::ColorRampEdit() {
add_child(popup);
checker = Ref<ImageTexture>(memnew(ImageTexture));
checker->create_from_image(Image(checker_bg_png), ImageTexture::FLAG_REPEAT);
Ref<Image> img = memnew(Image(checker_bg_png));
checker->create_from_image(img, ImageTexture::FLAG_REPEAT);
}
int ColorRampEdit::_get_point_from_pos(int x) {

2
scene/gui/video_player.h
View file

@ -59,7 +59,7 @@ class VideoPlayer : public Control {
RID stream_rid;
Ref<ImageTexture> texture;
Image last_frame;
Ref<Image> last_frame;
AudioRBResampler resampler;

4
scene/main/viewport.cpp
View file

@ -1226,10 +1226,10 @@ void Viewport::queue_screen_capture() {
//VS::get_singleton()->viewport_queue_screen_capture(viewport);
}
Image Viewport::get_screen_capture() const {
Ref<Image> Viewport::get_screen_capture() const {
//return VS::get_singleton()->viewport_get_screen_capture(viewport);
return Image();
return Ref<Image>();
}
Ref<ViewportTexture> Viewport::get_texture() const {

2
scene/main/viewport.h
View file

@ -383,7 +383,7 @@ public:
Vector2 get_camera_rect_size() const;
void queue_screen_capture();
Image get_screen_capture() const;
Ref<Image> get_screen_capture() const;
void set_use_own_world(bool p_world);
bool is_using_own_world() const;

4
scene/register_scene_types.cpp
View file

@ -212,7 +212,7 @@
#include "scene/resources/environment.h"
#include "scene/3d/area.h"
#include "scene/3d/baked_light_instance.h"
#include "scene/3d/body_shape.h"
#include "scene/3d/immediate_geometry.h"
#include "scene/3d/multimesh_instance.h"
@ -452,7 +452,7 @@ void register_scene_types() {
ClassDB::register_class<PathFollow>();
ClassDB::register_class<VisibilityNotifier>();
ClassDB::register_class<VisibilityEnabler>();
ClassDB::register_class<BakedLight>();
// ClassDB::register_class<BakedLight>();
//ClassDB::register_type<BakedLightSampler>();
ClassDB::register_class<WorldEnvironment>();
ClassDB::register_class<RemoteTransform>();

31
scene/resources/baked_light.cpp
View file

@ -1,31 +0,0 @@
/*************************************************************************/
/* baked_light.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "baked_light.h"
#include "servers/visual_server.h"

36
scene/resources/baked_light.h
View file

@ -1,36 +0,0 @@
/*************************************************************************/
/* baked_light.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2017 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 BAKED_LIGHT_H
#define BAKED_LIGHT_H
#include "resource.h"
#include "scene/resources/texture.h"
#endif // BAKED_LIGHT_H

14
scene/resources/bit_mask.cpp
View file

@ -41,16 +41,16 @@ void BitMap::create(const Size2 &p_size) {
zeromem(bitmask.ptr(), bitmask.size());
}
void BitMap::create_from_image_alpha(const Image &p_image) {
void BitMap::create_from_image_alpha(const Ref<Image> &p_image) {
ERR_FAIL_COND(p_image.empty());
Image img = p_image;
img.convert(Image::FORMAT_LA8);
ERR_FAIL_COND(img.get_format() != Image::FORMAT_LA8);
ERR_FAIL_COND(p_image.is_null() || p_image->empty());
Ref<Image> img = p_image->duplicate();
img->convert(Image::FORMAT_LA8);
ERR_FAIL_COND(img->get_format() != Image::FORMAT_LA8);
create(Size2(img.get_width(), img.get_height()));
create(Size2(img->get_width(), img->get_height()));
PoolVector<uint8_t>::Read r = img.get_data().read();
PoolVector<uint8_t>::Read r = img->get_data().read();
uint8_t *w = bitmask.ptr();
for (int i = 0; i < width * height; i++) {

3
scene/resources/bit_mask.h
View file

@ -30,6 +30,7 @@
#ifndef BIT_MASK_H
#define BIT_MASK_H
#include "image.h" 0
#include "io/resource_loader.h"
#include "resource.h"
@ -51,7 +52,7 @@ protected:
public:
void create(const Size2 &p_size);
void create_from_image_alpha(const Image &p_image);
void create_from_image_alpha(const Ref<Image> &p_image);
void set_bit(const Point2 &p_pos, bool p_value);
bool get_bit(const Point2 &p_pos) const;

Some files were not shown because too many files have changed in this diff Show more