Vector3 Camera::project_local_ray_normal(const Point2& p_pos) const { if (!is_inside_tree()) { ERR_EXPLAIN("Camera is not inside scene."); ERR_FAIL_COND_V(!is_inside_tree(),Vector3()); } #if 0 Size2 viewport_size = get_viewport()->get_visible_rect().size; Vector2 cpos = p_pos; #else Size2 viewport_size = get_viewport()->get_camera_rect_size(); Vector2 cpos = get_viewport()->get_camera_coords(p_pos); #endif Vector3 ray; if (mode==PROJECTION_ORTHOGONAL) { ray=Vector3(0,0,-1); } else { CameraMatrix cm; cm.set_perspective(fov,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH); float screen_w,screen_h; cm.get_viewport_size(screen_w,screen_h); ray=Vector3( ((cpos.x/viewport_size.width)*2.0-1.0)*screen_w, ((1.0-(cpos.y/viewport_size.height))*2.0-1.0)*screen_h,-near).normalized(); } return ray; };
void LifeForm::handle_event(const SDL_Event &event) { auto world = m_world.lock(); if (!world) { return; } if (event.type == SDL_MOUSEBUTTONDOWN) { if (event.button.button == SDL_BUTTON_LEFT) { const WorldRect viewport(world->get_viewport()); WorldPosition pos = get_pos(); WorldRect rect((int32_t)round(pos.x) - width/2, (int32_t)round(pos.y) - height/2, width, height); if (rect.contains(WorldPoint(event.button.x + viewport.x, event.button.y + viewport.y))) { set_focused(true); } else { set_focused(false); } } else if (focused() && event.button.button == SDL_BUTTON_RIGHT) { // Cancel m_lifeform's commands while (!m_commands.empty()) { m_commands.pop(); } const WorldRect viewport(world->get_viewport()); for (auto pt : world->get_path(get_pos(), WorldPosition(event.button.x + viewport.x, event.button.y + viewport.y))) { m_commands.emplace(new MoveCommand(this, WorldPosition(pt.x, pt.y))); } } } }
Vector3 ARVRCamera::project_local_ray_normal(const Point2 &p_pos) const { // get our ARVRServer ARVRServer *arvr_server = ARVRServer::get_singleton(); ERR_FAIL_NULL_V(arvr_server, Vector3()); Ref<ARVRInterface> arvr_interface = arvr_server->get_primary_interface(); if (arvr_interface.is_null()) { // we might be in the editor or have VR turned off, just call superclass return Camera::project_local_ray_normal(p_pos); } if (!is_inside_tree()) { ERR_EXPLAIN("Camera is not inside scene."); ERR_FAIL_COND_V(!is_inside_tree(), Vector3()); }; Size2 viewport_size = get_viewport()->get_camera_rect_size(); Vector2 cpos = get_viewport()->get_camera_coords(p_pos); Vector3 ray; CameraMatrix cm = arvr_interface->get_projection_for_eye(ARVRInterface::EYE_MONO, viewport_size.aspect(), get_znear(), get_zfar()); float screen_w, screen_h; cm.get_viewport_size(screen_w, screen_h); ray = Vector3(((cpos.x / viewport_size.width) * 2.0 - 1.0) * screen_w, ((1.0 - (cpos.y / viewport_size.height)) * 2.0 - 1.0) * screen_h, -get_znear()).normalized(); return ray; };
void Listener::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_WORLD: { bool first_listener = get_viewport()->_listener_add(this); if (!get_tree()->is_node_being_edited(this) && (current || first_listener)) make_current(); } break; case NOTIFICATION_TRANSFORM_CHANGED: { _request_listener_update(); } break; case NOTIFICATION_EXIT_WORLD: { if (!get_tree()->is_node_being_edited(this)) { if (is_current()) { clear_current(); current = true; //keep it true } else { current = false; } } get_viewport()->_listener_remove(this); } break; } }
void CL_OpenGLWindowProvider_GLX::update(const CL_Rect &_rect) { int width = get_viewport().get_width(); int height = get_viewport().get_height(); CL_Rect rect = _rect; if (rect.left < 0) rect.left = 0; if (rect.top < 0) rect.top = 0; if (rect.right > width) rect.right = width; if (rect.bottom > height) rect.bottom = height; if (rect.right <= rect.left || rect.bottom <= rect.top) return; CL_OpenGL::set_active(gc); glFlush(); GLboolean isDoubleBuffered = GL_TRUE; glGetBooleanv(GL_DOUBLEBUFFER, &isDoubleBuffered); if (isDoubleBuffered) { GLint read_last_bound; GLint draw_last_bound; glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &read_last_bound); glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &draw_last_bound); glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glReadBuffer(GL_BACK); glDrawBuffer(GL_FRONT); glBlitFramebuffer( rect.left, height - rect.bottom, rect.right, height - rect.top, rect.left, height - rect.bottom, rect.right, height - rect.top, GL_COLOR_BUFFER_BIT, GL_LINEAR); glDrawBuffer(GL_BACK); glReadBuffer(GL_FRONT); if (read_last_bound) glBindFramebuffer(GL_READ_FRAMEBUFFER, read_last_bound); if (draw_last_bound) glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw_last_bound); glFlush(); } }
void Listener::clear_current() { current = false; if (!is_inside_tree()) return; if (get_viewport()->get_listener() == this) { get_viewport()->_listener_set(NULL); get_viewport()->_listener_make_next_current(this); } }
void Camera::clear_current() { current = false; if (!is_inside_tree()) return; if (get_viewport()->get_camera() == this) { get_viewport()->_camera_set(NULL); get_viewport()->_camera_make_next_current(this); } }
void SWRenderDisplayWindowProvider::flip(int interval) { SWRenderGraphicContextProvider *gc_provider = static_cast<SWRenderGraphicContextProvider*>(gc.get_provider()); PixelCanvas *canvas = gc_provider->get_canvas(); #ifdef WIN32 HWND hwnd = window.get_hwnd(); HDC hdc = GetDC(hwnd); draw_image(hdc, get_viewport(), canvas->to_pixelbuffer()); ReleaseDC(hwnd, hdc); #elif !defined(__APPLE__) PixelBuffer &image = canvas->to_pixelbuffer(); draw_image(get_viewport(), image, Rect(0, 0, image.get_width(), image.get_height())); #endif if (interval == -1) interval = swap_interval; // use swap interval from the previous flip else swap_interval = interval; if (interval<=0) { flip_timer_set = false; } else { if (!flip_timer_set) { flip_last_time = System::get_time(); flip_timer_set = true; } else { ubyte64 current_time = System::get_time(); int time_diff = current_time - flip_last_time; interval *= 1000 / refresh_rate; int time_wait = interval - time_diff; if ( (time_wait > 0) && (time_wait < interval) ) { System::sleep(time_wait); flip_last_time = current_time + time_wait; } else { flip_last_time = current_time; } } } }
void MenuButton::_unhandled_key_input(Ref<InputEvent> p_event) { if (p_event->is_pressed() && !p_event->is_echo() && (Object::cast_to<InputEventKey>(p_event.ptr()) || Object::cast_to<InputEventJoypadButton>(p_event.ptr()) || Object::cast_to<InputEventAction>(*p_event))) { if (!get_parent() || !is_visible_in_tree() || is_disabled()) return; bool global_only = (get_viewport()->get_modal_stack_top() && !get_viewport()->get_modal_stack_top()->is_a_parent_of(this)); if (popup->activate_item_by_event(p_event, global_only)) accept_event(); } }
void Node::set_process_unhandled_key_input(bool p_enable) { if (p_enable==data.unhandled_key_input) return; data.unhandled_key_input=p_enable; if (!is_inside_tree()) return; if (p_enable) add_to_group("_vp_unhandled_key_input"+itos(get_viewport()->get_instance_ID())); else remove_from_group("_vp_unhandled_key_input"+itos(get_viewport()->get_instance_ID())); }
void BaseButton::_unhandled_input(InputEvent p_event) { if (!is_disabled() && is_visible() && p_event.is_pressed() && !p_event.is_echo() && shortcut.is_valid() && shortcut->is_shortcut(p_event)) { if (get_viewport()->get_modal_stack_top() && !get_viewport()->get_modal_stack_top()->is_a_parent_of(this)) return; //ignore because of modal window if (is_toggle_mode()) { set_pressed(!is_pressed()); emit_signal("toggled",is_pressed()); } emit_signal("pressed"); } }
void CanvasItem::_enter_canvas() { if ((!Object::cast_to<CanvasItem>(get_parent())) || toplevel) { Node *n = this; canvas_layer = NULL; while (n) { canvas_layer = Object::cast_to<CanvasLayer>(n); if (canvas_layer) { break; } n = n->get_parent(); } RID canvas; if (canvas_layer) canvas = canvas_layer->get_world_2d()->get_canvas(); else canvas = get_viewport()->find_world_2d()->get_canvas(); VisualServer::get_singleton()->canvas_item_set_parent(canvas_item, canvas); group = "root_canvas" + itos(canvas.get_id()); add_to_group(group); if (canvas_layer) canvas_layer->reset_sort_index(); else get_viewport()->gui_reset_canvas_sort_index(); get_tree()->call_group_flags(SceneTree::GROUP_CALL_UNIQUE, group, "_toplevel_raise_self"); } else { CanvasItem *parent = get_parent_item(); canvas_layer = parent->canvas_layer; VisualServer::get_singleton()->canvas_item_set_parent(canvas_item, parent->get_canvas_item()); VisualServer::get_singleton()->canvas_item_set_draw_index(canvas_item, get_index()); } pending_update = false; update(); notification(NOTIFICATION_ENTER_CANVAS); }
void Camera::_notification(int p_what) { switch(p_what) { case NOTIFICATION_ENTER_WORLD: { bool first_camera = get_viewport()->_camera_add(this); if (!get_tree()->is_node_being_edited(this) && (current || first_camera)) make_current(); } break; case NOTIFICATION_TRANSFORM_CHANGED: { _request_camera_update(); } break; case NOTIFICATION_EXIT_WORLD: { if (!get_tree()->is_node_being_edited(this)) { if (is_current()) { clear_current(); current=true; //keep it true } else { current=false; } } get_viewport()->_camera_remove(this); } break; case NOTIFICATION_BECAME_CURRENT: { if (get_world().is_valid()) { get_world()->_register_camera(this); } } break; case NOTIFICATION_LOST_CURRENT: { if (get_world().is_valid()) { get_world()->_remove_camera(this); } } break; } }
Vector3 ARVRCamera::project_position(const Point2 &p_point) const { // get our ARVRServer ARVRServer *arvr_server = ARVRServer::get_singleton(); ERR_FAIL_NULL_V(arvr_server, Vector3()); Ref<ARVRInterface> arvr_interface = arvr_server->get_primary_interface(); if (arvr_interface.is_null()) { // we might be in the editor or have VR turned off, just call superclass return Camera::project_position(p_point); } if (!is_inside_tree()) { ERR_EXPLAIN("Camera is not inside scene."); ERR_FAIL_COND_V(!is_inside_tree(), Vector3()); }; Size2 viewport_size = get_viewport()->get_visible_rect().size; CameraMatrix cm = arvr_interface->get_projection_for_eye(ARVRInterface::EYE_MONO, viewport_size.aspect(), get_znear(), get_zfar()); Size2 vp_size; cm.get_viewport_size(vp_size.x, vp_size.y); Vector2 point; point.x = (p_point.x / viewport_size.x) * 2.0 - 1.0; point.y = (1.0 - (p_point.y / viewport_size.y)) * 2.0 - 1.0; point *= vp_size; Vector3 p(point.x, point.y, -get_znear()); return get_camera_transform().xform(p); };
Transform2D CanvasItem::get_viewport_transform() const { ERR_FAIL_COND_V(!is_inside_tree(), Transform2D()); if (canvas_layer) { if (get_viewport()) { return get_viewport()->get_final_transform() * canvas_layer->get_transform(); } else { return canvas_layer->get_transform(); } } else { return get_viewport()->get_final_transform() * get_viewport()->get_canvas_transform(); } }
Vector3 Camera::project_position(const Point2& p_point) const { if (!is_inside_tree()) { ERR_EXPLAIN("Camera is not inside scene."); ERR_FAIL_COND_V(!is_inside_tree(),Vector3()); } Size2 viewport_size = get_viewport()->get_visible_rect().size; CameraMatrix cm; if (mode==PROJECTION_ORTHOGONAL) cm.set_orthogonal(size,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH); else cm.set_perspective(fov,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH); Size2 vp_size; cm.get_viewport_size(vp_size.x,vp_size.y); Vector2 point; point.x = (p_point.x/viewport_size.x) * 2.0 - 1.0; point.y = (1.0-(p_point.y/viewport_size.y)) * 2.0 - 1.0; point*=vp_size; Vector3 p(point.x,point.y,-near); return get_camera_transform().xform(p); }
void Camera2D::set_custom_viewport(Node *p_viewport) { ERR_FAIL_NULL(p_viewport); if (is_inside_tree()) { remove_from_group(group_name); remove_from_group(canvas_group_name); } custom_viewport = Object::cast_to<Viewport>(p_viewport); if (custom_viewport) { custom_viewport_id = custom_viewport->get_instance_id(); } else { custom_viewport_id = 0; } if (is_inside_tree()) { if (custom_viewport) viewport = custom_viewport; else viewport = get_viewport(); RID vp = viewport->get_viewport_rid(); group_name = "__cameras_" + itos(vp.get_id()); canvas_group_name = "__cameras_c" + itos(canvas.get_id()); add_to_group(group_name); add_to_group(canvas_group_name); } }
Point2 ARVRCamera::unproject_position(const Vector3 &p_pos) const { // get our ARVRServer ARVRServer *arvr_server = ARVRServer::get_singleton(); ERR_FAIL_NULL_V(arvr_server, Vector2()); Ref<ARVRInterface> arvr_interface = arvr_server->get_primary_interface(); if (arvr_interface.is_null()) { // we might be in the editor or have VR turned off, just call superclass return Camera::unproject_position(p_pos); } if (!is_inside_tree()) { ERR_EXPLAIN("Camera is not inside scene."); ERR_FAIL_COND_V(!is_inside_tree(), Vector2()); }; Size2 viewport_size = get_viewport()->get_visible_rect().size; CameraMatrix cm = arvr_interface->get_projection_for_eye(ARVRInterface::EYE_MONO, viewport_size.aspect(), get_znear(), get_zfar()); Plane p(get_camera_transform().xform_inv(p_pos), 1.0); p = cm.xform4(p); p.normal /= p.d; Point2 res; res.x = (p.normal.x * 0.5 + 0.5) * viewport_size.x; res.y = (-p.normal.y * 0.5 + 0.5) * viewport_size.y; return res; };
bool CL_OpenGLWindowProvider_GLX::on_clicked(XButtonEvent &event) { if (event.button != 1) // Left mouse button return true; int height = get_viewport().get_height(); glDrawBuffer(GL_BACK); glReadBuffer(GL_FRONT); CL_Rect rect = CL_Rect(event.x,event.y, CL_Size(1,1)); CL_PixelBuffer pixelbuffer(rect.get_width(), rect.get_height(), cl_rgba8); glReadPixels( rect.left, height - rect.bottom, rect.right - rect.left, rect.bottom - rect.top, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, pixelbuffer.get_data()); const cl_ubyte32 *xptr = (const cl_ubyte32 *) (pixelbuffer.get_data()); if (((*xptr) & 0xFF) < 10) { XLowerWindow(x11_window.get_display(), x11_window.get_window()); return false; } return true; }
Point2 Camera::unproject_position(const Vector3& p_pos) const { if (!is_inside_tree()) { ERR_EXPLAIN("Camera is not inside scene."); ERR_FAIL_COND_V(!is_inside_tree(),Vector2()); } Size2 viewport_size = get_viewport()->get_visible_rect().size; CameraMatrix cm; if (mode==PROJECTION_ORTHOGONAL) cm.set_orthogonal(size,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH); else cm.set_perspective(fov,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH); Plane p(get_camera_transform().xform_inv(p_pos),1.0); p=cm.xform4(p); p.normal/=p.d; Point2 res; res.x = (p.normal.x * 0.5 + 0.5) * viewport_size.x; res.y = (-p.normal.y * 0.5 + 0.5) * viewport_size.y; return res; }
void update_lcd(void) { if(show_settings_time) //Einstellungen anzeigen { lcd_clrscr(); lcd_gotoxy(0,0); lcd_puts(font_name); char buf[3]; itoa(font_size,buf,10); lcd_puts(buf); } else //normaler Editor { lcd_command(LCD_DISP_ON); lcd_gotoxy(0,0); //_delay_us(30); uint8_t x; uint8_t cx, cy, vx, vy; get_viewport(&vx, &vy); get_cursor(&cx, &cy); for(x=0;x<LCD_WIDTH;x++) lcd_putc(get_text_buffer(vy)[vx+x]); for(x=0;x<LCD_WIDTH;x++) lcd_putc(get_text_buffer(vy+1)[vx+x]); lcd_gotoxy(cx-vx,cy-vy); lcd_command(LCD_DISP_ON_CURSOR); } }
Vector3 Camera::project_ray_origin(const Point2& p_pos) const { if (!is_inside_tree()) { ERR_EXPLAIN("Camera is not inside scene."); ERR_FAIL_COND_V(!is_inside_tree(),Vector3()); } #if 0 Size2 viewport_size = get_viewport()->get_visible_rect().size; Vector2 cpos = p_pos; #else Size2 viewport_size = get_viewport()->get_camera_rect_size(); Vector2 cpos = get_viewport()->get_camera_coords(p_pos); #endif ERR_FAIL_COND_V( viewport_size.y == 0, Vector3() ); // float aspect = viewport_size.x / viewport_size.y; if (mode == PROJECTION_PERSPECTIVE) { return get_camera_transform().origin; } else { Vector2 pos = cpos / viewport_size; float vsize,hsize; if (keep_aspect==KEEP_WIDTH) { vsize = size/viewport_size.get_aspect(); hsize = size; } else { hsize = size*viewport_size.get_aspect(); vsize = size; } Vector3 ray; ray.x = pos.x * (hsize) - hsize/2; ray.y = (1.0 - pos.y) * (vsize) - vsize/2; ray.z = -near; ray = get_camera_transform().xform(ray); return ray; }; };
RID CanvasItem::get_canvas() const { ERR_FAIL_COND_V(!is_inside_tree(), RID()); if (canvas_layer) return canvas_layer->get_world_2d()->get_canvas(); else return get_viewport()->find_world_2d()->get_canvas(); }
void Listener::make_current() { current = true; if (!is_inside_tree()) return; get_viewport()->_listener_set(this); }
bool Camera::is_current() const { if (is_inside_tree() && !get_tree()->is_node_being_edited(this)) { return get_viewport()->get_camera()==this; } else return current; return false; }
void CanvasItem::_toplevel_raise_self() { if (!is_inside_tree()) return; if (canvas_layer) VisualServer::get_singleton()->canvas_item_set_draw_index(canvas_item, canvas_layer->get_sort_index()); else VisualServer::get_singleton()->canvas_item_set_draw_index(canvas_item, get_viewport()->gui_get_canvas_sort_index()); }
void VisualShaderEditor::_input(const Ref<InputEvent> p_event) { if (graph->has_focus()) { Ref<InputEventMouseButton> mb = p_event; if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) { add_node->get_popup()->set_position(get_viewport()->get_mouse_position()); add_node->get_popup()->show_modal(); } } }
Matrix32 CanvasItem::get_canvas_transform() const { ERR_FAIL_COND_V(!is_inside_tree(),Matrix32()); if (canvas_layer) return canvas_layer->get_transform(); else return get_viewport()->get_canvas_transform(); }
Transform2D CanvasItem::get_canvas_transform() const { ERR_FAIL_COND_V(!is_inside_tree(), Transform2D()); if (canvas_layer) return canvas_layer->get_transform(); else if (Object::cast_to<CanvasItem>(get_parent())) return Object::cast_to<CanvasItem>(get_parent())->get_canvas_transform(); else return get_viewport()->get_canvas_transform(); }
void Camera::make_current() { current=true; if (!is_inside_tree()) return; get_viewport()->_camera_set(this); //get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,camera_group,"_camera_make_current",this); }