godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2026-01-05 06:11:29 +03:00
Code Issues Packages Projects Releases Wiki Activity

Add GradientTexture2D

Browse Source 
Co-authored-by: Mariano Javier Suligoy <marianognu.easyrpg@gmail.com>
Co-authored-by: Andrii Doroshenko <xrayez@gmail.com>
This commit is contained in:
Hendrik Brucker
2021-10-12 16:22:30 +02:00
parent df376750ce
commit cd37af4e4c
5 changed files with 382 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

255
scene/resources/texture.cpp
View File

@@ -32,6 +32,7 @@
#include "core/core_string_names.h"
#include "core/io/image_loader.h"
#include "core/math/geometry_2d.h"
#include "core/os/os.h"
#include "mesh.h"
#include "scene/resources/bit_map.h"
@@ -1867,6 +1868,260 @@ Ref<Image> GradientTexture::get_image() const {
return RenderingServer::get_singleton()->texture_2d_get(texture);
}
GradientTexture2D::GradientTexture2D() {
_queue_update();
}
GradientTexture2D::~GradientTexture2D() {
if (texture.is_valid()) {
RS::get_singleton()->free(texture);
}
}
void GradientTexture2D::set_gradient(Ref<Gradient> p_gradient) {
if (gradient == p_gradient) {
return;
}
if (gradient.is_valid()) {
gradient->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &GradientTexture2D::_queue_update));
}
gradient = p_gradient;
if (gradient.is_valid()) {
gradient->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &GradientTexture2D::_queue_update));
}
_queue_update();
}
Ref<Gradient> GradientTexture2D::get_gradient() const {
return gradient;
}
void GradientTexture2D::_queue_update() {
if (update_pending) {
return;
}
update_pending = true;
call_deferred("_update");
}
void GradientTexture2D::_update() {
update_pending = false;
if (gradient.is_null()) {
return;
}
Ref<Image> image;
image.instantiate();
if (gradient->get_points_count() <= 1) { // No need to interpolate.
image->create(width, height, false, (use_hdr) ? Image::FORMAT_RGBAF : Image::FORMAT_RGBA8);
image->fill((gradient->get_points_count() == 1) ? gradient->get_color(0) : Color(0, 0, 0, 1));
} else {
if (use_hdr) {
image->create(width, height, false, Image::FORMAT_RGBAF);
Gradient &g = **gradient;
// `create()` isn't available for non-uint8_t data, so fill in the data manually.
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float ofs = _get_gradient_offset_at(x, y);
image->set_pixel(x, y, g.get_color_at_offset(ofs));
}
}
} else {
Vector<uint8_t> data;
data.resize(width * height * 4);
{
uint8_t *wd8 = data.ptrw();
Gradient &g = **gradient;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float ofs = _get_gradient_offset_at(x, y);
const Color &c = g.get_color_at_offset(ofs);
wd8[(x + (y * width)) * 4 + 0] = uint8_t(CLAMP(c.r * 255.0, 0, 255));
wd8[(x + (y * width)) * 4 + 1] = uint8_t(CLAMP(c.g * 255.0, 0, 255));
wd8[(x + (y * width)) * 4 + 2] = uint8_t(CLAMP(c.b * 255.0, 0, 255));
wd8[(x + (y * width)) * 4 + 3] = uint8_t(CLAMP(c.a * 255.0, 0, 255));
}
}
}
image->create(width, height, false, Image::FORMAT_RGBA8, data);
}
}
if (texture.is_valid()) {
RID new_texture = RS::get_singleton()->texture_2d_create(image);
RS::get_singleton()->texture_replace(texture, new_texture);
} else {
texture = RS::get_singleton()->texture_2d_create(image);
}
emit_changed();
}
float GradientTexture2D::_get_gradient_offset_at(int x, int y) const {
if (fill_to == fill_from) {
return 0;
}
float ofs = 0;
Vector2 pos;
if (width > 1) {
pos.x = static_cast<float>(x) / (width - 1);
}
if (height > 1) {
pos.y = static_cast<float>(y) / (height - 1);
}
if (fill == Fill::FILL_LINEAR) {
Vector2 segment[2];
segment[0] = fill_from;
segment[1] = fill_to;
Vector2 closest = Geometry2D::get_closest_point_to_segment_uncapped(pos, &segment[0]);
ofs = (closest - fill_from).length() / (fill_to - fill_from).length();
if ((closest - fill_from).dot(fill_to - fill_from) < 0) {
ofs *= -1;
}
} else if (fill == Fill::FILL_RADIAL) {
ofs = (pos - fill_from).length() / (fill_to - fill_from).length();
}
if (repeat == Repeat::REPEAT_NONE) {
ofs = CLAMP(ofs, 0.0, 1.0);
} else if (repeat == Repeat::REPEAT) {
ofs = Math::fmod(ofs, 1.0f);
if (ofs < 0) {
ofs = 1 + ofs;
}
} else if (repeat == Repeat::REPEAT_MIRROR) {
ofs = Math::abs(ofs);
ofs = Math::fmod(ofs, 2.0f);
if (ofs > 1.0) {
ofs = 2.0 - ofs;
}
}
return ofs;
}
void GradientTexture2D::set_width(int p_width) {
width = p_width;
_queue_update();
}
int GradientTexture2D::get_width() const {
return width;
}
void GradientTexture2D::set_height(int p_height) {
height = p_height;
_queue_update();
}
int GradientTexture2D::get_height() const {
return height;
}
void GradientTexture2D::set_use_hdr(bool p_enabled) {
if (p_enabled == use_hdr) {
return;
}
use_hdr = p_enabled;
_queue_update();
}
bool GradientTexture2D::is_using_hdr() const {
return use_hdr;
}
void GradientTexture2D::set_fill_from(Vector2 p_fill_from) {
fill_from = p_fill_from;
_queue_update();
}
Vector2 GradientTexture2D::get_fill_from() const {
return fill_from;
}
void GradientTexture2D::set_fill_to(Vector2 p_fill_to) {
fill_to = p_fill_to;
_queue_update();
}
Vector2 GradientTexture2D::get_fill_to() const {
return fill_to;
}
void GradientTexture2D::set_fill(Fill p_fill) {
fill = p_fill;
_queue_update();
}
GradientTexture2D::Fill GradientTexture2D::get_fill() const {
return fill;
}
void GradientTexture2D::set_repeat(Repeat p_repeat) {
repeat = p_repeat;
_queue_update();
}
GradientTexture2D::Repeat GradientTexture2D::get_repeat() const {
return repeat;
}
RID GradientTexture2D::get_rid() const {
if (!texture.is_valid()) {
texture = RS::get_singleton()->texture_2d_placeholder_create();
}
return texture;
}
Ref<Image> GradientTexture2D::get_image() const {
if (!texture.is_valid()) {
return Ref<Image>();
}
return RenderingServer::get_singleton()->texture_2d_get(texture);
}
void GradientTexture2D::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_gradient", "gradient"), &GradientTexture2D::set_gradient);
ClassDB::bind_method(D_METHOD("get_gradient"), &GradientTexture2D::get_gradient);
ClassDB::bind_method(D_METHOD("set_width", "width"), &GradientTexture2D::set_width);
ClassDB::bind_method(D_METHOD("set_height", "height"), &GradientTexture2D::set_height);
ClassDB::bind_method(D_METHOD("set_use_hdr", "enabled"), &GradientTexture2D::set_use_hdr);
ClassDB::bind_method(D_METHOD("is_using_hdr"), &GradientTexture2D::is_using_hdr);
ClassDB::bind_method(D_METHOD("set_fill", "fill"), &GradientTexture2D::set_fill);
ClassDB::bind_method(D_METHOD("get_fill"), &GradientTexture2D::get_fill);
ClassDB::bind_method(D_METHOD("set_fill_from", "fill_from"), &GradientTexture2D::set_fill_from);
ClassDB::bind_method(D_METHOD("get_fill_from"), &GradientTexture2D::get_fill_from);
ClassDB::bind_method(D_METHOD("set_fill_to", "fill_to"), &GradientTexture2D::set_fill_to);
ClassDB::bind_method(D_METHOD("get_fill_to"), &GradientTexture2D::get_fill_to);
ClassDB::bind_method(D_METHOD("set_repeat", "repeat"), &GradientTexture2D::set_repeat);
ClassDB::bind_method(D_METHOD("get_repeat"), &GradientTexture2D::get_repeat);
ClassDB::bind_method(D_METHOD("_update"), &GradientTexture2D::_update);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "gradient", PROPERTY_HINT_RESOURCE_TYPE, "Gradient", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT), "set_gradient", "get_gradient");
ADD_PROPERTY(PropertyInfo(Variant::INT, "width", PROPERTY_HINT_RANGE, "1,2048,1,or_greater"), "set_width", "get_width");
ADD_PROPERTY(PropertyInfo(Variant::INT, "height", PROPERTY_HINT_RANGE, "1,2048,1,or_greater"), "set_height", "get_height");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_hdr"), "set_use_hdr", "is_using_hdr");
ADD_GROUP("Fill", "fill_");
ADD_PROPERTY(PropertyInfo(Variant::INT, "fill", PROPERTY_HINT_ENUM, "Linear,Radial"), "set_fill", "get_fill");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "fill_from"), "set_fill_from", "get_fill_from");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "fill_to"), "set_fill_to", "get_fill_to");
ADD_GROUP("Repeat", "repeat_");
ADD_PROPERTY(PropertyInfo(Variant::INT, "repeat", PROPERTY_HINT_ENUM, "No Repeat,Repeat,Mirror Repeat"), "set_repeat", "get_repeat");
BIND_ENUM_CONSTANT(FILL_LINEAR);
BIND_ENUM_CONSTANT(FILL_RADIAL);
BIND_ENUM_CONSTANT(REPEAT_NONE);
BIND_ENUM_CONSTANT(REPEAT);
BIND_ENUM_CONSTANT(REPEAT_MIRROR);
}
//////////////////////////////////////
void ProxyTexture::_bind_methods() {