Nixyri/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-11-22 12:12:28 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Remove obsolete LargeTexture, it's no longer useful since 3.x

Browse Source 
It existed in early Godot releases to allow working around hardware limitations
on max texture sizes (e.g. hardware limits of 1024x1024 pixels).

Nowadays the max texture size supported natively by Godot is 16384x16384, and
even low end mobile hardware should support at least 4096x4096.

The LargeTexture implementation is basically just an array with offsets, sizes
and textures and should be easy to replicate with a custom Texture resource if
needed - solving most of its bugs on the way as the implementation removed here
has various unimplemented or incomplete methods.
This commit is contained in:
Rémi Verschelde 2021-04-28 14:15:29 +02:00
parent f879a08a62
commit 0e93a1df79
No known key found for this signature in database
GPG Key ID: C3336907360768E1
9 changed files with 3 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
doc/classes/LargeTexture.xml
View File

@ -1,90 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="LargeTexture" inherits="Texture2D" version="4.0">
<brief_description>
A [Texture2D] capable of storing many smaller textures with offsets.
</brief_description>
<description>
A [Texture2D] capable of storing many smaller textures with offsets.
You can dynamically add pieces ([Texture2D]s) to this [LargeTexture] using different offsets.
</description>
<tutorials>
</tutorials>
<methods>
<method name="add_piece">
<return type="int">
</return>
<argument index="0" name="ofs" type="Vector2">
</argument>
<argument index="1" name="texture" type="Texture2D">
</argument>
<description>
Adds [code]texture[/code] to this [LargeTexture], starting on offset [code]ofs[/code].
</description>
</method>
<method name="clear">
<return type="void">
</return>
<description>
Clears the [LargeTexture].
</description>
</method>
<method name="get_piece_count" qualifiers="const">
<return type="int">
</return>
<description>
Returns the number of pieces currently in this [LargeTexture].
</description>
</method>
<method name="get_piece_offset" qualifiers="const">
<return type="Vector2">
</return>
<argument index="0" name="idx" type="int">
</argument>
<description>
Returns the offset of the piece with the index [code]idx[/code].
</description>
</method>
<method name="get_piece_texture" qualifiers="const">
<return type="Texture2D">
</return>
<argument index="0" name="idx" type="int">
</argument>
<description>
Returns the [Texture2D] of the piece with the index [code]idx[/code].
</description>
</method>
<method name="set_piece_offset">
<return type="void">
</return>
<argument index="0" name="idx" type="int">
</argument>
<argument index="1" name="ofs" type="Vector2">
</argument>
<description>
Sets the offset of the piece with the index [code]idx[/code] to [code]ofs[/code].
</description>
</method>
<method name="set_piece_texture">
<return type="void">
</return>
<argument index="0" name="idx" type="int">
</argument>
<argument index="1" name="texture" type="Texture2D">
</argument>
<description>
Sets the [Texture2D] of the piece with index [code]idx[/code] to [code]texture[/code].
</description>
</method>
<method name="set_size">
<return type="void">
</return>
<argument index="0" name="size" type="Vector2">
</argument>
<description>
Sets the size of this [LargeTexture].
</description>
</method>
</methods>
<constants>
</constants>
</class>

1
editor/icons/LargeTexture.svg
View File

@ -1 +0,0 @@
<svg height="16" viewBox="0 0 16 16" width="16" xmlns="http://www.w3.org/2000/svg"><path d="m1 1v1 2h1v-2h2v-1zm11 0v1h2v2h1v-3zm-3 5v1h-1v1h-2v1h-1v1h-1v1h2 2 2 2v-2h-1v-1-1h-1v-1zm-8 6v2 1h3v-1h-2v-2zm13 0v2h-2v1h3v-1-2z" fill="#e0e0e0" fill-opacity=".99608"/></svg>
Side by Side

Before

Width:  |  Height:  |  Size: 269 B

3
editor/plugins/canvas_item_editor_plugin.cpp
View File

