canvas_item.cpp | Explore in Territory

/**************************************************************************/
/*  canvas_item.cpp                                                       */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* 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 "canvas_item.h"
#include "canvas_item.compat.inc"

#include "scene/2d/canvas_group.h"
#include "scene/main/canvas_layer.h"
#include "scene/main/window.h"
#include "scene/resources/atlas_texture.h"
#include "scene/resources/canvas_item_material.h"
#include "scene/resources/font.h"
#include "scene/resources/multimesh.h"
#include "scene/resources/style_box.h"
#include "scene/resources/world_2d.h"

#define ERR_DRAW_GUARD …

#ifdef DEBUG_ENABLED
bool CanvasItem::_edit_is_selected_on_click(const Point2 &p_point, double p_tolerance) const { … }
#endif // DEBUG_ENABLED

#ifdef TOOLS_ENABLED
Transform2D CanvasItem::_edit_get_transform() const { … }
#endif //TOOLS_ENABLED

bool CanvasItem::is_visible_in_tree() const { … }

void CanvasItem::_propagate_visibility_changed(bool p_parent_visible_in_tree) { … }

void CanvasItem::set_visible(bool p_visible) { … }

void CanvasItem::_handle_visibility_change(bool p_visible) { … }

void CanvasItem::show() { … }

void CanvasItem::hide() { … }

bool CanvasItem::is_visible() const { … }

CanvasItem *CanvasItem::current_item_drawn = …;
CanvasItem *CanvasItem::get_current_item_drawn() { … }

void CanvasItem::_redraw_callback() { … }

Transform2D CanvasItem::get_global_transform_with_canvas() const { … }

Transform2D CanvasItem::get_screen_transform() const { … }

Transform2D CanvasItem::get_global_transform() const { … }

void CanvasItem::_set_global_invalid(bool p_invalid) const { … }

void CanvasItem::_top_level_raise_self() { … }

void CanvasItem::_enter_canvas() { … }

void CanvasItem::_exit_canvas() { … }

void CanvasItem::_notification(int p_what) { … }

void CanvasItem::update_draw_order() { … }

void CanvasItem::_window_visibility_changed() { … }

void CanvasItem::queue_redraw() { … }

void CanvasItem::move_to_front() { … }

void CanvasItem::set_modulate(const Color &p_modulate) { … }

Color CanvasItem::get_modulate() const { … }

Color CanvasItem::get_modulate_in_tree() const { … }

void CanvasItem::set_as_top_level(bool p_top_level) { … }

void CanvasItem::_top_level_changed() { … }

void CanvasItem::_top_level_changed_on_parent() { … }

bool CanvasItem::is_set_as_top_level() const { … }

CanvasItem *CanvasItem::get_parent_item() const { … }

void CanvasItem::set_self_modulate(const Color &p_self_modulate) { … }

Color CanvasItem::get_self_modulate() const { … }

void CanvasItem::set_light_mask(int p_light_mask) { … }

int CanvasItem::get_light_mask() const { … }

void CanvasItem::item_rect_changed(bool p_size_changed) { … }

void CanvasItem::set_z_index(int p_z) { … }

void CanvasItem::set_z_as_relative(bool p_enabled) { … }

bool CanvasItem::is_z_relative() const { … }

int CanvasItem::get_z_index() const { … }

int CanvasItem::get_effective_z_index() const { … }

void CanvasItem::set_y_sort_enabled(bool p_enabled) { … }

bool CanvasItem::is_y_sort_enabled() const { … }

void CanvasItem::draw_dashed_line(const Point2 &p_from, const Point2 &p_to, const Color &p_color, real_t p_width, real_t p_dash, bool p_aligned, bool p_antialiased) { … }

void CanvasItem::draw_line(const Point2 &p_from, const Point2 &p_to, const Color &p_color, real_t p_width, bool p_antialiased) { … }

void CanvasItem::draw_polyline(const Vector<Point2> &p_points, const Color &p_color, real_t p_width, bool p_antialiased) { … }

void CanvasItem::draw_polyline_colors(const Vector<Point2> &p_points, const Vector<Color> &p_colors, real_t p_width, bool p_antialiased) { … }

void CanvasItem::draw_arc(const Vector2 &p_center, real_t p_radius, real_t p_start_angle, real_t p_end_angle, int p_point_count, const Color &p_color, real_t p_width, bool p_antialiased) { … }

void CanvasItem::draw_multiline(const Vector<Point2> &p_points, const Color &p_color, real_t p_width, bool p_antialiased) { … }

void CanvasItem::draw_multiline_colors(const Vector<Point2> &p_points, const Vector<Color> &p_colors, real_t p_width, bool p_antialiased) { … }

