1 /*************************************************************************/
2 /* visual_server_canvas.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30
31 #include "visual_server_canvas.h"
32 #include "visual_server_globals.h"
33 #include "visual_server_raster.h"
34 #include "visual_server_viewport.h"
35
36 static const int z_range = VS::CANVAS_ITEM_Z_MAX - VS::CANVAS_ITEM_Z_MIN + 1;
37
_render_canvas_item_tree(Item * p_canvas_item,const Transform2D & p_transform,const Rect2 & p_clip_rect,const Color & p_modulate,RasterizerCanvas::Light * p_lights)38 void VisualServerCanvas::_render_canvas_item_tree(Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, RasterizerCanvas::Light *p_lights) {
39
40 memset(z_list, 0, z_range * sizeof(RasterizerCanvas::Item *));
41 memset(z_last_list, 0, z_range * sizeof(RasterizerCanvas::Item *));
42
43 _render_canvas_item(p_canvas_item, p_transform, p_clip_rect, Color(1, 1, 1, 1), 0, z_list, z_last_list, NULL, NULL);
44
45 VSG::canvas_render->canvas_render_items_begin(p_modulate, p_lights, p_transform);
46 for (int i = 0; i < z_range; i++) {
47 if (!z_list[i])
48 continue;
49 VSG::canvas_render->canvas_render_items(z_list[i], VS::CANVAS_ITEM_Z_MIN + i, p_modulate, p_lights, p_transform);
50 }
51 VSG::canvas_render->canvas_render_items_end();
52 }
53
_collect_ysort_children(VisualServerCanvas::Item * p_canvas_item,Transform2D p_transform,VisualServerCanvas::Item * p_material_owner,const Color p_modulate,VisualServerCanvas::Item ** r_items,int & r_index)54 void _collect_ysort_children(VisualServerCanvas::Item *p_canvas_item, Transform2D p_transform, VisualServerCanvas::Item *p_material_owner, const Color p_modulate, VisualServerCanvas::Item **r_items, int &r_index) {
55 int child_item_count = p_canvas_item->child_items.size();
56 VisualServerCanvas::Item **child_items = p_canvas_item->child_items.ptrw();
57 for (int i = 0; i < child_item_count; i++) {
58 if (child_items[i]->visible) {
59 if (r_items) {
60 r_items[r_index] = child_items[i];
61 child_items[i]->ysort_modulate = p_modulate;
62 child_items[i]->ysort_xform = p_transform;
63 child_items[i]->ysort_pos = p_transform.xform(child_items[i]->xform.elements[2]);
64 child_items[i]->material_owner = child_items[i]->use_parent_material ? p_material_owner : NULL;
65 }
66
67 r_index++;
68
69 if (child_items[i]->sort_y)
70 _collect_ysort_children(child_items[i],
71 p_transform * child_items[i]->xform,
72 child_items[i]->use_parent_material ? p_material_owner : child_items[i],
73 p_modulate * child_items[i]->modulate,
74 r_items, r_index);
75 }
76 }
77 }
78
_mark_ysort_dirty(VisualServerCanvas::Item * ysort_owner,RID_Owner<VisualServerCanvas::Item> & canvas_item_owner)79 void _mark_ysort_dirty(VisualServerCanvas::Item *ysort_owner, RID_Owner<VisualServerCanvas::Item> &canvas_item_owner) {
80 do {
81 ysort_owner->ysort_children_count = -1;
82 ysort_owner = canvas_item_owner.owns(ysort_owner->parent) ? canvas_item_owner.getornull(ysort_owner->parent) : NULL;
83 } while (ysort_owner && ysort_owner->sort_y);
84 }
85
_render_canvas_item(Item * p_canvas_item,const Transform2D & p_transform,const Rect2 & p_clip_rect,const Color & p_modulate,int p_z,RasterizerCanvas::Item ** z_list,RasterizerCanvas::Item ** z_last_list,Item * p_canvas_clip,Item * p_material_owner)86 void VisualServerCanvas::_render_canvas_item(Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, int p_z, RasterizerCanvas::Item **z_list, RasterizerCanvas::Item **z_last_list, Item *p_canvas_clip, Item *p_material_owner) {
87
88 Item *ci = p_canvas_item;
89
90 if (!ci->visible)
91 return;
92
93 if (ci->children_order_dirty) {
94
95 ci->child_items.sort_custom<ItemIndexSort>();
96 ci->children_order_dirty = false;
97 }
98
99 Rect2 rect = ci->get_rect();
100 Transform2D xform = p_transform * ci->xform;
101 Rect2 global_rect = xform.xform(rect);
102 global_rect.position += p_clip_rect.position;
103
104 if (ci->use_parent_material && p_material_owner)
105 ci->material_owner = p_material_owner;
106 else {
107 p_material_owner = ci;
108 ci->material_owner = NULL;
109 }
110
111 Color modulate(ci->modulate.r * p_modulate.r, ci->modulate.g * p_modulate.g, ci->modulate.b * p_modulate.b, ci->modulate.a * p_modulate.a);
112
113 if (modulate.a < 0.007)
114 return;
115
116 int child_item_count = ci->child_items.size();
117 Item **child_items = ci->child_items.ptrw();
118
119 if (ci->clip) {
120 if (p_canvas_clip != NULL) {
121 ci->final_clip_rect = p_canvas_clip->final_clip_rect.clip(global_rect);
122 } else {
123 ci->final_clip_rect = global_rect;
124 }
125 ci->final_clip_owner = ci;
126
127 } else {
128 ci->final_clip_owner = p_canvas_clip;
129 }
130
131 if (ci->sort_y) {
132
133 if (ci->ysort_children_count == -1) {
134 ci->ysort_children_count = 0;
135 _collect_ysort_children(ci, Transform2D(), p_material_owner, Color(1, 1, 1, 1), NULL, ci->ysort_children_count);
136 }
137
138 child_item_count = ci->ysort_children_count;
139 child_items = (Item **)alloca(child_item_count * sizeof(Item *));
140
141 int i = 0;
142 _collect_ysort_children(ci, Transform2D(), p_material_owner, Color(1, 1, 1, 1), child_items, i);
143
144 SortArray<Item *, ItemPtrSort> sorter;
145 sorter.sort(child_items, child_item_count);
146 }
147
148 if (ci->z_relative)
149 p_z = CLAMP(p_z + ci->z_index, VS::CANVAS_ITEM_Z_MIN, VS::CANVAS_ITEM_Z_MAX);
150 else
151 p_z = ci->z_index;
152
153 for (int i = 0; i < child_item_count; i++) {
154
155 if (!child_items[i]->behind || (ci->sort_y && child_items[i]->sort_y))
156 continue;
157 if (ci->sort_y) {
158 _render_canvas_item(child_items[i], xform * child_items[i]->ysort_xform, p_clip_rect, modulate * child_items[i]->ysort_modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, (Item *)child_items[i]->material_owner);
159 } else {
160 _render_canvas_item(child_items[i], xform, p_clip_rect, modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, p_material_owner);
161 }
162 }
163
164 if (ci->copy_back_buffer) {
165
166 ci->copy_back_buffer->screen_rect = xform.xform(ci->copy_back_buffer->rect).clip(p_clip_rect);
167 }
168
169 if (ci->update_when_visible) {
170 VisualServerRaster::redraw_request();
171 }
172
173 if ((!ci->commands.empty() && p_clip_rect.intersects(global_rect, true)) || ci->vp_render || ci->copy_back_buffer) {
174 //something to draw?
175 ci->final_transform = xform;
176 ci->final_modulate = Color(modulate.r * ci->self_modulate.r, modulate.g * ci->self_modulate.g, modulate.b * ci->self_modulate.b, modulate.a * ci->self_modulate.a);
177 ci->global_rect_cache = global_rect;
178 ci->global_rect_cache.position -= p_clip_rect.position;
179 ci->light_masked = false;
180
181 int zidx = p_z - VS::CANVAS_ITEM_Z_MIN;
182
183 if (z_last_list[zidx]) {
184 z_last_list[zidx]->next = ci;
185 z_last_list[zidx] = ci;
186
187 } else {
188 z_list[zidx] = ci;
189 z_last_list[zidx] = ci;
190 }
191
192 ci->next = NULL;
193 }
194
195 for (int i = 0; i < child_item_count; i++) {
196
197 if (child_items[i]->behind || (ci->sort_y && child_items[i]->sort_y))
198 continue;
199 if (ci->sort_y) {
200 _render_canvas_item(child_items[i], xform * child_items[i]->ysort_xform, p_clip_rect, modulate * child_items[i]->ysort_modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, (Item *)child_items[i]->material_owner);
201 } else {
202 _render_canvas_item(child_items[i], xform, p_clip_rect, modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, p_material_owner);
203 }
204 }
205 }
206
_light_mask_canvas_items(int p_z,RasterizerCanvas::Item * p_canvas_item,RasterizerCanvas::Light * p_masked_lights,int p_canvas_layer_id)207 void VisualServerCanvas::_light_mask_canvas_items(int p_z, RasterizerCanvas::Item *p_canvas_item, RasterizerCanvas::Light *p_masked_lights, int p_canvas_layer_id) {
208
209 RasterizerCanvas::Item *ci = p_canvas_item;
210
211 while (ci) {
212
213 RasterizerCanvas::Light *light = p_masked_lights;
214 while (light) {
215
216 if ((p_canvas_layer_id >= light->layer_min) && (p_canvas_layer_id <= light->layer_max) && (ci->light_mask & light->item_mask) && (p_z >= light->z_min) && (p_z <= light->z_max) && (ci->global_rect_cache.intersects_transformed(light->xform_cache, light->rect_cache))) {
217 ci->light_masked = true;
218 }
219
220 light = light->mask_next_ptr;
221 }
222
223 ci = ci->next;
224 }
225 }
226
render_canvas(Canvas * p_canvas,const Transform2D & p_transform,RasterizerCanvas::Light * p_lights,RasterizerCanvas::Light * p_masked_lights,const Rect2 & p_clip_rect,int p_canvas_layer_id)227 void VisualServerCanvas::render_canvas(Canvas *p_canvas, const Transform2D &p_transform, RasterizerCanvas::Light *p_lights, RasterizerCanvas::Light *p_masked_lights, const Rect2 &p_clip_rect, int p_canvas_layer_id) {
228
229 VSG::canvas_render->canvas_begin();
230
231 if (p_canvas->children_order_dirty) {
232
233 p_canvas->child_items.sort();
234 p_canvas->children_order_dirty = false;
235 }
236
237 int l = p_canvas->child_items.size();
238 Canvas::ChildItem *ci = p_canvas->child_items.ptrw();
239
240 bool has_mirror = false;
241 for (int i = 0; i < l; i++) {
242 if (ci[i].mirror.x || ci[i].mirror.y) {
243 has_mirror = true;
244 break;
245 }
246 }
247
248 if (!has_mirror) {
249
250 static const int z_range = VS::CANVAS_ITEM_Z_MAX - VS::CANVAS_ITEM_Z_MIN + 1;
251 RasterizerCanvas::Item *z_list[z_range];
252 RasterizerCanvas::Item *z_last_list[z_range];
253
254 memset(z_list, 0, z_range * sizeof(RasterizerCanvas::Item *));
255 memset(z_last_list, 0, z_range * sizeof(RasterizerCanvas::Item *));
256
257 for (int i = 0; i < l; i++) {
258 _render_canvas_item(ci[i].item, p_transform, p_clip_rect, Color(1, 1, 1, 1), 0, z_list, z_last_list, NULL, NULL);
259 }
260
261 VSG::canvas_render->canvas_render_items_begin(p_canvas->modulate, p_lights, p_transform);
262 for (int i = 0; i < z_range; i++) {
263 if (!z_list[i])
264 continue;
265
266 if (p_masked_lights) {
267 _light_mask_canvas_items(VS::CANVAS_ITEM_Z_MIN + i, z_list[i], p_masked_lights, p_canvas_layer_id);
268 }
269
270 VSG::canvas_render->canvas_render_items(z_list[i], VS::CANVAS_ITEM_Z_MIN + i, p_canvas->modulate, p_lights, p_transform);
271 }
272 VSG::canvas_render->canvas_render_items_end();
273 } else {
274
275 for (int i = 0; i < l; i++) {
276
277 const Canvas::ChildItem &ci2 = p_canvas->child_items[i];
278 _render_canvas_item_tree(ci2.item, p_transform, p_clip_rect, p_canvas->modulate, p_lights);
279
280 //mirroring (useful for scrolling backgrounds)
281 if (ci2.mirror.x != 0) {
282
283 Transform2D xform2 = p_transform * Transform2D(0, Vector2(ci2.mirror.x, 0));
284 _render_canvas_item_tree(ci2.item, xform2, p_clip_rect, p_canvas->modulate, p_lights);
285 }
286 if (ci2.mirror.y != 0) {
287
288 Transform2D xform2 = p_transform * Transform2D(0, Vector2(0, ci2.mirror.y));
289 _render_canvas_item_tree(ci2.item, xform2, p_clip_rect, p_canvas->modulate, p_lights);
290 }
291 if (ci2.mirror.y != 0 && ci2.mirror.x != 0) {
292
293 Transform2D xform2 = p_transform * Transform2D(0, ci2.mirror);
294 _render_canvas_item_tree(ci2.item, xform2, p_clip_rect, p_canvas->modulate, p_lights);
295 }
296 }
297 }
298
299 VSG::canvas_render->canvas_end();
300 }
301
canvas_create()302 RID VisualServerCanvas::canvas_create() {
303
304 Canvas *canvas = memnew(Canvas);
305 ERR_FAIL_COND_V(!canvas, RID());
306 RID rid = canvas_owner.make_rid(canvas);
307
308 return rid;
309 }
310
canvas_set_item_mirroring(RID p_canvas,RID p_item,const Point2 & p_mirroring)311 void VisualServerCanvas::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring) {
312
313 Canvas *canvas = canvas_owner.getornull(p_canvas);
314 ERR_FAIL_COND(!canvas);
315 Item *canvas_item = canvas_item_owner.getornull(p_item);
316 ERR_FAIL_COND(!canvas_item);
317
318 int idx = canvas->find_item(canvas_item);
319 ERR_FAIL_COND(idx == -1);
320 canvas->child_items.write[idx].mirror = p_mirroring;
321 }
canvas_set_modulate(RID p_canvas,const Color & p_color)322 void VisualServerCanvas::canvas_set_modulate(RID p_canvas, const Color &p_color) {
323
324 Canvas *canvas = canvas_owner.get(p_canvas);
325 ERR_FAIL_COND(!canvas);
326 canvas->modulate = p_color;
327 }
328
canvas_set_disable_scale(bool p_disable)329 void VisualServerCanvas::canvas_set_disable_scale(bool p_disable) {
330 disable_scale = p_disable;
331 }
332
canvas_set_parent(RID p_canvas,RID p_parent,float p_scale)333 void VisualServerCanvas::canvas_set_parent(RID p_canvas, RID p_parent, float p_scale) {
334
335 Canvas *canvas = canvas_owner.get(p_canvas);
336 ERR_FAIL_COND(!canvas);
337
338 canvas->parent = p_parent;
339 canvas->parent_scale = p_scale;
340 }
341
canvas_item_create()342 RID VisualServerCanvas::canvas_item_create() {
343
344 Item *canvas_item = memnew(Item);
345 ERR_FAIL_COND_V(!canvas_item, RID());
346
347 return canvas_item_owner.make_rid(canvas_item);
348 }
349
canvas_item_set_parent(RID p_item,RID p_parent)350 void VisualServerCanvas::canvas_item_set_parent(RID p_item, RID p_parent) {
351
352 Item *canvas_item = canvas_item_owner.getornull(p_item);
353 ERR_FAIL_COND(!canvas_item);
354
355 if (canvas_item->parent.is_valid()) {
356
357 if (canvas_owner.owns(canvas_item->parent)) {
358
359 Canvas *canvas = canvas_owner.get(canvas_item->parent);
360 canvas->erase_item(canvas_item);
361 } else if (canvas_item_owner.owns(canvas_item->parent)) {
362
363 Item *item_owner = canvas_item_owner.get(canvas_item->parent);
364 item_owner->child_items.erase(canvas_item);
365
366 if (item_owner->sort_y) {
367 _mark_ysort_dirty(item_owner, canvas_item_owner);
368 }
369 }
370
371 canvas_item->parent = RID();
372 }
373
374 if (p_parent.is_valid()) {
375 if (canvas_owner.owns(p_parent)) {
376
377 Canvas *canvas = canvas_owner.get(p_parent);
378 Canvas::ChildItem ci;
379 ci.item = canvas_item;
380 canvas->child_items.push_back(ci);
381 canvas->children_order_dirty = true;
382 } else if (canvas_item_owner.owns(p_parent)) {
383
384 Item *item_owner = canvas_item_owner.get(p_parent);
385 item_owner->child_items.push_back(canvas_item);
386 item_owner->children_order_dirty = true;
387
388 if (item_owner->sort_y) {
389 _mark_ysort_dirty(item_owner, canvas_item_owner);
390 }
391
392 } else {
393
394 ERR_FAIL_MSG("Invalid parent.");
395 }
396 }
397
398 canvas_item->parent = p_parent;
399 }
canvas_item_set_visible(RID p_item,bool p_visible)400 void VisualServerCanvas::canvas_item_set_visible(RID p_item, bool p_visible) {
401
402 Item *canvas_item = canvas_item_owner.getornull(p_item);
403 ERR_FAIL_COND(!canvas_item);
404
405 canvas_item->visible = p_visible;
406
407 _mark_ysort_dirty(canvas_item, canvas_item_owner);
408 }
canvas_item_set_light_mask(RID p_item,int p_mask)409 void VisualServerCanvas::canvas_item_set_light_mask(RID p_item, int p_mask) {
410
411 Item *canvas_item = canvas_item_owner.getornull(p_item);
412 ERR_FAIL_COND(!canvas_item);
413
414 canvas_item->light_mask = p_mask;
415 }
416
canvas_item_set_transform(RID p_item,const Transform2D & p_transform)417 void VisualServerCanvas::canvas_item_set_transform(RID p_item, const Transform2D &p_transform) {
418
419 Item *canvas_item = canvas_item_owner.getornull(p_item);
420 ERR_FAIL_COND(!canvas_item);
421
422 canvas_item->xform = p_transform;
423 }
canvas_item_set_clip(RID p_item,bool p_clip)424 void VisualServerCanvas::canvas_item_set_clip(RID p_item, bool p_clip) {
425
426 Item *canvas_item = canvas_item_owner.getornull(p_item);
427 ERR_FAIL_COND(!canvas_item);
428
429 canvas_item->clip = p_clip;
430 }
canvas_item_set_distance_field_mode(RID p_item,bool p_enable)431 void VisualServerCanvas::canvas_item_set_distance_field_mode(RID p_item, bool p_enable) {
432
433 Item *canvas_item = canvas_item_owner.getornull(p_item);
434 ERR_FAIL_COND(!canvas_item);
435
436 canvas_item->distance_field = p_enable;
437 }
canvas_item_set_custom_rect(RID p_item,bool p_custom_rect,const Rect2 & p_rect)438 void VisualServerCanvas::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect) {
439
440 Item *canvas_item = canvas_item_owner.getornull(p_item);
441 ERR_FAIL_COND(!canvas_item);
442
443 canvas_item->custom_rect = p_custom_rect;
444 canvas_item->rect = p_rect;
445 }
canvas_item_set_modulate(RID p_item,const Color & p_color)446 void VisualServerCanvas::canvas_item_set_modulate(RID p_item, const Color &p_color) {
447
448 Item *canvas_item = canvas_item_owner.getornull(p_item);
449 ERR_FAIL_COND(!canvas_item);
450
451 canvas_item->modulate = p_color;
452 }
canvas_item_set_self_modulate(RID p_item,const Color & p_color)453 void VisualServerCanvas::canvas_item_set_self_modulate(RID p_item, const Color &p_color) {
454
455 Item *canvas_item = canvas_item_owner.getornull(p_item);
456 ERR_FAIL_COND(!canvas_item);
457
458 canvas_item->self_modulate = p_color;
459 }
460
canvas_item_set_draw_behind_parent(RID p_item,bool p_enable)461 void VisualServerCanvas::canvas_item_set_draw_behind_parent(RID p_item, bool p_enable) {
462
463 Item *canvas_item = canvas_item_owner.getornull(p_item);
464 ERR_FAIL_COND(!canvas_item);
465
466 canvas_item->behind = p_enable;
467 }
468
canvas_item_set_update_when_visible(RID p_item,bool p_update)469 void VisualServerCanvas::canvas_item_set_update_when_visible(RID p_item, bool p_update) {
470
471 Item *canvas_item = canvas_item_owner.getornull(p_item);
472 ERR_FAIL_COND(!canvas_item);
473
474 canvas_item->update_when_visible = p_update;
475 }
476
canvas_item_add_line(RID p_item,const Point2 & p_from,const Point2 & p_to,const Color & p_color,float p_width,bool p_antialiased)477 void VisualServerCanvas::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width, bool p_antialiased) {
478
479 Item *canvas_item = canvas_item_owner.getornull(p_item);
480 ERR_FAIL_COND(!canvas_item);
481
482 Item::CommandLine *line = memnew(Item::CommandLine);
483 ERR_FAIL_COND(!line);
484 line->color = p_color;
485 line->from = p_from;
486 line->to = p_to;
487 line->width = p_width;
488 line->antialiased = p_antialiased;
489 canvas_item->rect_dirty = true;
490
491 canvas_item->commands.push_back(line);
492 }
493
canvas_item_add_polyline(RID p_item,const Vector<Point2> & p_points,const Vector<Color> & p_colors,float p_width,bool p_antialiased)494 void VisualServerCanvas::canvas_item_add_polyline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width, bool p_antialiased) {
495
496 ERR_FAIL_COND(p_points.size() < 2);
497 Item *canvas_item = canvas_item_owner.getornull(p_item);
498 ERR_FAIL_COND(!canvas_item);
499
500 Item::CommandPolyLine *pline = memnew(Item::CommandPolyLine);
501 ERR_FAIL_COND(!pline);
502
503 pline->antialiased = p_antialiased;
504 pline->multiline = false;
505
506 if (p_width <= 1) {
507 pline->lines = p_points;
508 pline->line_colors = p_colors;
509 if (pline->line_colors.size() == 0) {
510 pline->line_colors.push_back(Color(1, 1, 1, 1));
511 } else if (pline->line_colors.size() > 1 && pline->line_colors.size() != pline->lines.size()) {
512 pline->line_colors.resize(1);
513 }
514 } else {
515 //make a trianglestrip for drawing the line...
516 Vector2 prev_t;
517 pline->triangles.resize(p_points.size() * 2);
518 if (p_antialiased) {
519 pline->lines.resize(p_points.size() * 2);
520 }
521
522 if (p_colors.size() == 0) {
523 pline->triangle_colors.push_back(Color(1, 1, 1, 1));
524 if (p_antialiased) {
525 pline->line_colors.push_back(Color(1, 1, 1, 1));
526 }
527 } else if (p_colors.size() == 1) {
528 pline->triangle_colors = p_colors;
529 pline->line_colors = p_colors;
530 } else {
531 if (p_colors.size() != p_points.size()) {
532 pline->triangle_colors.push_back(p_colors[0]);
533 pline->line_colors.push_back(p_colors[0]);
534 } else {
535 pline->triangle_colors.resize(pline->triangles.size());
536 pline->line_colors.resize(pline->lines.size());
537 }
538 }
539
540 for (int i = 0; i < p_points.size(); i++) {
541
542 Vector2 t;
543 if (i == p_points.size() - 1) {
544 t = prev_t;
545 } else {
546 t = (p_points[i + 1] - p_points[i]).normalized().tangent();
547 if (i == 0) {
548 prev_t = t;
549 }
550 }
551
552 Vector2 tangent = ((t + prev_t).normalized()) * p_width * 0.5;
553
554 if (p_antialiased) {
555 pline->lines.write[i] = p_points[i] + tangent;
556 pline->lines.write[p_points.size() * 2 - i - 1] = p_points[i] - tangent;
557 if (pline->line_colors.size() > 1) {
558 pline->line_colors.write[i] = p_colors[i];
559 pline->line_colors.write[p_points.size() * 2 - i - 1] = p_colors[i];
560 }
561 }
562
563 pline->triangles.write[i * 2 + 0] = p_points[i] + tangent;
564 pline->triangles.write[i * 2 + 1] = p_points[i] - tangent;
565
566 if (pline->triangle_colors.size() > 1) {
567
568 pline->triangle_colors.write[i * 2 + 0] = p_colors[i];
569 pline->triangle_colors.write[i * 2 + 1] = p_colors[i];
570 }
571
572 prev_t = t;
573 }
574 }
575 canvas_item->rect_dirty = true;
576 canvas_item->commands.push_back(pline);
577 }
578
canvas_item_add_multiline(RID p_item,const Vector<Point2> & p_points,const Vector<Color> & p_colors,float p_width,bool p_antialiased)579 void VisualServerCanvas::canvas_item_add_multiline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width, bool p_antialiased) {
580
581 ERR_FAIL_COND(p_points.size() < 2);
582 Item *canvas_item = canvas_item_owner.getornull(p_item);
583 ERR_FAIL_COND(!canvas_item);
584
585 Item::CommandPolyLine *pline = memnew(Item::CommandPolyLine);
586 ERR_FAIL_COND(!pline);
587
588 pline->antialiased = false; //todo
589 pline->multiline = true;
590
591 pline->lines = p_points;
592 pline->line_colors = p_colors;
593 if (pline->line_colors.size() == 0) {
594 pline->line_colors.push_back(Color(1, 1, 1, 1));
595 } else if (pline->line_colors.size() > 1 && pline->line_colors.size() != pline->lines.size()) {
596 pline->line_colors.resize(1);
597 }
598
599 canvas_item->rect_dirty = true;
600 canvas_item->commands.push_back(pline);
601 }
602
canvas_item_add_rect(RID p_item,const Rect2 & p_rect,const Color & p_color)603 void VisualServerCanvas::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color) {
604
605 Item *canvas_item = canvas_item_owner.getornull(p_item);
606 ERR_FAIL_COND(!canvas_item);
607
608 Item::CommandRect *rect = memnew(Item::CommandRect);
609 ERR_FAIL_COND(!rect);
610 rect->modulate = p_color;
611 rect->rect = p_rect;
612 canvas_item->rect_dirty = true;
613
614 canvas_item->commands.push_back(rect);
615 }
616
canvas_item_add_circle(RID p_item,const Point2 & p_pos,float p_radius,const Color & p_color)617 void VisualServerCanvas::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color) {
618
619 Item *canvas_item = canvas_item_owner.getornull(p_item);
620 ERR_FAIL_COND(!canvas_item);
621
622 Item::CommandCircle *circle = memnew(Item::CommandCircle);
623 ERR_FAIL_COND(!circle);
624 circle->color = p_color;
625 circle->pos = p_pos;
626 circle->radius = p_radius;
627
628 canvas_item->commands.push_back(circle);
629 }
630
canvas_item_add_texture_rect(RID p_item,const Rect2 & p_rect,RID p_texture,bool p_tile,const Color & p_modulate,bool p_transpose,RID p_normal_map)631 void VisualServerCanvas::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose, RID p_normal_map) {
632
633 Item *canvas_item = canvas_item_owner.getornull(p_item);
634 ERR_FAIL_COND(!canvas_item);
635
636 Item::CommandRect *rect = memnew(Item::CommandRect);
637 ERR_FAIL_COND(!rect);
638 rect->modulate = p_modulate;
639 rect->rect = p_rect;
640 rect->flags = 0;
641 if (p_tile) {
642 rect->flags |= RasterizerCanvas::CANVAS_RECT_TILE;
643 rect->flags |= RasterizerCanvas::CANVAS_RECT_REGION;
644 rect->source = Rect2(0, 0, fabsf(p_rect.size.width), fabsf(p_rect.size.height));
645 }
646
647 if (p_rect.size.x < 0) {
648
649 rect->flags |= RasterizerCanvas::CANVAS_RECT_FLIP_H;
650 rect->rect.size.x = -rect->rect.size.x;
651 }
652 if (p_rect.size.y < 0) {
653
654 rect->flags |= RasterizerCanvas::CANVAS_RECT_FLIP_V;
655 rect->rect.size.y = -rect->rect.size.y;
656 }
657 if (p_transpose) {
658 rect->flags |= RasterizerCanvas::CANVAS_RECT_TRANSPOSE;
659 SWAP(rect->rect.size.x, rect->rect.size.y);
660 }
661 rect->texture = p_texture;
662 rect->normal_map = p_normal_map;
663 canvas_item->rect_dirty = true;
664 canvas_item->commands.push_back(rect);
665 }
666
canvas_item_add_texture_rect_region(RID p_item,const Rect2 & p_rect,RID p_texture,const Rect2 & p_src_rect,const Color & p_modulate,bool p_transpose,RID p_normal_map,bool p_clip_uv)667 void VisualServerCanvas::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, RID p_normal_map, bool p_clip_uv) {
668
669 Item *canvas_item = canvas_item_owner.getornull(p_item);
670 ERR_FAIL_COND(!canvas_item);
671
672 Item::CommandRect *rect = memnew(Item::CommandRect);
673 ERR_FAIL_COND(!rect);
674 rect->modulate = p_modulate;
675 rect->rect = p_rect;
676 rect->texture = p_texture;
677 rect->normal_map = p_normal_map;
678 rect->source = p_src_rect;
679 rect->flags = RasterizerCanvas::CANVAS_RECT_REGION;
680
681 if (p_rect.size.x < 0) {
682
683 rect->flags |= RasterizerCanvas::CANVAS_RECT_FLIP_H;
684 rect->rect.size.x = -rect->rect.size.x;
685 }
686 if (p_src_rect.size.x < 0) {
687
688 rect->flags ^= RasterizerCanvas::CANVAS_RECT_FLIP_H;
689 rect->source.size.x = -rect->source.size.x;
690 }
691 if (p_rect.size.y < 0) {
692
693 rect->flags |= RasterizerCanvas::CANVAS_RECT_FLIP_V;
694 rect->rect.size.y = -rect->rect.size.y;
695 }
696 if (p_src_rect.size.y < 0) {
697
698 rect->flags ^= RasterizerCanvas::CANVAS_RECT_FLIP_V;
699 rect->source.size.y = -rect->source.size.y;
700 }
701
702 if (p_transpose) {
703 rect->flags |= RasterizerCanvas::CANVAS_RECT_TRANSPOSE;
704 SWAP(rect->rect.size.x, rect->rect.size.y);
705 }
706
707 if (p_clip_uv) {
708 rect->flags |= RasterizerCanvas::CANVAS_RECT_CLIP_UV;
709 }
710
711 canvas_item->rect_dirty = true;
712
713 canvas_item->commands.push_back(rect);
714 }
715
canvas_item_add_nine_patch(RID p_item,const Rect2 & p_rect,const Rect2 & p_source,RID p_texture,const Vector2 & p_topleft,const Vector2 & p_bottomright,VS::NinePatchAxisMode p_x_axis_mode,VS::NinePatchAxisMode p_y_axis_mode,bool p_draw_center,const Color & p_modulate,RID p_normal_map)716 void VisualServerCanvas::canvas_item_add_nine_patch(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, VS::NinePatchAxisMode p_x_axis_mode, VS::NinePatchAxisMode p_y_axis_mode, bool p_draw_center, const Color &p_modulate, RID p_normal_map) {
717
718 Item *canvas_item = canvas_item_owner.getornull(p_item);
719 ERR_FAIL_COND(!canvas_item);
720
721 Item::CommandNinePatch *style = memnew(Item::CommandNinePatch);
722 ERR_FAIL_COND(!style);
723 style->texture = p_texture;
724 style->normal_map = p_normal_map;
725 style->rect = p_rect;
726 style->source = p_source;
727 style->draw_center = p_draw_center;
728 style->color = p_modulate;
729 style->margin[MARGIN_LEFT] = p_topleft.x;
730 style->margin[MARGIN_TOP] = p_topleft.y;
731 style->margin[MARGIN_RIGHT] = p_bottomright.x;
732 style->margin[MARGIN_BOTTOM] = p_bottomright.y;
733 style->axis_x = p_x_axis_mode;
734 style->axis_y = p_y_axis_mode;
735 canvas_item->rect_dirty = true;
736
737 canvas_item->commands.push_back(style);
738 }
canvas_item_add_primitive(RID p_item,const Vector<Point2> & p_points,const Vector<Color> & p_colors,const Vector<Point2> & p_uvs,RID p_texture,float p_width,RID p_normal_map)739 void VisualServerCanvas::canvas_item_add_primitive(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width, RID p_normal_map) {
740
741 Item *canvas_item = canvas_item_owner.getornull(p_item);
742 ERR_FAIL_COND(!canvas_item);
743
744 Item::CommandPrimitive *prim = memnew(Item::CommandPrimitive);
745 ERR_FAIL_COND(!prim);
746 prim->texture = p_texture;
747 prim->normal_map = p_normal_map;
748 prim->points = p_points;
749 prim->uvs = p_uvs;
750 prim->colors = p_colors;
751 prim->width = p_width;
752 canvas_item->rect_dirty = true;
753
754 canvas_item->commands.push_back(prim);
755 }
756
canvas_item_add_polygon(RID p_item,const Vector<Point2> & p_points,const Vector<Color> & p_colors,const Vector<Point2> & p_uvs,RID p_texture,RID p_normal_map,bool p_antialiased)757 void VisualServerCanvas::canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, RID p_normal_map, bool p_antialiased) {
758
759 Item *canvas_item = canvas_item_owner.getornull(p_item);
760 ERR_FAIL_COND(!canvas_item);
761 #ifdef DEBUG_ENABLED
762 int pointcount = p_points.size();
763 ERR_FAIL_COND(pointcount < 3);
764 int color_size = p_colors.size();
765 int uv_size = p_uvs.size();
766 ERR_FAIL_COND(color_size != 0 && color_size != 1 && color_size != pointcount);
767 ERR_FAIL_COND(uv_size != 0 && (uv_size != pointcount));
768 #endif
769 Vector<int> indices = Geometry::triangulate_polygon(p_points);
770 ERR_FAIL_COND_MSG(indices.empty(), "Invalid polygon data, triangulation failed.");
771
772 Item::CommandPolygon *polygon = memnew(Item::CommandPolygon);
773 ERR_FAIL_COND(!polygon);
774 polygon->texture = p_texture;
775 polygon->normal_map = p_normal_map;
776 polygon->points = p_points;
777 polygon->uvs = p_uvs;
778 polygon->colors = p_colors;
779 polygon->indices = indices;
780 polygon->count = indices.size();
781 polygon->antialiased = p_antialiased;
782 polygon->antialiasing_use_indices = false;
783 canvas_item->rect_dirty = true;
784
785 canvas_item->commands.push_back(polygon);
786 }
787
canvas_item_add_triangle_array(RID p_item,const Vector<int> & p_indices,const Vector<Point2> & p_points,const Vector<Color> & p_colors,const Vector<Point2> & p_uvs,const Vector<int> & p_bones,const Vector<float> & p_weights,RID p_texture,int p_count,RID p_normal_map,bool p_antialiased,bool p_antialiasing_use_indices)788 void VisualServerCanvas::canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, const Vector<int> &p_bones, const Vector<float> &p_weights, RID p_texture, int p_count, RID p_normal_map, bool p_antialiased, bool p_antialiasing_use_indices) {
789
790 Item *canvas_item = canvas_item_owner.getornull(p_item);
791 ERR_FAIL_COND(!canvas_item);
792
793 int vertex_count = p_points.size();
794 ERR_FAIL_COND(vertex_count == 0);
795 ERR_FAIL_COND(!p_colors.empty() && p_colors.size() != vertex_count && p_colors.size() != 1);
796 ERR_FAIL_COND(!p_uvs.empty() && p_uvs.size() != vertex_count);
797 ERR_FAIL_COND(!p_bones.empty() && p_bones.size() != vertex_count * 4);
798 ERR_FAIL_COND(!p_weights.empty() && p_weights.size() != vertex_count * 4);
799
800 const Vector<int> &indices = p_indices;
801
802 int count = p_count * 3;
803
804 if (indices.empty()) {
805
806 ERR_FAIL_COND(vertex_count % 3 != 0);
807 if (p_count == -1)
808 count = vertex_count;
809 } else {
810
811 ERR_FAIL_COND(indices.size() % 3 != 0);
812 if (p_count == -1)
813 count = indices.size();
814 }
815
816 Item::CommandPolygon *polygon = memnew(Item::CommandPolygon);
817 ERR_FAIL_COND(!polygon);
818 polygon->texture = p_texture;
819 polygon->normal_map = p_normal_map;
820 polygon->points = p_points;
821 polygon->uvs = p_uvs;
822 polygon->colors = p_colors;
823 polygon->bones = p_bones;
824 polygon->weights = p_weights;
825 polygon->indices = indices;
826 polygon->count = count;
827 polygon->antialiased = p_antialiased;
828 polygon->antialiasing_use_indices = p_antialiasing_use_indices;
829 canvas_item->rect_dirty = true;
830
831 canvas_item->commands.push_back(polygon);
832 }
833
canvas_item_add_set_transform(RID p_item,const Transform2D & p_transform)834 void VisualServerCanvas::canvas_item_add_set_transform(RID p_item, const Transform2D &p_transform) {
835
836 Item *canvas_item = canvas_item_owner.getornull(p_item);
837 ERR_FAIL_COND(!canvas_item);
838
839 Item::CommandTransform *tr = memnew(Item::CommandTransform);
840 ERR_FAIL_COND(!tr);
841 tr->xform = p_transform;
842
843 canvas_item->commands.push_back(tr);
844 }
845
canvas_item_add_mesh(RID p_item,const RID & p_mesh,const Transform2D & p_transform,const Color & p_modulate,RID p_texture,RID p_normal_map)846 void VisualServerCanvas::canvas_item_add_mesh(RID p_item, const RID &p_mesh, const Transform2D &p_transform, const Color &p_modulate, RID p_texture, RID p_normal_map) {
847
848 Item *canvas_item = canvas_item_owner.getornull(p_item);
849 ERR_FAIL_COND(!canvas_item);
850
851 Item::CommandMesh *m = memnew(Item::CommandMesh);
852 ERR_FAIL_COND(!m);
853 m->mesh = p_mesh;
854 m->texture = p_texture;
855 m->normal_map = p_normal_map;
856 m->transform = p_transform;
857 m->modulate = p_modulate;
858
859 canvas_item->commands.push_back(m);
860 }
canvas_item_add_particles(RID p_item,RID p_particles,RID p_texture,RID p_normal)861 void VisualServerCanvas::canvas_item_add_particles(RID p_item, RID p_particles, RID p_texture, RID p_normal) {
862
863 Item *canvas_item = canvas_item_owner.getornull(p_item);
864 ERR_FAIL_COND(!canvas_item);
865
866 Item::CommandParticles *part = memnew(Item::CommandParticles);
867 ERR_FAIL_COND(!part);
868 part->particles = p_particles;
869 part->texture = p_texture;
870 part->normal_map = p_normal;
871
872 //take the chance and request processing for them, at least once until they become visible again
873 VSG::storage->particles_request_process(p_particles);
874
875 canvas_item->rect_dirty = true;
876 canvas_item->commands.push_back(part);
877 }
878
canvas_item_add_multimesh(RID p_item,RID p_mesh,RID p_texture,RID p_normal_map)879 void VisualServerCanvas::canvas_item_add_multimesh(RID p_item, RID p_mesh, RID p_texture, RID p_normal_map) {
880
881 Item *canvas_item = canvas_item_owner.getornull(p_item);
882 ERR_FAIL_COND(!canvas_item);
883
884 Item::CommandMultiMesh *mm = memnew(Item::CommandMultiMesh);
885 ERR_FAIL_COND(!mm);
886 mm->multimesh = p_mesh;
887 mm->texture = p_texture;
888 mm->normal_map = p_normal_map;
889
890 canvas_item->rect_dirty = true;
891 canvas_item->commands.push_back(mm);
892 }
893
canvas_item_add_clip_ignore(RID p_item,bool p_ignore)894 void VisualServerCanvas::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) {
895
896 Item *canvas_item = canvas_item_owner.getornull(p_item);
897 ERR_FAIL_COND(!canvas_item);
898
899 Item::CommandClipIgnore *ci = memnew(Item::CommandClipIgnore);
900 ERR_FAIL_COND(!ci);
901 ci->ignore = p_ignore;
902
903 canvas_item->commands.push_back(ci);
904 }
canvas_item_set_sort_children_by_y(RID p_item,bool p_enable)905 void VisualServerCanvas::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
906
907 Item *canvas_item = canvas_item_owner.getornull(p_item);
908 ERR_FAIL_COND(!canvas_item);
909
910 canvas_item->sort_y = p_enable;
911
912 _mark_ysort_dirty(canvas_item, canvas_item_owner);
913 }
canvas_item_set_z_index(RID p_item,int p_z)914 void VisualServerCanvas::canvas_item_set_z_index(RID p_item, int p_z) {
915
916 ERR_FAIL_COND(p_z < VS::CANVAS_ITEM_Z_MIN || p_z > VS::CANVAS_ITEM_Z_MAX);
917
918 Item *canvas_item = canvas_item_owner.getornull(p_item);
919 ERR_FAIL_COND(!canvas_item);
920
921 canvas_item->z_index = p_z;
922 }
canvas_item_set_z_as_relative_to_parent(RID p_item,bool p_enable)923 void VisualServerCanvas::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) {
924
925 Item *canvas_item = canvas_item_owner.getornull(p_item);
926 ERR_FAIL_COND(!canvas_item);
927
928 canvas_item->z_relative = p_enable;
929 }
930
canvas_item_attach_skeleton(RID p_item,RID p_skeleton)931 void VisualServerCanvas::canvas_item_attach_skeleton(RID p_item, RID p_skeleton) {
932
933 Item *canvas_item = canvas_item_owner.getornull(p_item);
934 ERR_FAIL_COND(!canvas_item);
935
936 canvas_item->skeleton = p_skeleton;
937 }
938
canvas_item_set_copy_to_backbuffer(RID p_item,bool p_enable,const Rect2 & p_rect)939 void VisualServerCanvas::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect) {
940
941 Item *canvas_item = canvas_item_owner.getornull(p_item);
942 ERR_FAIL_COND(!canvas_item);
943 if (bool(canvas_item->copy_back_buffer != NULL) != p_enable) {
944 if (p_enable) {
945 canvas_item->copy_back_buffer = memnew(RasterizerCanvas::Item::CopyBackBuffer);
946 } else {
947 memdelete(canvas_item->copy_back_buffer);
948 canvas_item->copy_back_buffer = NULL;
949 }
950 }
951
952 if (p_enable) {
953 canvas_item->copy_back_buffer->rect = p_rect;
954 canvas_item->copy_back_buffer->full = p_rect == Rect2();
955 }
956 }
957
canvas_item_clear(RID p_item)958 void VisualServerCanvas::canvas_item_clear(RID p_item) {
959
960 Item *canvas_item = canvas_item_owner.getornull(p_item);
961 ERR_FAIL_COND(!canvas_item);
962
963 canvas_item->clear();
964 }
canvas_item_set_draw_index(RID p_item,int p_index)965 void VisualServerCanvas::canvas_item_set_draw_index(RID p_item, int p_index) {
966
967 Item *canvas_item = canvas_item_owner.getornull(p_item);
968 ERR_FAIL_COND(!canvas_item);
969
970 canvas_item->index = p_index;
971
972 if (canvas_item_owner.owns(canvas_item->parent)) {
973 Item *canvas_item_parent = canvas_item_owner.getornull(canvas_item->parent);
974 canvas_item_parent->children_order_dirty = true;
975 return;
976 }
977
978 Canvas *canvas = canvas_owner.getornull(canvas_item->parent);
979 if (canvas) {
980 canvas->children_order_dirty = true;
981 return;
982 }
983 }
984
canvas_item_set_material(RID p_item,RID p_material)985 void VisualServerCanvas::canvas_item_set_material(RID p_item, RID p_material) {
986
987 Item *canvas_item = canvas_item_owner.get(p_item);
988 ERR_FAIL_COND(!canvas_item);
989
990 canvas_item->material = p_material;
991 }
992
canvas_item_set_use_parent_material(RID p_item,bool p_enable)993 void VisualServerCanvas::canvas_item_set_use_parent_material(RID p_item, bool p_enable) {
994
995 Item *canvas_item = canvas_item_owner.get(p_item);
996 ERR_FAIL_COND(!canvas_item);
997
998 canvas_item->use_parent_material = p_enable;
999 }
1000
canvas_light_create()1001 RID VisualServerCanvas::canvas_light_create() {
1002
1003 RasterizerCanvas::Light *clight = memnew(RasterizerCanvas::Light);
1004 clight->light_internal = VSG::canvas_render->light_internal_create();
1005 return canvas_light_owner.make_rid(clight);
1006 }
canvas_light_attach_to_canvas(RID p_light,RID p_canvas)1007 void VisualServerCanvas::canvas_light_attach_to_canvas(RID p_light, RID p_canvas) {
1008
1009 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1010 ERR_FAIL_COND(!clight);
1011
1012 if (clight->canvas.is_valid()) {
1013
1014 Canvas *canvas = canvas_owner.getornull(clight->canvas);
1015 canvas->lights.erase(clight);
1016 }
1017
1018 if (!canvas_owner.owns(p_canvas))
1019 p_canvas = RID();
1020
1021 clight->canvas = p_canvas;
1022
1023 if (clight->canvas.is_valid()) {
1024
1025 Canvas *canvas = canvas_owner.get(clight->canvas);
1026 canvas->lights.insert(clight);
1027 }
1028 }
1029
canvas_light_set_enabled(RID p_light,bool p_enabled)1030 void VisualServerCanvas::canvas_light_set_enabled(RID p_light, bool p_enabled) {
1031
1032 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1033 ERR_FAIL_COND(!clight);
1034
1035 clight->enabled = p_enabled;
1036 }
canvas_light_set_scale(RID p_light,float p_scale)1037 void VisualServerCanvas::canvas_light_set_scale(RID p_light, float p_scale) {
1038
1039 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1040 ERR_FAIL_COND(!clight);
1041
1042 clight->scale = p_scale;
1043 }
canvas_light_set_transform(RID p_light,const Transform2D & p_transform)1044 void VisualServerCanvas::canvas_light_set_transform(RID p_light, const Transform2D &p_transform) {
1045
1046 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1047 ERR_FAIL_COND(!clight);
1048
1049 clight->xform = p_transform;
1050 }
canvas_light_set_texture(RID p_light,RID p_texture)1051 void VisualServerCanvas::canvas_light_set_texture(RID p_light, RID p_texture) {
1052
1053 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1054 ERR_FAIL_COND(!clight);
1055
1056 clight->texture = p_texture;
1057 }
canvas_light_set_texture_offset(RID p_light,const Vector2 & p_offset)1058 void VisualServerCanvas::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset) {
1059
1060 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1061 ERR_FAIL_COND(!clight);
1062
1063 clight->texture_offset = p_offset;
1064 }
canvas_light_set_color(RID p_light,const Color & p_color)1065 void VisualServerCanvas::canvas_light_set_color(RID p_light, const Color &p_color) {
1066
1067 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1068 ERR_FAIL_COND(!clight);
1069
1070 clight->color = p_color;
1071 }
canvas_light_set_height(RID p_light,float p_height)1072 void VisualServerCanvas::canvas_light_set_height(RID p_light, float p_height) {
1073
1074 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1075 ERR_FAIL_COND(!clight);
1076
1077 clight->height = p_height;
1078 }
canvas_light_set_energy(RID p_light,float p_energy)1079 void VisualServerCanvas::canvas_light_set_energy(RID p_light, float p_energy) {
1080
1081 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1082 ERR_FAIL_COND(!clight);
1083
1084 clight->energy = p_energy;
1085 }
canvas_light_set_z_range(RID p_light,int p_min_z,int p_max_z)1086 void VisualServerCanvas::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z) {
1087
1088 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1089 ERR_FAIL_COND(!clight);
1090
1091 clight->z_min = p_min_z;
1092 clight->z_max = p_max_z;
1093 }
canvas_light_set_layer_range(RID p_light,int p_min_layer,int p_max_layer)1094 void VisualServerCanvas::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer) {
1095
1096 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1097 ERR_FAIL_COND(!clight);
1098
1099 clight->layer_max = p_max_layer;
1100 clight->layer_min = p_min_layer;
1101 }
canvas_light_set_item_cull_mask(RID p_light,int p_mask)1102 void VisualServerCanvas::canvas_light_set_item_cull_mask(RID p_light, int p_mask) {
1103
1104 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1105 ERR_FAIL_COND(!clight);
1106
1107 clight->item_mask = p_mask;
1108 }
canvas_light_set_item_shadow_cull_mask(RID p_light,int p_mask)1109 void VisualServerCanvas::canvas_light_set_item_shadow_cull_mask(RID p_light, int p_mask) {
1110
1111 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1112 ERR_FAIL_COND(!clight);
1113
1114 clight->item_shadow_mask = p_mask;
1115 }
canvas_light_set_mode(RID p_light,VS::CanvasLightMode p_mode)1116 void VisualServerCanvas::canvas_light_set_mode(RID p_light, VS::CanvasLightMode p_mode) {
1117
1118 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1119 ERR_FAIL_COND(!clight);
1120
1121 clight->mode = p_mode;
1122 }
1123
canvas_light_set_shadow_enabled(RID p_light,bool p_enabled)1124 void VisualServerCanvas::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled) {
1125
1126 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1127 ERR_FAIL_COND(!clight);
1128
1129 if (clight->shadow_buffer.is_valid() == p_enabled)
1130 return;
1131 if (p_enabled) {
1132 clight->shadow_buffer = VSG::storage->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
1133 } else {
1134 VSG::storage->free(clight->shadow_buffer);
1135 clight->shadow_buffer = RID();
1136 }
1137 }
canvas_light_set_shadow_buffer_size(RID p_light,int p_size)1138 void VisualServerCanvas::canvas_light_set_shadow_buffer_size(RID p_light, int p_size) {
1139
1140 ERR_FAIL_COND(p_size < 32 || p_size > 16384);
1141
1142 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1143 ERR_FAIL_COND(!clight);
1144
1145 int new_size = next_power_of_2(p_size);
1146 if (new_size == clight->shadow_buffer_size)
1147 return;
1148
1149 clight->shadow_buffer_size = next_power_of_2(p_size);
1150
1151 if (clight->shadow_buffer.is_valid()) {
1152 VSG::storage->free(clight->shadow_buffer);
1153 clight->shadow_buffer = VSG::storage->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
1154 }
1155 }
1156
canvas_light_set_shadow_gradient_length(RID p_light,float p_length)1157 void VisualServerCanvas::canvas_light_set_shadow_gradient_length(RID p_light, float p_length) {
1158
1159 ERR_FAIL_COND(p_length < 0);
1160
1161 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1162 ERR_FAIL_COND(!clight);
1163
1164 clight->shadow_gradient_length = p_length;
1165 }
canvas_light_set_shadow_filter(RID p_light,VS::CanvasLightShadowFilter p_filter)1166 void VisualServerCanvas::canvas_light_set_shadow_filter(RID p_light, VS::CanvasLightShadowFilter p_filter) {
1167
1168 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1169 ERR_FAIL_COND(!clight);
1170
1171 clight->shadow_filter = p_filter;
1172 }
canvas_light_set_shadow_color(RID p_light,const Color & p_color)1173 void VisualServerCanvas::canvas_light_set_shadow_color(RID p_light, const Color &p_color) {
1174
1175 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1176 ERR_FAIL_COND(!clight);
1177
1178 clight->shadow_color = p_color;
1179 }
1180
canvas_light_set_shadow_smooth(RID p_light,float p_smooth)1181 void VisualServerCanvas::canvas_light_set_shadow_smooth(RID p_light, float p_smooth) {
1182
1183 RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
1184 ERR_FAIL_COND(!clight);
1185 clight->shadow_smooth = p_smooth;
1186 }
1187
canvas_light_occluder_create()1188 RID VisualServerCanvas::canvas_light_occluder_create() {
1189
1190 RasterizerCanvas::LightOccluderInstance *occluder = memnew(RasterizerCanvas::LightOccluderInstance);
1191
1192 return canvas_light_occluder_owner.make_rid(occluder);
1193 }
canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas)1194 void VisualServerCanvas::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas) {
1195
1196 RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
1197 ERR_FAIL_COND(!occluder);
1198
1199 if (occluder->canvas.is_valid()) {
1200
1201 Canvas *canvas = canvas_owner.get(occluder->canvas);
1202 canvas->occluders.erase(occluder);
1203 }
1204
1205 if (!canvas_owner.owns(p_canvas))
1206 p_canvas = RID();
1207
1208 occluder->canvas = p_canvas;
1209
1210 if (occluder->canvas.is_valid()) {
1211
1212 Canvas *canvas = canvas_owner.get(occluder->canvas);
1213 canvas->occluders.insert(occluder);
1214 }
1215 }
canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled)1216 void VisualServerCanvas::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled) {
1217
1218 RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
1219 ERR_FAIL_COND(!occluder);
1220
1221 occluder->enabled = p_enabled;
1222 }
canvas_light_occluder_set_polygon(RID p_occluder,RID p_polygon)1223 void VisualServerCanvas::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon) {
1224
1225 RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
1226 ERR_FAIL_COND(!occluder);
1227
1228 if (occluder->polygon.is_valid()) {
1229 LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
1230 if (occluder_poly) {
1231 occluder_poly->owners.erase(occluder);
1232 }
1233 }
1234
1235 occluder->polygon = p_polygon;
1236 occluder->polygon_buffer = RID();
1237
1238 if (occluder->polygon.is_valid()) {
1239 LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
1240 if (!occluder_poly) {
1241 occluder->polygon = RID();
1242 ERR_FAIL_COND(!occluder_poly);
1243 } else {
1244 occluder_poly->owners.insert(occluder);
1245 occluder->polygon_buffer = occluder_poly->occluder;
1246 occluder->aabb_cache = occluder_poly->aabb;
1247 occluder->cull_cache = occluder_poly->cull_mode;
1248 }
1249 }
1250 }
canvas_light_occluder_set_transform(RID p_occluder,const Transform2D & p_xform)1251 void VisualServerCanvas::canvas_light_occluder_set_transform(RID p_occluder, const Transform2D &p_xform) {
1252
1253 RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
1254 ERR_FAIL_COND(!occluder);
1255
1256 occluder->xform = p_xform;
1257 }
canvas_light_occluder_set_light_mask(RID p_occluder,int p_mask)1258 void VisualServerCanvas::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) {
1259
1260 RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
1261 ERR_FAIL_COND(!occluder);
1262
1263 occluder->light_mask = p_mask;
1264 }
1265
canvas_occluder_polygon_create()1266 RID VisualServerCanvas::canvas_occluder_polygon_create() {
1267
1268 LightOccluderPolygon *occluder_poly = memnew(LightOccluderPolygon);
1269 occluder_poly->occluder = VSG::storage->canvas_light_occluder_create();
1270 return canvas_light_occluder_polygon_owner.make_rid(occluder_poly);
1271 }
canvas_occluder_polygon_set_shape(RID p_occluder_polygon,const PoolVector<Vector2> & p_shape,bool p_closed)1272 void VisualServerCanvas::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const PoolVector<Vector2> &p_shape, bool p_closed) {
1273
1274 if (p_shape.size() < 3) {
1275 canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, p_shape);
1276 return;
1277 }
1278
1279 PoolVector<Vector2> lines;
1280 int lc = p_shape.size() * 2;
1281
1282 lines.resize(lc - (p_closed ? 0 : 2));
1283 {
1284 PoolVector<Vector2>::Write w = lines.write();
1285 PoolVector<Vector2>::Read r = p_shape.read();
1286
1287 int max = lc / 2;
1288 if (!p_closed) {
1289 max--;
1290 }
1291 for (int i = 0; i < max; i++) {
1292
1293 Vector2 a = r[i];
1294 Vector2 b = r[(i + 1) % (lc / 2)];
1295 w[i * 2 + 0] = a;
1296 w[i * 2 + 1] = b;
1297 }
1298 }
1299
1300 canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, lines);
1301 }
canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon,const PoolVector<Vector2> & p_shape)1302 void VisualServerCanvas::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const PoolVector<Vector2> &p_shape) {
1303
1304 LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
1305 ERR_FAIL_COND(!occluder_poly);
1306 ERR_FAIL_COND(p_shape.size() & 1);
1307
1308 int lc = p_shape.size();
1309 occluder_poly->aabb = Rect2();
1310 {
1311 PoolVector<Vector2>::Read r = p_shape.read();
1312 for (int i = 0; i < lc; i++) {
1313 if (i == 0)
1314 occluder_poly->aabb.position = r[i];
1315 else
1316 occluder_poly->aabb.expand_to(r[i]);
1317 }
1318 }
1319
1320 VSG::storage->canvas_light_occluder_set_polylines(occluder_poly->occluder, p_shape);
1321 for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
1322 E->get()->aabb_cache = occluder_poly->aabb;
1323 }
1324 }
1325
canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon,VS::CanvasOccluderPolygonCullMode p_mode)1326 void VisualServerCanvas::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, VS::CanvasOccluderPolygonCullMode p_mode) {
1327
1328 LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
1329 ERR_FAIL_COND(!occluder_poly);
1330 occluder_poly->cull_mode = p_mode;
1331 for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
1332 E->get()->cull_cache = p_mode;
1333 }
1334 }
1335
free(RID p_rid)1336 bool VisualServerCanvas::free(RID p_rid) {
1337
1338 if (canvas_owner.owns(p_rid)) {
1339
1340 Canvas *canvas = canvas_owner.get(p_rid);
1341 ERR_FAIL_COND_V(!canvas, false);
1342
1343 while (canvas->viewports.size()) {
1344
1345 VisualServerViewport::Viewport *vp = VSG::viewport->viewport_owner.get(canvas->viewports.front()->get());
1346 ERR_FAIL_COND_V(!vp, true);
1347
1348 Map<RID, VisualServerViewport::Viewport::CanvasData>::Element *E = vp->canvas_map.find(p_rid);
1349 ERR_FAIL_COND_V(!E, true);
1350 vp->canvas_map.erase(p_rid);
1351
1352 canvas->viewports.erase(canvas->viewports.front());
1353 }
1354
1355 for (int i = 0; i < canvas->child_items.size(); i++) {
1356
1357 canvas->child_items[i].item->parent = RID();
1358 }
1359
1360 for (Set<RasterizerCanvas::Light *>::Element *E = canvas->lights.front(); E; E = E->next()) {
1361
1362 E->get()->canvas = RID();
1363 }
1364
1365 for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *E = canvas->occluders.front(); E; E = E->next()) {
1366
1367 E->get()->canvas = RID();
1368 }
1369
1370 canvas_owner.free(p_rid);
1371
1372 memdelete(canvas);
1373
1374 } else if (canvas_item_owner.owns(p_rid)) {
1375
1376 Item *canvas_item = canvas_item_owner.get(p_rid);
1377 ERR_FAIL_COND_V(!canvas_item, true);
1378
1379 if (canvas_item->parent.is_valid()) {
1380
1381 if (canvas_owner.owns(canvas_item->parent)) {
1382
1383 Canvas *canvas = canvas_owner.get(canvas_item->parent);
1384 canvas->erase_item(canvas_item);
1385 } else if (canvas_item_owner.owns(canvas_item->parent)) {
1386
1387 Item *item_owner = canvas_item_owner.get(canvas_item->parent);
1388 item_owner->child_items.erase(canvas_item);
1389
1390 if (item_owner->sort_y) {
1391 _mark_ysort_dirty(item_owner, canvas_item_owner);
1392 }
1393 }
1394 }
1395
1396 for (int i = 0; i < canvas_item->child_items.size(); i++) {
1397
1398 canvas_item->child_items[i]->parent = RID();
1399 }
1400
1401 /*
1402 if (canvas_item->material) {
1403 canvas_item->material->owners.erase(canvas_item);
1404 }
1405 */
1406
1407 canvas_item_owner.free(p_rid);
1408
1409 memdelete(canvas_item);
1410
1411 } else if (canvas_light_owner.owns(p_rid)) {
1412
1413 RasterizerCanvas::Light *canvas_light = canvas_light_owner.get(p_rid);
1414 ERR_FAIL_COND_V(!canvas_light, true);
1415
1416 if (canvas_light->canvas.is_valid()) {
1417 Canvas *canvas = canvas_owner.get(canvas_light->canvas);
1418 if (canvas)
1419 canvas->lights.erase(canvas_light);
1420 }
1421
1422 if (canvas_light->shadow_buffer.is_valid())
1423 VSG::storage->free(canvas_light->shadow_buffer);
1424
1425 VSG::canvas_render->light_internal_free(canvas_light->light_internal);
1426
1427 canvas_light_owner.free(p_rid);
1428 memdelete(canvas_light);
1429
1430 } else if (canvas_light_occluder_owner.owns(p_rid)) {
1431
1432 RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_rid);
1433 ERR_FAIL_COND_V(!occluder, true);
1434
1435 if (occluder->polygon.is_valid()) {
1436
1437 LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(occluder->polygon);
1438 if (occluder_poly) {
1439 occluder_poly->owners.erase(occluder);
1440 }
1441 }
1442
1443 if (occluder->canvas.is_valid() && canvas_owner.owns(occluder->canvas)) {
1444
1445 Canvas *canvas = canvas_owner.get(occluder->canvas);
1446 canvas->occluders.erase(occluder);
1447 }
1448
1449 canvas_light_occluder_owner.free(p_rid);
1450 memdelete(occluder);
1451
1452 } else if (canvas_light_occluder_polygon_owner.owns(p_rid)) {
1453
1454 LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_rid);
1455 ERR_FAIL_COND_V(!occluder_poly, true);
1456 VSG::storage->free(occluder_poly->occluder);
1457
1458 while (occluder_poly->owners.size()) {
1459
1460 occluder_poly->owners.front()->get()->polygon = RID();
1461 occluder_poly->owners.erase(occluder_poly->owners.front());
1462 }
1463
1464 canvas_light_occluder_polygon_owner.free(p_rid);
1465 memdelete(occluder_poly);
1466 } else {
1467 return false;
1468 }
1469
1470 return true;
1471 }
1472
VisualServerCanvas()1473 VisualServerCanvas::VisualServerCanvas() {
1474
1475 z_list = (RasterizerCanvas::Item **)memalloc(z_range * sizeof(RasterizerCanvas::Item *));
1476 z_last_list = (RasterizerCanvas::Item **)memalloc(z_range * sizeof(RasterizerCanvas::Item *));
1477
1478 disable_scale = false;
1479 }
1480
~VisualServerCanvas()1481 VisualServerCanvas::~VisualServerCanvas() {
1482
1483 memfree(z_list);
1484 memfree(z_last_list);
1485 }
1486