blob: 9a24dcd36c4eb0f940a232740bfc0b5946531792 [file] [log] [blame]
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/vr/ui_scene.h"
#include <string>
#include <utility>
#include "base/containers/adapters.h"
#include "base/memory/ptr_util.h"
#include "base/numerics/ranges.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "base/values.h"
#include "chrome/browser/vr/databinding/binding_base.h"
#include "chrome/browser/vr/elements/draw_phase.h"
#include "chrome/browser/vr/elements/keyboard.h"
#include "chrome/browser/vr/elements/reticle.h"
#include "chrome/browser/vr/elements/ui_element.h"
#include "ui/gfx/transform.h"
namespace vr {
namespace {
template <typename P>
UiScene::Elements GetVisibleElements(UiElement* root,
P predicate) {
UiScene::Elements elements;
for (auto& element : *root) {
if (element.IsVisible() && predicate(&element))
elements.push_back(&element);
}
return elements;
}
} // namespace
void UiScene::AddUiElement(UiElementName parent,
std::unique_ptr<UiElement> element) {
CHECK_GE(element->id(), 0);
CHECK_EQ(GetUiElementById(element->id()), nullptr);
CHECK_GE(element->draw_phase(), 0);
if (gl_initialized_) {
for (auto& child : *element) {
child.Initialize(provider_);
}
}
GetUiElementByName(parent)->AddChild(std::move(element));
is_dirty_ = true;
}
std::unique_ptr<UiElement> UiScene::RemoveUiElement(int element_id) {
UiElement* to_remove = GetUiElementById(element_id);
CHECK_NE(nullptr, to_remove);
CHECK_NE(nullptr, to_remove->parent());
is_dirty_ = true;
return to_remove->parent()->RemoveChild(to_remove);
}
bool UiScene::OnBeginFrame(const base::TimeTicks& current_time,
const gfx::Vector3dF& look_at) {
bool scene_dirty = !initialized_scene_ || is_dirty_;
initialized_scene_ = true;
is_dirty_ = false;
{
TRACE_EVENT0("gpu", "UiScene::OnBeginFrame.UpdateBindings");
// Propagate updates across bindings.
for (auto& element : *root_element_) {
element.UpdateBindings();
element.set_update_phase(UiElement::kUpdatedBindings);
}
}
{
TRACE_EVENT0("gpu", "UiScene::OnBeginFrame.UpdateAnimations");
// Process all animations and pre-binding work. I.e., induce any
// time-related "dirtiness" on the scene graph.
for (auto& element : *root_element_) {
element.set_update_phase(UiElement::kDirty);
if ((element.DoBeginFrame(current_time, look_at) ||
element.updated_bindings_this_frame()) &&
(element.IsVisible() || element.updated_visiblity_this_frame())) {
scene_dirty = true;
}
}
}
{
TRACE_EVENT0("gpu", "UiScene::OnBeginFrame.UpdateTexturesAndSizes");
// Update textures and sizes.
// TODO(mthiesse): We should really only be updating the sizes here, and not
// actually redrawing the textures because we draw all of the textures as a
// second phase after OnBeginFrame, once we've processed input. For now this
// is fine, it's just a small amount of duplicated work.
// Textures will have to know what their size would be, if they were to draw
// with their current state, and changing anything other than texture
// synchronously in response to input should be prohibited.
for (auto& element : *root_element_) {
if (element.PrepareToDraw())
scene_dirty = true;
element.set_update_phase(UiElement::kUpdatedTexturesAndSizes);
}
}
if (!scene_dirty) {
// Nothing to update, so set all elements to the final update phase and
// return early.
for (auto& element : *root_element_) {
element.set_update_phase(UiElement::kUpdatedWorldSpaceTransform);
}
return false;
}
{
TRACE_EVENT0("gpu", "UiScene::OnBeginFrame.UpdateLayout");
// Update layout, which depends on size. Note that the layout phase changes
// the size of layout-type elements, as they adjust to fit the cumulative
// size of their children. This must be done in reverse order, such that
// children are correctly sized when laid out by their parent.
for (auto& element : base::Reversed(*root_element_)) {
element.DoLayOutChildren();
element.set_update_phase(UiElement::kUpdatedLayout);
}
}
{
TRACE_EVENT0("gpu", "UiScene::OnBeginFrame.UpdateWorldSpaceTransform");
// Now that we have finalized our local values, we can safely update our
// final, baked transform.
root_element_->UpdateWorldSpaceTransformRecursive();
}
return scene_dirty;
}
bool UiScene::UpdateTextures() {
bool needs_redraw = false;
// Update textures and sizes.
for (auto& element : *root_element_) {
if (element.PrepareToDraw())
needs_redraw = true;
}
return needs_redraw;
}
UiElement& UiScene::root_element() {
return *root_element_;
}
UiElement* UiScene::GetUiElementById(int element_id) const {
for (auto& element : *root_element_) {
if (element.id() == element_id)
return &element;
}
return nullptr;
}
UiElement* UiScene::GetUiElementByName(UiElementName name) const {
for (auto& element : *root_element_) {
if (element.name() == name)
return &element;
}
return nullptr;
}
UiScene::Elements UiScene::GetVisibleElementsToDraw() const {
return GetVisibleElements(GetUiElementByName(kRoot), [](UiElement* element) {
return element->draw_phase() == kPhaseForeground ||
element->draw_phase() == kPhaseBackground;
});
}
UiScene::Elements UiScene::GetVisibleWebVrOverlayElementsToDraw() const {
return GetVisibleElements(
GetUiElementByName(kWebVrRoot), [](UiElement* element) {
return element->draw_phase() == kPhaseOverlayForeground;
});
}
UiScene::Elements UiScene::GetPotentiallyVisibleElements() const {
UiScene::Elements elements;
for (auto& element : *root_element_) {
if (element.draw_phase() != kPhaseNone)
elements.push_back(&element);
}
return elements;
}
UiScene::UiScene() {
root_element_ = base::MakeUnique<UiElement>();
root_element_->SetName(kRoot);
root_element_->SetDrawPhase(kPhaseNone);
root_element_->set_hit_testable(false);
}
UiScene::~UiScene() = default;
void UiScene::OnGlInitialized(SkiaSurfaceProvider* provider) {
gl_initialized_ = true;
provider_ = provider;
for (auto& element : *root_element_)
element.Initialize(provider_);
}
} // namespace vr