void CanvasItem::draw_rect(const Rect2 &p_rect, const Color &p_color, bool p_filled, real_t p_width, bool p_antialiased) { … }

void CanvasItem::draw_circle(const Point2 &p_pos, real_t p_radius, const Color &p_color, bool p_filled, real_t p_width, bool p_antialiased) { … }

void CanvasItem::draw_texture(const Ref<Texture2D> &p_texture, const Point2 &p_pos, const Color &p_modulate) { … }

void CanvasItem::draw_texture_rect(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) { … }

void CanvasItem::draw_texture_rect_region(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, bool p_clip_uv) { … }

void CanvasItem::draw_msdf_texture_rect_region(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, double p_outline, double p_pixel_range, double p_scale) { … }

void CanvasItem::draw_lcd_texture_rect_region(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate) { … }

void CanvasItem::draw_style_box(const Ref<StyleBox> &p_style_box, const Rect2 &p_rect) { … }

void CanvasItem::draw_primitive(const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, Ref<Texture2D> p_texture) { … }

void CanvasItem::draw_set_transform(const Point2 &p_offset, real_t p_rot, const Size2 &p_scale) { … }

void CanvasItem::draw_set_transform_matrix(const Transform2D &p_matrix) { … }
void CanvasItem::draw_animation_slice(double p_animation_length, double p_slice_begin, double p_slice_end, double p_offset) { … }

void CanvasItem::draw_end_animation() { … }

void CanvasItem::draw_polygon(const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, Ref<Texture2D> p_texture) { … }

void CanvasItem::draw_colored_polygon(const Vector<Point2> &p_points, const Color &p_color, const Vector<Point2> &p_uvs, Ref<Texture2D> p_texture) { … }

void CanvasItem::draw_mesh(const Ref<Mesh> &p_mesh, const Ref<Texture2D> &p_texture, const Transform2D &p_transform, const Color &p_modulate) { … }

void CanvasItem::draw_multimesh(const Ref<MultiMesh> &p_multimesh, const Ref<Texture2D> &p_texture) { … }

void CanvasItem::draw_string(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, HorizontalAlignment p_alignment, float p_width, int p_font_size, const Color &p_modulate, BitField<TextServer::JustificationFlag> p_jst_flags, TextServer::Direction p_direction, TextServer::Orientation p_orientation) const { … }

void CanvasItem::draw_multiline_string(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, HorizontalAlignment p_alignment, float p_width, int p_font_size, int p_max_lines, const Color &p_modulate, BitField<TextServer::LineBreakFlag> p_brk_flags, BitField<TextServer::JustificationFlag> p_jst_flags, TextServer::Direction p_direction, TextServer::Orientation p_orientation) const { … }

void CanvasItem::draw_string_outline(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, HorizontalAlignment p_alignment, float p_width, int p_font_size, int p_size, const Color &p_modulate, BitField<TextServer::JustificationFlag> p_jst_flags, TextServer::Direction p_direction, TextServer::Orientation p_orientation) const { … }

void CanvasItem::draw_multiline_string_outline(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, HorizontalAlignment p_alignment, float p_width, int p_font_size, int p_max_lines, int p_size, const Color &p_modulate, BitField<TextServer::LineBreakFlag> p_brk_flags, BitField<TextServer::JustificationFlag> p_jst_flags, TextServer::Direction p_direction, TextServer::Orientation p_orientation) const { … }

void CanvasItem::draw_char(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_char, int p_font_size, const Color &p_modulate) const { … }

void CanvasItem::draw_char_outline(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_char, int p_font_size, int p_size, const Color &p_modulate) const { … }

void CanvasItem::_notify_transform_deferred() { … }

void CanvasItem::_notify_transform(CanvasItem *p_node) { … }

void CanvasItem::_physics_interpolated_changed() { … }

Rect2 CanvasItem::get_viewport_rect() const { … }

RID CanvasItem::get_canvas() const { … }

ObjectID CanvasItem::get_canvas_layer_instance_id() const { … }

CanvasItem *CanvasItem::get_top_level() const { … }

Ref<World2D> CanvasItem::get_world_2d() const { … }

RID CanvasItem::get_viewport_rid() const { … }

void CanvasItem::set_block_transform_notify(bool p_enable) { … }

bool CanvasItem::is_block_transform_notify_enabled() const { … }

void CanvasItem::set_draw_behind_parent(bool p_enable) { … }

bool CanvasItem::is_draw_behind_parent_enabled() const { … }

void CanvasItem::set_material(const Ref<Material> &p_material) { … }

void CanvasItem::set_use_parent_material(bool p_use_parent_material) { … }