@ -6518,8 +6518,7 @@ bool CanvasItemEditorViewport::can_drop_data(const Point2 &p_point, const Varian
type == "CurveTexture" ||
type == "GradientTexture" ||
type == "StreamTexture2D" ||
type == "AtlasTexture" ||
type == "LargeTexture") {
type == "AtlasTexture") {
Ref<Texture2D> texture = Ref<Texture2D>(Object::cast_to<Texture2D>(*res));
if (!texture.is_valid()) {
continue;

3
editor/plugins/editor_preview_plugins.cpp
View File

@ -81,7 +81,6 @@ bool EditorTexturePreviewPlugin::generate_small_preview_automatically() const {
Ref<Texture2D> EditorTexturePreviewPlugin::generate(const RES &p_from, const Size2 &p_size) const {
Ref<Image> img;
Ref<AtlasTexture> atex = p_from;
Ref<LargeTexture> ltex = p_from;
if (atex.is_valid()) {
Ref<Texture2D> tex = atex->get_atlas();
if (!tex.is_valid()) {
@ -94,8 +93,6 @@ Ref<Texture2D> EditorTexturePreviewPlugin::generate(const RES &p_from, const Siz
}
img = atlas->get_rect(atex->get_region());
} else if (ltex.is_valid()) {
img = ltex->to_image();
} else {
Ref<Texture2D> tex = p_from;
if (tex.is_valid()) {

2
editor/plugins/texture_editor_plugin.cpp
View File

@ -143,7 +143,7 @@ TextureEditor::~TextureEditor() {
//
bool EditorInspectorPluginTexture::can_handle(Object *p_object) {
return Object::cast_to<ImageTexture>(p_object) != nullptr || Object::cast_to<AtlasTexture>(p_object) != nullptr || Object::cast_to<StreamTexture2D>(p_object) != nullptr || Object::cast_to<LargeTexture>(p_object) != nullptr || Object::cast_to<AnimatedTexture>(p_object) != nullptr;
return Object::cast_to<ImageTexture>(p_object) != nullptr || Object::cast_to<AtlasTexture>(p_object) != nullptr || Object::cast_to<StreamTexture2D>(p_object) != nullptr || Object::cast_to<AnimatedTexture>(p_object) != nullptr;
}
void EditorInspectorPluginTexture::parse_begin(Object *p_object) {

2
editor/plugins/tile_set_editor_plugin.cpp
View File

@ -319,7 +319,7 @@ void TileSetEditor::_notification(int p_what) {
tool_editmode[EDITMODE_NAVIGATION]->set_icon(get_theme_icon("Navigation2D", "EditorIcons"));
tool_editmode[EDITMODE_BITMASK]->set_icon(get_theme_icon("PackedDataContainer", "EditorIcons"));
tool_editmode[EDITMODE_PRIORITY]->set_icon(get_theme_icon("MaterialPreviewLight1", "EditorIcons"));
tool_editmode[EDITMODE_ICON]->set_icon(get_theme_icon("LargeTexture", "EditorIcons"));
tool_editmode[EDITMODE_ICON]->set_icon(get_theme_icon("Image", "EditorIcons"));
tool_editmode[EDITMODE_Z_INDEX]->set_icon(get_theme_icon("Sort", "EditorIcons"));
scroll->add_theme_style_override("bg", get_theme_stylebox("bg", "Tree"));

1
scene/register_scene_types.cpp
View File

@ -729,7 +729,6 @@ void register_scene_types() {
ClassDB::register_class<ImageTexture>();
ClassDB::register_class<AtlasTexture>();
ClassDB::register_class<MeshTexture>();
ClassDB::register_class<LargeTexture>();
ClassDB::register_class<CurveTexture>();
ClassDB::register_class<GradientTexture>();
ClassDB::register_class<ProxyTexture>();

179
scene/resources/texture.cpp
View File

@ -1405,185 +1405,6 @@ MeshTexture::MeshTexture() {
//////////////////////////////////////////
int LargeTexture::get_width() const {
return size.width;
}
int LargeTexture::get_height() const {
return size.height;
}
RID LargeTexture::get_rid() const {
return RID();
}
bool LargeTexture::has_alpha() const {
for (int i = 0; i < pieces.size(); i++) {
if (pieces[i].texture->has_alpha()) {
return true;
}
}
return false;
}
int LargeTexture::add_piece(const Point2 &p_offset, const Ref<Texture2D> &p_texture) {
ERR_FAIL_COND_V(p_texture.is_null(), -1);
Piece p;
p.offset = p_offset;
p.texture = p_texture;
pieces.push_back(p);
return pieces.size() - 1;
}
void LargeTexture::set_piece_offset(int p_idx, const Point2 &p_offset) {
ERR_FAIL_INDEX(p_idx, pieces.size());
pieces.write[p_idx].offset = p_offset;
};
void LargeTexture::set_piece_texture(int p_idx, const Ref<Texture2D> &p_texture) {
ERR_FAIL_COND(p_texture == this);
ERR_FAIL_COND(p_texture.is_null());
ERR_FAIL_INDEX(p_idx, pieces.size());
pieces.write[p_idx].texture = p_texture;
};
void LargeTexture::set_size(const Size2 &p_size) {
size = p_size;
}
void LargeTexture::clear() {
pieces.clear();
size = Size2i();
}
Array LargeTexture::_get_data() const {
Array arr;
for (int i = 0; i < pieces.size(); i++) {
arr.push_back(pieces[i].offset);
arr.push_back(pieces[i].texture);
}
arr.push_back(Size2(size));
return arr;
}
void LargeTexture::_set_data(const Array &p_array) {
ERR_FAIL_COND(p_array.size() < 1);
ERR_FAIL_COND(!(p_array.size() & 1));
clear();
for (int i = 0; i < p_array.size() - 1; i += 2) {
add_piece(p_array[i], p_array[i + 1]);
}
size = Size2(p_array[p_array.size() - 1]);
}
int LargeTexture::get_piece_count() const {
return pieces.size();
}
Vector2 LargeTexture::get_piece_offset(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, pieces.size(), Vector2());
return pieces[p_idx].offset;
}
Ref<Texture2D> LargeTexture::get_piece_texture(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, pieces.size(), Ref<Texture2D>());
return pieces[p_idx].texture;
}
Ref<Image> LargeTexture::to_image() const {
Ref<Image> img = memnew(Image(this->get_width(), this->get_height(), false, Image::FORMAT_RGBA8));
for (int i = 0; i < pieces.size(); i++) {
Ref<Image> src_img = pieces[i].texture->get_image();
img->blit_rect(src_img, Rect2(0, 0, src_img->get_width(), src_img->get_height()), pieces[i].offset);
}
return img;
}
void LargeTexture::_bind_methods() {
ClassDB::bind_method(D_METHOD("add_piece", "ofs", "texture"), &LargeTexture::add_piece);
ClassDB::bind_method(D_METHOD("set_piece_offset", "idx", "ofs"), &LargeTexture::set_piece_offset);
ClassDB::bind_method(D_METHOD("set_piece_texture", "idx", "texture"), &LargeTexture::set_piece_texture);
ClassDB::bind_method(D_METHOD("set_size", "size"), &LargeTexture::set_size);
ClassDB::bind_method(D_METHOD("clear"), &LargeTexture::clear);
ClassDB::bind_method(D_METHOD("get_piece_count"), &LargeTexture::get_piece_count);
ClassDB::bind_method(D_METHOD("get_piece_offset", "idx"), &LargeTexture::get_piece_offset);
ClassDB::bind_method(D_METHOD("get_piece_texture", "idx"), &LargeTexture::get_piece_texture);
ClassDB::bind_method(D_METHOD("_set_data", "data"), &LargeTexture::_set_data);
ClassDB::bind_method(D_METHOD("_get_data"), &LargeTexture::_get_data);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_data", "_get_data");
}
void LargeTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
for (int i = 0; i < pieces.size(); i++) {
// TODO
pieces[i].texture->draw(p_canvas_item, pieces[i].offset + p_pos, p_modulate, p_transpose);
}
}
void LargeTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
//tiling not supported for this
if (size.x == 0 || size.y == 0) {
return;
}
Size2 scale = p_rect.size / size;
for (int i = 0; i < pieces.size(); i++) {
// TODO
pieces[i].texture->draw_rect(p_canvas_item, Rect2(pieces[i].offset * scale + p_rect.position, pieces[i].texture->get_size() * scale), false, p_modulate, p_transpose);
}
}
void LargeTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, bool p_clip_uv) const {
//tiling not supported for this
if (p_src_rect.size.x == 0 || p_src_rect.size.y == 0) {
return;
}
Size2 scale = p_rect.size / p_src_rect.size;
for (int i = 0; i < pieces.size(); i++) {
// TODO
Rect2 rect(pieces[i].offset, pieces[i].texture->get_size());
if (!p_src_rect.intersects(rect)) {
continue;
}
Rect2 local = p_src_rect.intersection(rect);
Rect2 target = local;
target.size *= scale;
target.position = p_rect.position + (p_src_rect.position + rect.position) * scale;
local.position -= rect.position;
pieces[i].texture->draw_rect_region(p_canvas_item, target, local, p_modulate, p_transpose, false);
}
}
bool LargeTexture::is_pixel_opaque(int p_x, int p_y) const {
for (int i = 0; i < pieces.size(); i++) {
// TODO
if (!pieces[i].texture.is_valid()) {
continue;
}
Rect2 rect(pieces[i].offset, pieces[i].texture->get_size());
if (rect.has_point(Point2(p_x, p_y))) {
return pieces[i].texture->is_pixel_opaque(p_x - rect.position.x, p_y - rect.position.y);
}
}
return true;
}
LargeTexture::LargeTexture() {
}
///////////////////
void CurveTexture::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_width", "width"), &CurveTexture::set_width);

45
scene/resources/texture.h
View File

@ -297,51 +297,6 @@ public:
MeshTexture();
};
class LargeTexture : public Texture2D {
GDCLASS(LargeTexture, Texture2D);
RES_BASE_EXTENSION("largetex");
protected:
struct Piece {
Point2 offset;
Ref<Texture2D> texture;
};
Vector<Piece> pieces;
Size2i size;
Array _get_data() const;
void _set_data(const Array &p_array);
static void _bind_methods();
public:
virtual int get_width() const override;
virtual int get_height() const override;
virtual RID get_rid() const override;
virtual bool has_alpha() const override;
int add_piece(const Point2 &p_offset, const Ref<Texture2D> &p_texture);
void set_piece_offset(int p_idx, const Point2 &p_offset);
void set_piece_texture(int p_idx, const Ref<Texture2D> &p_texture);
void set_size(const Size2 &p_size);
void clear();
int get_piece_count() const;
Vector2 get_piece_offset(int p_idx) const;
Ref<Texture2D> get_piece_texture(int p_idx) const;
Ref<Image> to_image() const;
virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const override;
virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const override;
virtual void draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false, bool p_clip_uv = true) const override;
bool is_pixel_opaque(int p_x, int p_y) const override;
LargeTexture();
};
class TextureLayered : public Texture {
GDCLASS(TextureLayered, Texture);