mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-11-27 09:16:35 +08:00
Code Issues Packages Projects Releases Wiki Activity
b44cb4e3b9
godot/scene/gui/texture_progress.cpp

420 lines
16 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/*************************************************************************/
/* texture_progress.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 20:16:55 +08:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/*************************************************************************/
Welcome in 2017, dear changelog reader! That year should bring the long-awaited OpenGL ES 3.0 compatible renderer with state-of-the-art rendering techniques tuned to work as low as middle end handheld devices - without compromising with the possibilities given for higher end desktop games of course. Great times ahead for the Godot community and the gamers that will play our games!
2017-01-02 05:01:57 +08:00
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
Add "Godot Engine contributors" copyright line
2017-04-08 06:11:42 +08:00
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
/* */
/* 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 "texture_progress.h"
Removes editor_hint from SceneTree
2017-08-19 07:02:56 +08:00
#include "engine.h"
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
void TextureProgress::set_under_texture(const Ref<Texture> &p_texture) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
under = p_texture;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
update();
minimum_size_changed();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Ref<Texture> TextureProgress::get_under_texture() const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return under;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
void TextureProgress::set_over_texture(const Ref<Texture> &p_texture) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
over = p_texture;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
update();
WIP new AudioServer, with buses, effects, etc.
2017-01-22 06:00:25 +08:00
if (under.is_null()) {
minimum_size_changed();
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Ref<Texture> TextureProgress::get_over_texture() const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return over;
}
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
void TextureProgress::set_stretch_margin(Margin p_margin, int p_size) {
ERR_FAIL_INDEX(p_margin, 4);
stretch_margin[p_margin] = p_size;
update();
minimum_size_changed();
}
int TextureProgress::get_stretch_margin(Margin p_margin) const {
ERR_FAIL_INDEX_V(p_margin, 4, 0);
return stretch_margin[p_margin];
}
void TextureProgress::set_nine_patch_stretch(bool p_stretch) {
nine_patch_stretch = p_stretch;
update();
minimum_size_changed();
}
bool TextureProgress::get_nine_patch_stretch() const {
return nine_patch_stretch;
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Size2 TextureProgress::get_minimum_size() const {
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
if (nine_patch_stretch)
return Size2(stretch_margin[MARGIN_LEFT] + stretch_margin[MARGIN_RIGHT], stretch_margin[MARGIN_TOP] + stretch_margin[MARGIN_BOTTOM]);
else if (under.is_valid())
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return under->get_size();
else if (over.is_valid())
return over->get_size();
else if (progress.is_valid())
return progress->get_size();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
return Size2(1, 1);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
void TextureProgress::set_progress_texture(const Ref<Texture> &p_texture) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
progress = p_texture;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
update();
minimum_size_changed();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Ref<Texture> TextureProgress::get_progress_texture() const {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
return progress;
}
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
Point2 TextureProgress::unit_val_to_uv(float val) {
if (progress.is_null())
return Point2();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
if (val < 0)
val += 1;
if (val > 1)
val -= 1;
Point2 p = get_relative_center();
if (val < 0.125)
return Point2(p.x + (1 - p.x) * val * 8, 0);
if (val < 0.25)
return Point2(1, p.y * (val - 0.125) * 8);
if (val < 0.375)
return Point2(1, p.y + (1 - p.y) * (val - 0.25) * 8);
if (val < 0.5)
return Point2(1 - (1 - p.x) * (val - 0.375) * 8, 1);
if (val < 0.625)
return Point2(p.x * (1 - (val - 0.5) * 8), 1);
if (val < 0.75)
return Point2(0, 1 - ((1 - p.y) * (val - 0.625) * 8));
if (val < 0.875)
return Point2(0, p.y - p.y * (val - 0.75) * 8);
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
else
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
return Point2(p.x * (val - 0.875) * 8, 0);
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Point2 TextureProgress::get_relative_center() {
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
if (progress.is_null())
return Point2();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Point2 p = progress->get_size() / 2;
p += rad_center_off;
p.x /= progress->get_width();
p.y /= progress->get_height();
p.x = CLAMP(p.x, 0, 1);
p.y = CLAMP(p.y, 0, 1);
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
return p;
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
void TextureProgress::draw_nine_patch_stretched(const Ref<Texture> &p_texture, FillMode p_mode, double p_ratio) {
Vector2 texture_size = p_texture->get_size();
Vector2 topleft = Vector2(stretch_margin[MARGIN_LEFT], stretch_margin[MARGIN_TOP]);
Vector2 bottomright = Vector2(stretch_margin[MARGIN_RIGHT], stretch_margin[MARGIN_BOTTOM]);
Rect2 src_rect = Rect2(Point2(), texture_size);
Rect2 dst_rect = Rect2(Point2(), get_size());
if (p_ratio < 1.0) {
// Drawing a partially-filled 9-patch is a little tricky -
// texture is divided by 3 sections toward fill direction,
// then middle section is streching while the other two aren't.
double width_total = 0.0;
double width_texture = 0.0;
double first_section_size = 0.0;
double last_section_size = 0.0;
switch (mode) {
case FILL_LEFT_TO_RIGHT:
case FILL_RIGHT_TO_LEFT: {
width_total = dst_rect.size.x;
width_texture = texture_size.x;
first_section_size = topleft.x;
last_section_size = bottomright.x;
} break;
case FILL_TOP_TO_BOTTOM:
case FILL_BOTTOM_TO_TOP: {
width_total = dst_rect.size.y;
width_texture = texture_size.y;
first_section_size = topleft.y;
last_section_size = bottomright.y;
} break;
}
double width_filled = width_total * p_ratio;
double middle_section_size = MAX(0.0, width_texture - first_section_size - last_section_size);
middle_section_size *= MIN(1.0, (MAX(0.0, width_filled - first_section_size) / MAX(1.0, width_total - first_section_size - last_section_size)));
last_section_size = MAX(0.0, last_section_size - (width_total - width_filled));
width_texture = MIN(width_texture, first_section_size + middle_section_size + last_section_size);
switch (mode) {
case FILL_LEFT_TO_RIGHT: {
src_rect.size.x = width_texture;
dst_rect.size.x = width_filled;
bottomright.x = last_section_size;
} break;
case FILL_RIGHT_TO_LEFT: {
src_rect.position.x += src_rect.size.x - width_texture;
src_rect.size.x = width_texture;
dst_rect.position.x += width_total - width_filled;
dst_rect.size.x = width_filled;
topleft.x = last_section_size;
} break;
case FILL_TOP_TO_BOTTOM: {
src_rect.size.y = width_texture;
dst_rect.size.y = width_filled;
bottomright.y = last_section_size;
} break;
case FILL_BOTTOM_TO_TOP: {
src_rect.position.y += src_rect.size.y - width_texture;
src_rect.size.y = width_texture;
dst_rect.position.y += width_total - width_filled;
dst_rect.size.y = width_filled;
topleft.y = last_section_size;
} break;
}
}
RID ci = get_canvas_item();
VS::get_singleton()->canvas_item_add_nine_patch(ci, dst_rect, src_rect, p_texture->get_rid(), topleft, bottomright);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
void TextureProgress::_notification(int p_what) {
const float corners[12] = { -0.125, -0.375, -0.625, -0.875, 0.125, 0.375, 0.625, 0.875, 1.125, 1.375, 1.625, 1.875 };
switch (p_what) {
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
case NOTIFICATION_DRAW: {
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
if (nine_patch_stretch && (mode == FILL_LEFT_TO_RIGHT || mode == FILL_RIGHT_TO_LEFT || mode == FILL_TOP_TO_BOTTOM || mode == FILL_BOTTOM_TO_TOP)) {
if (under.is_valid()) {
draw_nine_patch_stretched(under, FILL_LEFT_TO_RIGHT, 1.0);
}
if (progress.is_valid()) {
draw_nine_patch_stretched(progress, mode, get_as_ratio());
}
if (over.is_valid()) {
draw_nine_patch_stretched(over, FILL_LEFT_TO_RIGHT, 1.0);
}
} else {
if (under.is_valid())
draw_texture(under, Point2());
if (progress.is_valid()) {
Size2 s = progress->get_size();
switch (mode) {
case FILL_LEFT_TO_RIGHT: {
Rect2 region = Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y));
draw_texture_rect_region(progress, region, region);
} break;
case FILL_RIGHT_TO_LEFT: {
Rect2 region = Rect2(Point2(s.x - s.x * get_as_ratio(), 0), Size2(s.x * get_as_ratio(), s.y));
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
draw_texture_rect_region(progress, region, region);
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
} break;
case FILL_TOP_TO_BOTTOM: {
Rect2 region = Rect2(Point2(), Size2(s.x, s.y * get_as_ratio()));
draw_texture_rect_region(progress, region, region);
} break;
case FILL_BOTTOM_TO_TOP: {
Rect2 region = Rect2(Point2(0, s.y - s.y * get_as_ratio()), Size2(s.x, s.y * get_as_ratio()));
draw_texture_rect_region(progress, region, region);
} break;
case FILL_CLOCKWISE:
case FILL_COUNTER_CLOCKWISE: {
float val = get_as_ratio() * rad_max_degrees / 360;
if (val == 1) {
Rect2 region = Rect2(Point2(), s);
draw_texture_rect_region(progress, region, region);
} else if (val != 0) {
Array pts;
float direction = mode == FILL_CLOCKWISE ? 1 : -1;
float start = rad_init_angle / 360;
float end = start + direction * val;
pts.append(start);
pts.append(end);
float from = MIN(start, end);
float to = MAX(start, end);
for (int i = 0; i < 12; i++)
if (corners[i] > from && corners[i] < to)
pts.append(corners[i]);
pts.sort();
Vector<Point2> uvs;
Vector<Point2> points;
uvs.push_back(get_relative_center());
points.push_back(Point2(s.x * get_relative_center().x, s.y * get_relative_center().y));
for (int i = 0; i < pts.size(); i++) {
Point2 uv = unit_val_to_uv(pts[i]);
if (uvs.find(uv) >= 0)
continue;
uvs.push_back(uv);
points.push_back(Point2(uv.x * s.x, uv.y * s.y));
}
draw_polygon(points, Vector<Color>(), uvs, progress);
}
if (Engine::get_singleton()->is_editor_hint()) {
Point2 p = progress->get_size();
p.x *= get_relative_center().x;
p.y *= get_relative_center().y;
p = p.floor();
draw_line(p - Point2(8, 0), p + Point2(8, 0), Color(0.9, 0.5, 0.5), 2);
draw_line(p - Point2(0, 8), p + Point2(0, 8), Color(0.9, 0.5, 0.5), 2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
}
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
} break;
default:
draw_texture_rect_region(progress, Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y)), Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y)));
}
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
}
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
if (over.is_valid())
draw_texture(over, Point2());
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
} break;
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
void TextureProgress::set_fill_mode(int p_fill) {
ERR_FAIL_INDEX(p_fill, 6);
mode = (FillMode)p_fill;
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
update();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
int TextureProgress::get_fill_mode() {
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
return mode;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
void TextureProgress::set_radial_initial_angle(float p_angle) {
while (p_angle > 360)
p_angle -= 360;
while (p_angle < 0)
p_angle += 360;
rad_init_angle = p_angle;
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
update();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
float TextureProgress::get_radial_initial_angle() {
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
return rad_init_angle;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
void TextureProgress::set_fill_degrees(float p_angle) {
rad_max_degrees = CLAMP(p_angle, 0, 360);
Add fill_degrees to limitate radial filling
2015-10-18 12:21:53 +08:00
update();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
float TextureProgress::get_fill_degrees() {
Add fill_degrees to limitate radial filling
2015-10-18 12:21:53 +08:00
return rad_max_degrees;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
void TextureProgress::set_radial_center_offset(const Point2 &p_off) {
rad_center_off = p_off;
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
update();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
Point2 TextureProgress::get_radial_center_offset() {
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
return rad_center_off;
}
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
void TextureProgress::_bind_methods() {
Removes type information from method binds
2017-08-09 19:19:41 +08:00
ClassDB::bind_method(D_METHOD("set_under_texture", "tex"), &TextureProgress::set_under_texture);
ClassDB::bind_method(D_METHOD("get_under_texture"), &TextureProgress::get_under_texture);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Removes type information from method binds
2017-08-09 19:19:41 +08:00
ClassDB::bind_method(D_METHOD("set_progress_texture", "tex"), &TextureProgress::set_progress_texture);
ClassDB::bind_method(D_METHOD("get_progress_texture"), &TextureProgress::get_progress_texture);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
Removes type information from method binds
2017-08-09 19:19:41 +08:00
ClassDB::bind_method(D_METHOD("set_over_texture", "tex"), &TextureProgress::set_over_texture);
ClassDB::bind_method(D_METHOD("get_over_texture"), &TextureProgress::get_over_texture);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("set_fill_mode", "mode"), &TextureProgress::set_fill_mode);
Rename the _MD macro to D_METHOD This new name also makes its purpose a little clearer This is a step towards fixing #56
2017-02-13 19:47:24 +08:00
ClassDB::bind_method(D_METHOD("get_fill_mode"), &TextureProgress::get_fill_mode);
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("set_radial_initial_angle", "mode"), &TextureProgress::set_radial_initial_angle);
Rename the _MD macro to D_METHOD This new name also makes its purpose a little clearer This is a step towards fixing #56
2017-02-13 19:47:24 +08:00
ClassDB::bind_method(D_METHOD("get_radial_initial_angle"), &TextureProgress::get_radial_initial_angle);
remove trailing whitespace
2016-03-09 07:00:52 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("set_radial_center_offset", "mode"), &TextureProgress::set_radial_center_offset);
Rename the _MD macro to D_METHOD This new name also makes its purpose a little clearer This is a step towards fixing #56
2017-02-13 19:47:24 +08:00
ClassDB::bind_method(D_METHOD("get_radial_center_offset"), &TextureProgress::get_radial_center_offset);
remove trailing whitespace
2016-03-09 07:00:52 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ClassDB::bind_method(D_METHOD("set_fill_degrees", "mode"), &TextureProgress::set_fill_degrees);
Rename the _MD macro to D_METHOD This new name also makes its purpose a little clearer This is a step towards fixing #56
2017-02-13 19:47:24 +08:00
ClassDB::bind_method(D_METHOD("get_fill_degrees"), &TextureProgress::get_fill_degrees);
Add fill modes. Clockwise, Counter-CW and center-offset
2015-10-18 10:37:39 +08:00
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
ClassDB::bind_method(D_METHOD("set_stretch_margin", "margin", "value"), &TextureProgress::set_stretch_margin);
ClassDB::bind_method(D_METHOD("get_stretch_margin", "margin"), &TextureProgress::get_stretch_margin);
ClassDB::bind_method(D_METHOD("set_nine_patch_stretch", "stretch"), &TextureProgress::set_nine_patch_stretch);
ClassDB::bind_method(D_METHOD("get_nine_patch_stretch"), &TextureProgress::get_nine_patch_stretch);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ADD_GROUP("Textures", "texture_");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture_under", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_under_texture", "get_under_texture");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture_over", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_over_texture", "get_over_texture");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture_progress", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_progress_texture", "get_progress_texture");
ADD_PROPERTYNZ(PropertyInfo(Variant::INT, "fill_mode", PROPERTY_HINT_ENUM, "Left to Right,Right to Left,Top to Bottom,Bottom to Top,Clockwise,Counter Clockwise"), "set_fill_mode", "get_fill_mode");
ADD_GROUP("Radial Fill", "radial_");
ADD_PROPERTYNZ(PropertyInfo(Variant::REAL, "radial_initial_angle", PROPERTY_HINT_RANGE, "0.0,360.0,0.1,slider"), "set_radial_initial_angle", "get_radial_initial_angle");
ADD_PROPERTYNZ(PropertyInfo(Variant::REAL, "radial_fill_degrees", PROPERTY_HINT_RANGE, "0.0,360.0,0.1,slider"), "set_fill_degrees", "get_fill_degrees");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "radial_center_offset"), "set_radial_center_offset", "get_radial_center_offset");
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
ADD_GROUP("Stretch", "stretch_");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "nine_patch_stretch"), "set_nine_patch_stretch", "get_nine_patch_stretch");
ADD_PROPERTYINZ(PropertyInfo(Variant::INT, "stretch_margin_left", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", MARGIN_LEFT);
ADD_PROPERTYINZ(PropertyInfo(Variant::INT, "stretch_margin_top", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", MARGIN_TOP);
ADD_PROPERTYINZ(PropertyInfo(Variant::INT, "stretch_margin_right", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", MARGIN_RIGHT);
ADD_PROPERTYINZ(PropertyInfo(Variant::INT, "stretch_margin_bottom", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", MARGIN_BOTTOM);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
ClassDB: Provide the enum name of integer constants
2017-08-20 23:45:01 +08:00
BIND_ENUM_CONSTANT(FILL_LEFT_TO_RIGHT);
BIND_ENUM_CONSTANT(FILL_RIGHT_TO_LEFT);
BIND_ENUM_CONSTANT(FILL_TOP_TO_BOTTOM);
BIND_ENUM_CONSTANT(FILL_BOTTOM_TO_TOP);
BIND_ENUM_CONSTANT(FILL_CLOCKWISE);
BIND_ENUM_CONSTANT(FILL_COUNTER_CLOCKWISE);
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 23:44:50 +08:00
TextureProgress::TextureProgress() {
mode = FILL_LEFT_TO_RIGHT;
rad_init_angle = 0;
rad_center_off = Point2();
rad_max_degrees = 360;
WIP new AudioServer, with buses, effects, etc.
2017-01-22 06:00:25 +08:00
set_mouse_filter(MOUSE_FILTER_PASS);
Add stretching to `TextureProgress` Now `TextureProgress` has `nine_patch_stretch` flag. With this flag enabled, it's being rendered as 9-path using `stretch_margin_*` properties as texture margins. Stretching doesn't support `FILL_CLOCKWISE` and `FILL_COUNTER_CLOCKWISE` fill modes.
2017-08-21 12:01:06 +08:00
nine_patch_stretch = false;
stretch_margin[MARGIN_LEFT] = 0;
stretch_margin[MARGIN_RIGHT] = 0;
stretch_margin[MARGIN_BOTTOM] = 0;
stretch_margin[MARGIN_TOP] = 0;
GODOT IS OPEN SOURCE
2014-02-10 09:10:30 +08:00
}
Reference in New Issue Copy Permalink