1 /*************************************************************************/
2 /* camera_2d.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2019 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 #include "camera_2d.h"
31 #include "scene/scene_string_names.h"
32 #include "servers/visual_server.h"
33
_update_scroll()34 void Camera2D::_update_scroll() {
35
36 if (!is_inside_tree())
37 return;
38
39 if (get_tree()->is_editor_hint()) {
40 update(); //will just be drawn
41 return;
42 }
43
44 if (current) {
45
46 ERR_FAIL_COND(custom_viewport && !ObjectDB::get_instance(custom_viewport_id));
47
48 Matrix32 xform = get_camera_transform();
49
50 if (viewport) {
51 viewport->set_canvas_transform(xform);
52 }
53 get_tree()->call_group(SceneTree::GROUP_CALL_REALTIME, group_name, "_camera_moved", xform);
54 };
55 }
56
set_zoom(const Vector2 & p_zoom)57 void Camera2D::set_zoom(const Vector2 &p_zoom) {
58
59 zoom = p_zoom;
60 Point2 old_smoothed_camera_pos = smoothed_camera_pos;
61 _update_scroll();
62 smoothed_camera_pos = old_smoothed_camera_pos;
63 };
64
get_zoom() const65 Vector2 Camera2D::get_zoom() const {
66
67 return zoom;
68 };
69
get_camera_transform()70 Matrix32 Camera2D::get_camera_transform() {
71
72 if (!get_tree())
73 return Matrix32();
74
75 Size2 screen_size = get_viewport_rect().size;
76 screen_size = get_viewport_rect().size;
77
78 Point2 new_camera_pos = get_global_transform().get_origin();
79 Point2 ret_camera_pos;
80
81 if (!first) {
82
83 if (anchor_mode == ANCHOR_MODE_DRAG_CENTER) {
84
85 if (h_drag_enabled && !get_tree()->is_editor_hint()) {
86 camera_pos.x = MIN(camera_pos.x, (new_camera_pos.x + screen_size.x * 0.5 * drag_margin[MARGIN_RIGHT]));
87 camera_pos.x = MAX(camera_pos.x, (new_camera_pos.x - screen_size.x * 0.5 * drag_margin[MARGIN_LEFT]));
88 } else {
89
90 if (h_ofs < 0) {
91 camera_pos.x = new_camera_pos.x + screen_size.x * 0.5 * drag_margin[MARGIN_RIGHT] * h_ofs;
92 } else {
93 camera_pos.x = new_camera_pos.x + screen_size.x * 0.5 * drag_margin[MARGIN_LEFT] * h_ofs;
94 }
95 }
96
97 if (v_drag_enabled && !get_tree()->is_editor_hint()) {
98
99 camera_pos.y = MIN(camera_pos.y, (new_camera_pos.y + screen_size.y * 0.5 * drag_margin[MARGIN_BOTTOM]));
100 camera_pos.y = MAX(camera_pos.y, (new_camera_pos.y - screen_size.y * 0.5 * drag_margin[MARGIN_TOP]));
101
102 } else {
103
104 if (v_ofs < 0) {
105 camera_pos.y = new_camera_pos.y + screen_size.y * 0.5 * drag_margin[MARGIN_TOP] * v_ofs;
106 } else {
107 camera_pos.y = new_camera_pos.y + screen_size.y * 0.5 * drag_margin[MARGIN_BOTTOM] * v_ofs;
108 }
109 }
110
111 } else if (anchor_mode == ANCHOR_MODE_FIXED_TOP_LEFT) {
112
113 camera_pos = new_camera_pos;
114 }
115
116 if (smoothing_enabled && !get_tree()->is_editor_hint()) {
117
118 float c = smoothing * get_fixed_process_delta_time();
119 smoothed_camera_pos = ((camera_pos - smoothed_camera_pos) * c) + smoothed_camera_pos;
120 ret_camera_pos = smoothed_camera_pos;
121 // camera_pos=camera_pos*(1.0-smoothing)+new_camera_pos*smoothing;
122 } else {
123
124 ret_camera_pos = smoothed_camera_pos = camera_pos;
125 }
126
127 } else {
128 ret_camera_pos = smoothed_camera_pos = camera_pos = new_camera_pos;
129 first = false;
130 }
131
132 Point2 screen_offset = (anchor_mode == ANCHOR_MODE_DRAG_CENTER ? (screen_size * 0.5 * zoom) : Point2());
133
134 float angle = get_global_transform().get_rotation();
135 if (rotating) {
136 screen_offset = screen_offset.rotated(angle);
137 }
138
139 Rect2 screen_rect(-screen_offset + ret_camera_pos, screen_size * zoom);
140 if (screen_rect.pos.x + screen_rect.size.x > limit[MARGIN_RIGHT])
141 screen_rect.pos.x = limit[MARGIN_RIGHT] - screen_rect.size.x;
142
143 if (screen_rect.pos.y + screen_rect.size.y > limit[MARGIN_BOTTOM])
144 screen_rect.pos.y = limit[MARGIN_BOTTOM] - screen_rect.size.y;
145
146 if (screen_rect.pos.x < limit[MARGIN_LEFT])
147 screen_rect.pos.x = limit[MARGIN_LEFT];
148
149 if (screen_rect.pos.y < limit[MARGIN_TOP])
150 screen_rect.pos.y = limit[MARGIN_TOP];
151
152 if (offset != Vector2()) {
153
154 screen_rect.pos += offset;
155 if (screen_rect.pos.x + screen_rect.size.x > limit[MARGIN_RIGHT])
156 screen_rect.pos.x = limit[MARGIN_RIGHT] - screen_rect.size.x;
157
158 if (screen_rect.pos.y + screen_rect.size.y > limit[MARGIN_BOTTOM])
159 screen_rect.pos.y = limit[MARGIN_BOTTOM] - screen_rect.size.y;
160
161 if (screen_rect.pos.x < limit[MARGIN_LEFT])
162 screen_rect.pos.x = limit[MARGIN_LEFT];
163
164 if (screen_rect.pos.y < limit[MARGIN_TOP])
165 screen_rect.pos.y = limit[MARGIN_TOP];
166 }
167
168 camera_screen_center = screen_rect.pos + screen_rect.size * 0.5;
169
170 Matrix32 xform;
171 if (rotating) {
172 xform.set_rotation(angle);
173 }
174 xform.scale_basis(zoom);
175 xform.set_origin(screen_rect.pos /*.floor()*/);
176
177 /*
178 if (0) {
179
180 xform = get_global_transform() * xform;
181 } else {
182
183 xform.elements[2]+=get_global_transform().get_origin();
184 }
185 */
186
187 return (xform).affine_inverse();
188 }
189
_notification(int p_what)190 void Camera2D::_notification(int p_what) {
191
192 switch (p_what) {
193
194 case NOTIFICATION_FIXED_PROCESS: {
195
196 _update_scroll();
197
198 } break;
199 case NOTIFICATION_TRANSFORM_CHANGED: {
200
201 if (!is_fixed_processing())
202 _update_scroll();
203
204 } break;
205 case NOTIFICATION_ENTER_TREE: {
206
207 if (custom_viewport && ObjectDB::get_instance(custom_viewport_id)) {
208 viewport = custom_viewport;
209 } else {
210 viewport = get_viewport();
211 }
212
213 canvas = get_canvas();
214
215 RID vp = viewport->get_viewport();
216
217 group_name = "__cameras_" + itos(vp.get_id());
218 canvas_group_name = "__cameras_c" + itos(canvas.get_id());
219 add_to_group(group_name);
220 add_to_group(canvas_group_name);
221
222 if (get_tree()->is_editor_hint()) {
223 set_fixed_process(false);
224 }
225
226 _update_scroll();
227 first = true;
228
229 } break;
230 case NOTIFICATION_EXIT_TREE: {
231
232 if (is_current()) {
233 if (viewport && !(custom_viewport && !ObjectDB::get_instance(custom_viewport_id))) {
234 viewport->set_canvas_transform(Matrix32());
235 }
236 }
237 remove_from_group(group_name);
238 remove_from_group(canvas_group_name);
239 viewport = NULL;
240
241 } break;
242 case NOTIFICATION_DRAW: {
243
244 if (!is_inside_tree() || !get_tree()->is_editor_hint())
245 break;
246
247 Color area_axis_color(0.5, 0.42, 0.87, 0.63);
248 float area_axis_width = 1;
249 if (current)
250 area_axis_width = 3;
251
252 Matrix32 inv_camera_transform = get_camera_transform().affine_inverse();
253 Size2 screen_size = get_viewport_rect().size;
254
255 Vector2 screen_endpoints[4] = {
256 inv_camera_transform.xform(Vector2(0, 0)),
257 inv_camera_transform.xform(Vector2(screen_size.width, 0)),
258 inv_camera_transform.xform(Vector2(screen_size.width, screen_size.height)),
259 inv_camera_transform.xform(Vector2(0, screen_size.height))
260 };
261
262 Matrix32 inv_transform = get_global_transform().affine_inverse(); // undo global space
263
264 for (int i = 0; i < 4; i++) {
265 draw_line(inv_transform.xform(screen_endpoints[i]), inv_transform.xform(screen_endpoints[(i + 1) % 4]), area_axis_color, area_axis_width);
266 }
267
268 } break;
269 }
270 }
271
set_offset(const Vector2 & p_offset)272 void Camera2D::set_offset(const Vector2 &p_offset) {
273
274 offset = p_offset;
275 _update_scroll();
276 }
277
get_offset() const278 Vector2 Camera2D::get_offset() const {
279
280 return offset;
281 }
282
set_anchor_mode(AnchorMode p_anchor_mode)283 void Camera2D::set_anchor_mode(AnchorMode p_anchor_mode) {
284
285 anchor_mode = p_anchor_mode;
286 _update_scroll();
287 }
288
get_anchor_mode() const289 Camera2D::AnchorMode Camera2D::get_anchor_mode() const {
290
291 return anchor_mode;
292 }
293
set_rotating(bool p_rotating)294 void Camera2D::set_rotating(bool p_rotating) {
295
296 rotating = p_rotating;
297 _update_scroll();
298 }
299
is_rotating() const300 bool Camera2D::is_rotating() const {
301
302 return rotating;
303 }
304
_make_current(Object * p_which)305 void Camera2D::_make_current(Object *p_which) {
306
307 if (p_which == this) {
308
309 current = true;
310 _update_scroll();
311 } else {
312 current = false;
313 }
314 }
315
_set_current(bool p_current)316 void Camera2D::_set_current(bool p_current) {
317
318 if (p_current)
319 make_current();
320
321 current = p_current;
322 }
323
is_current() const324 bool Camera2D::is_current() const {
325
326 return current;
327 }
328
make_current()329 void Camera2D::make_current() {
330
331 if (!is_inside_tree()) {
332 current = true;
333 } else {
334 get_tree()->call_group(SceneTree::GROUP_CALL_REALTIME, group_name, "_make_current", this);
335 }
336 }
337
clear_current()338 void Camera2D::clear_current() {
339
340 current = false;
341 if (is_inside_tree()) {
342 get_tree()->call_group(SceneTree::GROUP_CALL_REALTIME, group_name, "_make_current", (Object *)(NULL));
343 }
344 }
345
set_limit(Margin p_margin,int p_limit)346 void Camera2D::set_limit(Margin p_margin, int p_limit) {
347
348 ERR_FAIL_INDEX(p_margin, 4);
349 limit[p_margin] = p_limit;
350 }
351
get_limit(Margin p_margin) const352 int Camera2D::get_limit(Margin p_margin) const {
353
354 ERR_FAIL_INDEX_V(p_margin, 4, 0);
355 return limit[p_margin];
356 }
357
set_drag_margin(Margin p_margin,float p_drag_margin)358 void Camera2D::set_drag_margin(Margin p_margin, float p_drag_margin) {
359
360 ERR_FAIL_INDEX(p_margin, 4);
361 drag_margin[p_margin] = p_drag_margin;
362 }
363
get_drag_margin(Margin p_margin) const364 float Camera2D::get_drag_margin(Margin p_margin) const {
365
366 ERR_FAIL_INDEX_V(p_margin, 4, 0);
367 return drag_margin[p_margin];
368 }
369
get_camera_pos() const370 Vector2 Camera2D::get_camera_pos() const {
371
372 return camera_pos;
373 }
374
force_update_scroll()375 void Camera2D::force_update_scroll() {
376
377 _update_scroll();
378 }
379
reset_smoothing()380 void Camera2D::reset_smoothing() {
381
382 smoothed_camera_pos = camera_pos;
383 _update_scroll();
384 }
385
align()386 void Camera2D::align() {
387
388 Size2 screen_size = get_viewport_rect().size;
389 screen_size = get_viewport_rect().size;
390 Point2 current_camera_pos = get_global_transform().get_origin();
391 if (anchor_mode == ANCHOR_MODE_DRAG_CENTER) {
392 if (h_ofs < 0) {
393 camera_pos.x = current_camera_pos.x + screen_size.x * 0.5 * drag_margin[MARGIN_RIGHT] * h_ofs;
394 } else {
395 camera_pos.x = current_camera_pos.x + screen_size.x * 0.5 * drag_margin[MARGIN_LEFT] * h_ofs;
396 }
397 if (v_ofs < 0) {
398 camera_pos.y = current_camera_pos.y + screen_size.y * 0.5 * drag_margin[MARGIN_TOP] * v_ofs;
399 } else {
400 camera_pos.y = current_camera_pos.y + screen_size.y * 0.5 * drag_margin[MARGIN_BOTTOM] * v_ofs;
401 }
402 } else if (anchor_mode == ANCHOR_MODE_FIXED_TOP_LEFT) {
403
404 camera_pos = current_camera_pos;
405 }
406
407 _update_scroll();
408 }
409
set_follow_smoothing(float p_speed)410 void Camera2D::set_follow_smoothing(float p_speed) {
411
412 smoothing = p_speed;
413 if (smoothing > 0 && !(is_inside_tree() && get_tree()->is_editor_hint()))
414 set_fixed_process(true);
415 else
416 set_fixed_process(false);
417 }
418
get_follow_smoothing() const419 float Camera2D::get_follow_smoothing() const {
420
421 return smoothing;
422 }
423
get_camera_screen_center() const424 Point2 Camera2D::get_camera_screen_center() const {
425
426 return camera_screen_center;
427 }
428
set_h_drag_enabled(bool p_enabled)429 void Camera2D::set_h_drag_enabled(bool p_enabled) {
430
431 h_drag_enabled = p_enabled;
432 }
433
is_h_drag_enabled() const434 bool Camera2D::is_h_drag_enabled() const {
435
436 return h_drag_enabled;
437 }
438
set_v_drag_enabled(bool p_enabled)439 void Camera2D::set_v_drag_enabled(bool p_enabled) {
440
441 v_drag_enabled = p_enabled;
442 }
443
is_v_drag_enabled() const444 bool Camera2D::is_v_drag_enabled() const {
445
446 return v_drag_enabled;
447 }
448
set_v_offset(float p_offset)449 void Camera2D::set_v_offset(float p_offset) {
450
451 v_ofs = p_offset;
452 }
453
get_v_offset() const454 float Camera2D::get_v_offset() const {
455
456 return v_ofs;
457 }
458
set_h_offset(float p_offset)459 void Camera2D::set_h_offset(float p_offset) {
460
461 h_ofs = p_offset;
462 }
get_h_offset() const463 float Camera2D::get_h_offset() const {
464
465 return h_ofs;
466 }
467
_set_old_smoothing(float p_val)468 void Camera2D::_set_old_smoothing(float p_val) {
469 //compatibility
470 if (p_val > 0) {
471 smoothing_enabled = true;
472 set_follow_smoothing(p_val);
473 }
474 }
475
set_enable_follow_smoothing(bool p_enabled)476 void Camera2D::set_enable_follow_smoothing(bool p_enabled) {
477
478 smoothing_enabled = p_enabled;
479 }
480
is_follow_smoothing_enabled() const481 bool Camera2D::is_follow_smoothing_enabled() const {
482
483 return smoothing_enabled;
484 }
485
set_custom_viewport(Node * p_viewport)486 void Camera2D::set_custom_viewport(Node *p_viewport) {
487 ERR_FAIL_NULL(p_viewport);
488 if (is_inside_tree()) {
489 remove_from_group(group_name);
490 remove_from_group(canvas_group_name);
491 }
492
493 custom_viewport = p_viewport->cast_to<Viewport>();
494
495 if (custom_viewport) {
496 custom_viewport_id = custom_viewport->get_instance_ID();
497 } else {
498 custom_viewport_id = 0;
499 }
500
501 if (is_inside_tree()) {
502
503 if (custom_viewport)
504 viewport = custom_viewport;
505 else
506 viewport = get_viewport();
507
508 RID vp = viewport->get_viewport();
509 group_name = "__cameras_" + itos(vp.get_id());
510 canvas_group_name = "__cameras_c" + itos(canvas.get_id());
511 add_to_group(group_name);
512 add_to_group(canvas_group_name);
513 }
514 }
515
get_custom_viewport() const516 Node *Camera2D::get_custom_viewport() const {
517
518 return custom_viewport;
519 }
520
_bind_methods()521 void Camera2D::_bind_methods() {
522
523 ObjectTypeDB::bind_method(_MD("set_offset", "offset"), &Camera2D::set_offset);
524 ObjectTypeDB::bind_method(_MD("get_offset"), &Camera2D::get_offset);
525
526 ObjectTypeDB::bind_method(_MD("set_anchor_mode", "anchor_mode"), &Camera2D::set_anchor_mode);
527 ObjectTypeDB::bind_method(_MD("get_anchor_mode"), &Camera2D::get_anchor_mode);
528
529 ObjectTypeDB::bind_method(_MD("set_rotating", "rotating"), &Camera2D::set_rotating);
530 ObjectTypeDB::bind_method(_MD("is_rotating"), &Camera2D::is_rotating);
531
532 ObjectTypeDB::bind_method(_MD("make_current"), &Camera2D::make_current);
533 ObjectTypeDB::bind_method(_MD("clear_current"), &Camera2D::clear_current);
534 ObjectTypeDB::bind_method(_MD("_make_current"), &Camera2D::_make_current);
535
536 ObjectTypeDB::bind_method(_MD("_update_scroll"), &Camera2D::_update_scroll);
537
538 ObjectTypeDB::bind_method(_MD("_set_current", "current"), &Camera2D::_set_current);
539 ObjectTypeDB::bind_method(_MD("is_current"), &Camera2D::is_current);
540
541 ObjectTypeDB::bind_method(_MD("set_limit", "margin", "limit"), &Camera2D::set_limit);
542 ObjectTypeDB::bind_method(_MD("get_limit", "margin"), &Camera2D::get_limit);
543
544 ObjectTypeDB::bind_method(_MD("set_v_drag_enabled", "enabled"), &Camera2D::set_v_drag_enabled);
545 ObjectTypeDB::bind_method(_MD("is_v_drag_enabled"), &Camera2D::is_v_drag_enabled);
546
547 ObjectTypeDB::bind_method(_MD("set_h_drag_enabled", "enabled"), &Camera2D::set_h_drag_enabled);
548 ObjectTypeDB::bind_method(_MD("is_h_drag_enabled"), &Camera2D::is_h_drag_enabled);
549
550 ObjectTypeDB::bind_method(_MD("set_v_offset", "ofs"), &Camera2D::set_v_offset);
551 ObjectTypeDB::bind_method(_MD("get_v_offset"), &Camera2D::get_v_offset);
552
553 ObjectTypeDB::bind_method(_MD("set_h_offset", "ofs"), &Camera2D::set_h_offset);
554 ObjectTypeDB::bind_method(_MD("get_h_offset"), &Camera2D::get_h_offset);
555
556 ObjectTypeDB::bind_method(_MD("set_drag_margin", "margin", "drag_margin"), &Camera2D::set_drag_margin);
557 ObjectTypeDB::bind_method(_MD("get_drag_margin", "margin"), &Camera2D::get_drag_margin);
558
559 ObjectTypeDB::bind_method(_MD("get_camera_pos"), &Camera2D::get_camera_pos);
560 ObjectTypeDB::bind_method(_MD("get_camera_screen_center"), &Camera2D::get_camera_screen_center);
561
562 ObjectTypeDB::bind_method(_MD("set_zoom", "zoom"), &Camera2D::set_zoom);
563 ObjectTypeDB::bind_method(_MD("get_zoom"), &Camera2D::get_zoom);
564
565 ObjectTypeDB::bind_method(_MD("set_custom_viewport", "viewport:Viewport"), &Camera2D::set_custom_viewport);
566 ObjectTypeDB::bind_method(_MD("get_custom_viewport:Viewport"), &Camera2D::get_custom_viewport);
567
568 ObjectTypeDB::bind_method(_MD("set_follow_smoothing", "follow_smoothing"), &Camera2D::set_follow_smoothing);
569 ObjectTypeDB::bind_method(_MD("get_follow_smoothing"), &Camera2D::get_follow_smoothing);
570
571 ObjectTypeDB::bind_method(_MD("set_enable_follow_smoothing", "follow_smoothing"), &Camera2D::set_enable_follow_smoothing);
572 ObjectTypeDB::bind_method(_MD("is_follow_smoothing_enabled"), &Camera2D::is_follow_smoothing_enabled);
573
574 ObjectTypeDB::bind_method(_MD("force_update_scroll"), &Camera2D::force_update_scroll);
575 ObjectTypeDB::bind_method(_MD("reset_smoothing"), &Camera2D::reset_smoothing);
576 ObjectTypeDB::bind_method(_MD("align"), &Camera2D::align);
577
578 ObjectTypeDB::bind_method(_MD("_set_old_smoothing", "follow_smoothing"), &Camera2D::_set_old_smoothing);
579
580 ADD_PROPERTYNZ(PropertyInfo(Variant::VECTOR2, "offset"), _SCS("set_offset"), _SCS("get_offset"));
581 ADD_PROPERTY(PropertyInfo(Variant::INT, "anchor_mode", PROPERTY_HINT_ENUM, "Fixed TopLeft,Drag Center"), _SCS("set_anchor_mode"), _SCS("get_anchor_mode"));
582 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "rotating"), _SCS("set_rotating"), _SCS("is_rotating"));
583 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "current"), _SCS("_set_current"), _SCS("is_current"));
584 ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "zoom"), _SCS("set_zoom"), _SCS("get_zoom"));
585
586 ADD_PROPERTYI(PropertyInfo(Variant::INT, "limit/left"), _SCS("set_limit"), _SCS("get_limit"), MARGIN_LEFT);
587 ADD_PROPERTYI(PropertyInfo(Variant::INT, "limit/top"), _SCS("set_limit"), _SCS("get_limit"), MARGIN_TOP);
588 ADD_PROPERTYI(PropertyInfo(Variant::INT, "limit/right"), _SCS("set_limit"), _SCS("get_limit"), MARGIN_RIGHT);
589 ADD_PROPERTYI(PropertyInfo(Variant::INT, "limit/bottom"), _SCS("set_limit"), _SCS("get_limit"), MARGIN_BOTTOM);
590
591 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "drag_margin/h_enabled"), _SCS("set_h_drag_enabled"), _SCS("is_h_drag_enabled"));
592 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "drag_margin/v_enabled"), _SCS("set_v_drag_enabled"), _SCS("is_v_drag_enabled"));
593
594 ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smoothing/enable"), _SCS("set_enable_follow_smoothing"), _SCS("is_follow_smoothing_enabled"));
595 ADD_PROPERTY(PropertyInfo(Variant::REAL, "smoothing/speed"), _SCS("set_follow_smoothing"), _SCS("get_follow_smoothing"));
596
597 //compatibility
598 ADD_PROPERTY(PropertyInfo(Variant::REAL, "smoothing", PROPERTY_HINT_NONE, "", 0), _SCS("_set_old_smoothing"), _SCS("get_follow_smoothing"));
599
600 ADD_PROPERTYI(PropertyInfo(Variant::REAL, "drag_margin/left", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_drag_margin"), _SCS("get_drag_margin"), MARGIN_LEFT);
601 ADD_PROPERTYI(PropertyInfo(Variant::REAL, "drag_margin/top", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_drag_margin"), _SCS("get_drag_margin"), MARGIN_TOP);
602 ADD_PROPERTYI(PropertyInfo(Variant::REAL, "drag_margin/right", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_drag_margin"), _SCS("get_drag_margin"), MARGIN_RIGHT);
603 ADD_PROPERTYI(PropertyInfo(Variant::REAL, "drag_margin/bottom", PROPERTY_HINT_RANGE, "0,1,0.01"), _SCS("set_drag_margin"), _SCS("get_drag_margin"), MARGIN_BOTTOM);
604
605 BIND_CONSTANT(ANCHOR_MODE_DRAG_CENTER);
606 BIND_CONSTANT(ANCHOR_MODE_FIXED_TOP_LEFT);
607 }
608
Camera2D()609 Camera2D::Camera2D() {
610
611 anchor_mode = ANCHOR_MODE_DRAG_CENTER;
612 rotating = false;
613 current = false;
614 limit[MARGIN_LEFT] = -10000000;
615 limit[MARGIN_TOP] = -10000000;
616 limit[MARGIN_RIGHT] = 10000000;
617 limit[MARGIN_BOTTOM] = 10000000;
618 drag_margin[MARGIN_LEFT] = 0.2;
619 drag_margin[MARGIN_TOP] = 0.2;
620 drag_margin[MARGIN_RIGHT] = 0.2;
621 drag_margin[MARGIN_BOTTOM] = 0.2;
622 camera_pos = Vector2();
623 first = true;
624 smoothing_enabled = false;
625 custom_viewport = NULL;
626 custom_viewport_id = 0;
627
628 smoothing = 5.0;
629 zoom = Vector2(1, 1);
630
631 h_drag_enabled = true;
632 v_drag_enabled = true;
633 h_ofs = 0;
634 v_ofs = 0;
635 }
636