bool CanvasItem::get_use_parent_material() const { … }

Ref<Material> CanvasItem::get_material() const { … }

Vector2 CanvasItem::make_canvas_position_local(const Vector2 &screen_point) const { … }

Ref<InputEvent> CanvasItem::make_input_local(const Ref<InputEvent> &p_event) const { … }

Vector2 CanvasItem::get_global_mouse_position() const { … }

Vector2 CanvasItem::get_local_mouse_position() const { … }

void CanvasItem::force_update_transform() { … }

void CanvasItem::_validate_property(PropertyInfo &p_property) const { … }

void CanvasItem::_bind_methods() { … }

Transform2D CanvasItem::get_canvas_transform() const { … }

Transform2D CanvasItem::get_viewport_transform() const { … }

void CanvasItem::set_notify_local_transform(bool p_enable) { … }

bool CanvasItem::is_local_transform_notification_enabled() const { … }

void CanvasItem::set_notify_transform(bool p_enable) { … }

bool CanvasItem::is_transform_notification_enabled() const { … }

int CanvasItem::get_canvas_layer() const { … }

CanvasLayer *CanvasItem::get_canvas_layer_node() const { … }

void CanvasItem::set_visibility_layer(uint32_t p_visibility_layer) { … }

uint32_t CanvasItem::get_visibility_layer() const { … }

void CanvasItem::set_visibility_layer_bit(uint32_t p_visibility_layer, bool p_enable) { … }

bool CanvasItem::get_visibility_layer_bit(uint32_t p_visibility_layer) const { … }

void CanvasItem::_refresh_texture_filter_cache() const { … }

void CanvasItem::_update_self_texture_filter(RS::CanvasItemTextureFilter p_texture_filter) { … }

void CanvasItem::_update_texture_filter_changed(bool p_propagate) { … }

void CanvasItem::set_texture_filter(TextureFilter p_texture_filter) { … }

CanvasItem::TextureFilter CanvasItem::get_texture_filter() const { … }

void CanvasItem::_refresh_texture_repeat_cache() const { … }

void CanvasItem::_update_self_texture_repeat(RS::CanvasItemTextureRepeat p_texture_repeat) { … }

void CanvasItem::_update_texture_repeat_changed(bool p_propagate) { … }

void CanvasItem::set_texture_repeat(TextureRepeat p_texture_repeat) { … }

void CanvasItem::set_clip_children_mode(ClipChildrenMode p_clip_mode) { … }
CanvasItem::ClipChildrenMode CanvasItem::get_clip_children_mode() const { … }

CanvasItem::TextureRepeat CanvasItem::get_texture_repeat() const { … }

CanvasItem::TextureFilter CanvasItem::get_texture_filter_in_tree() const { … }

CanvasItem::TextureRepeat CanvasItem::get_texture_repeat_in_tree() const { … }

CanvasItem::CanvasItem() : … { … }

CanvasItem::~CanvasItem() { … }

///////////////////////////////////////////////////////////////////

void CanvasTexture::set_diffuse_texture(const Ref<Texture2D> &p_diffuse) { … }
Ref<Texture2D> CanvasTexture::get_diffuse_texture() const { … }

void CanvasTexture::set_normal_texture(const Ref<Texture2D> &p_normal) { … }
Ref<Texture2D> CanvasTexture::get_normal_texture() const { … }

void CanvasTexture::set_specular_texture(const Ref<Texture2D> &p_specular) { … }

Ref<Texture2D> CanvasTexture::get_specular_texture() const { … }

void CanvasTexture::set_specular_color(const Color &p_color) { … }

Color CanvasTexture::get_specular_color() const { … }

void CanvasTexture::set_specular_shininess(real_t p_shininess) { … }

real_t CanvasTexture::get_specular_shininess() const { … }

void CanvasTexture::set_texture_filter(CanvasItem::TextureFilter p_filter) { … }
CanvasItem::TextureFilter CanvasTexture::get_texture_filter() const { … }

void CanvasTexture::set_texture_repeat(CanvasItem::TextureRepeat p_repeat) { … }
CanvasItem::TextureRepeat CanvasTexture::get_texture_repeat() const { … }

int CanvasTexture::get_width() const { … }
int CanvasTexture::get_height() const { … }

bool CanvasTexture::is_pixel_opaque(int p_x, int p_y) const { … }

bool CanvasTexture::has_alpha() const { … }

Ref<Image> CanvasTexture::get_image() const { … }

RID CanvasTexture::get_rid() const { … }

void CanvasTexture::_bind_methods() { … }

CanvasTexture::CanvasTexture() { … }
CanvasTexture::~CanvasTexture() { … }
godot/scene/main/canvas_item.cpp
