| // Copyright 2013 The Flutter 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 "impeller/aiks/aiks_playground_inspector.h" |
| |
| #include <initializer_list> |
| |
| #include "impeller/core/capture.h" |
| #include "impeller/entity/entity_pass.h" |
| #include "impeller/renderer/context.h" |
| #include "third_party/imgui/imgui.h" |
| #include "third_party/imgui/imgui_internal.h" |
| |
| namespace impeller { |
| |
| static const char* kElementsWindowName = "Elements"; |
| static const char* kPropertiesWindowName = "Properties"; |
| |
| static const std::initializer_list<std::string> kSupportedDocuments = { |
| EntityPass::kCaptureDocumentName}; |
| |
| AiksInspector::AiksInspector() = default; |
| |
| const std::optional<Picture>& AiksInspector::RenderInspector( |
| AiksContext& aiks_context, |
| const std::function<std::optional<Picture>()>& picture_callback) { |
| //---------------------------------------------------------------------------- |
| /// Configure the next frame. |
| /// |
| |
| RenderCapture(aiks_context.GetContext()->capture); |
| |
| //---------------------------------------------------------------------------- |
| /// Configure the next frame. |
| /// |
| |
| if (ImGui::IsKeyPressed(ImGuiKey_Z)) { |
| wireframe_ = !wireframe_; |
| aiks_context.GetContentContext().SetWireframe(wireframe_); |
| } |
| |
| if (ImGui::IsKeyPressed(ImGuiKey_C)) { |
| capturing_ = !capturing_; |
| if (capturing_) { |
| aiks_context.GetContext()->capture = |
| CaptureContext::MakeAllowlist({kSupportedDocuments}); |
| } |
| } |
| if (!capturing_) { |
| hovered_element_ = nullptr; |
| selected_element_ = nullptr; |
| aiks_context.GetContext()->capture = CaptureContext::MakeInactive(); |
| std::optional<Picture> new_picture = picture_callback(); |
| |
| // If the new picture doesn't have a pass, that means it was already moved |
| // into the inspector. Simply re-emit the last received valid picture. |
| if (!new_picture.has_value() || new_picture->pass) { |
| last_picture_ = std::move(new_picture); |
| } |
| } |
| |
| return last_picture_; |
| } |
| |
| void AiksInspector::HackResetDueToTextureLeaks() { |
| last_picture_.reset(); |
| } |
| |
| static const auto kPropertiesProcTable = CaptureProcTable{ |
| .boolean = |
| [](CaptureBooleanProperty& p) { |
| ImGui::Checkbox(p.label.c_str(), &p.value); |
| }, |
| .integer = |
| [](CaptureIntegerProperty& p) { |
| if (p.options.range.has_value()) { |
| ImGui::SliderInt(p.label.c_str(), &p.value, |
| static_cast<int>(p.options.range->min), |
| static_cast<int>(p.options.range->max)); |
| return; |
| } |
| ImGui::InputInt(p.label.c_str(), &p.value); |
| }, |
| .scalar = |
| [](CaptureScalarProperty& p) { |
| if (p.options.range.has_value()) { |
| ImGui::SliderFloat(p.label.c_str(), &p.value, p.options.range->min, |
| p.options.range->max); |
| return; |
| } |
| ImGui::DragFloat(p.label.c_str(), &p.value, 0.01); |
| }, |
| .point = |
| [](CapturePointProperty& p) { |
| if (p.options.range.has_value()) { |
| ImGui::SliderFloat2(p.label.c_str(), |
| reinterpret_cast<float*>(&p.value), |
| p.options.range->min, p.options.range->max); |
| return; |
| } |
| ImGui::DragFloat2(p.label.c_str(), reinterpret_cast<float*>(&p.value), |
| 0.01); |
| }, |
| .vector3 = |
| [](CaptureVector3Property& p) { |
| if (p.options.range.has_value()) { |
| ImGui::SliderFloat3(p.label.c_str(), |
| reinterpret_cast<float*>(&p.value), |
| p.options.range->min, p.options.range->max); |
| return; |
| } |
| ImGui::DragFloat3(p.label.c_str(), reinterpret_cast<float*>(&p.value), |
| 0.01); |
| }, |
| .rect = |
| [](CaptureRectProperty& p) { |
| ImGui::DragFloat4(p.label.c_str(), reinterpret_cast<float*>(&p.value), |
| 0.01); |
| }, |
| .color = |
| [](CaptureColorProperty& p) { |
| ImGui::ColorEdit4(p.label.c_str(), |
| reinterpret_cast<float*>(&p.value)); |
| }, |
| .matrix = |
| [](CaptureMatrixProperty& p) { |
| float* pointer = reinterpret_cast<float*>(&p.value); |
| ImGui::DragFloat4((p.label + " X basis").c_str(), pointer, 0.001); |
| ImGui::DragFloat4((p.label + " Y basis").c_str(), pointer + 4, 0.001); |
| ImGui::DragFloat4((p.label + " Z basis").c_str(), pointer + 8, 0.001); |
| ImGui::DragFloat4((p.label + " Translation").c_str(), pointer + 12, |
| 0.001); |
| }, |
| .string = |
| [](CaptureStringProperty& p) { |
| ImGui::InputTextEx(p.label.c_str(), "", |
| // Fine as long as it's read-only. |
| const_cast<char*>(p.value.c_str()), p.value.size(), |
| ImVec2(0, 0), ImGuiInputTextFlags_ReadOnly); |
| }, |
| }; |
| |
| void AiksInspector::RenderCapture(CaptureContext& capture_context) { |
| if (!capturing_) { |
| return; |
| } |
| |
| auto document = capture_context.GetDocument(EntityPass::kCaptureDocumentName); |
| |
| //---------------------------------------------------------------------------- |
| /// Setup a shared dockspace to collect the capture windows. |
| /// |
| |
| ImGui::SetNextWindowBgAlpha(0.5); |
| ImGui::Begin("Capture"); |
| auto dockspace_id = ImGui::GetID("CaptureDockspace"); |
| if (!ImGui::DockBuilderGetNode(dockspace_id)) { |
| ImGui::SetWindowSize(ImVec2(370, 680)); |
| ImGui::SetWindowPos(ImVec2(640, 55)); |
| |
| ImGui::DockBuilderRemoveNode(dockspace_id); |
| ImGui::DockBuilderAddNode(dockspace_id); |
| |
| ImGuiID opposite_id; |
| ImGuiID up_id = ImGui::DockBuilderSplitNode(dockspace_id, ImGuiDir_Up, 0.6, |
| nullptr, &opposite_id); |
| ImGuiID down_id = ImGui::DockBuilderSplitNode(opposite_id, ImGuiDir_Down, |
| 0.0, nullptr, nullptr); |
| ImGui::DockBuilderDockWindow(kElementsWindowName, up_id); |
| ImGui::DockBuilderDockWindow(kPropertiesWindowName, down_id); |
| |
| ImGui::DockBuilderFinish(dockspace_id); |
| } |
| ImGui::DockSpace(dockspace_id); |
| ImGui::End(); // Capture window. |
| |
| //---------------------------------------------------------------------------- |
| /// Element hierarchy window. |
| /// |
| |
| ImGui::Begin(kElementsWindowName); |
| auto root_element = document.GetElement(); |
| hovered_element_ = nullptr; |
| if (root_element) { |
| RenderCaptureElement(*root_element); |
| } |
| ImGui::End(); // Hierarchy window. |
| |
| if (selected_element_) { |
| //---------------------------------------------------------------------------- |
| /// Properties window. |
| /// |
| |
| ImGui::Begin(kPropertiesWindowName); |
| { |
| selected_element_->properties.Iterate([&](CaptureProperty& property) { |
| property.Invoke(kPropertiesProcTable); |
| }); |
| } |
| ImGui::End(); // Inspector window. |
| |
| //---------------------------------------------------------------------------- |
| /// Selected coverage highlighting. |
| /// |
| |
| auto coverage_property = |
| selected_element_->properties.FindFirstByLabel("Coverage"); |
| if (coverage_property) { |
| auto coverage = coverage_property->AsRect(); |
| if (coverage.has_value()) { |
| Scalar scale = ImGui::GetWindowDpiScale(); |
| ImGui::GetBackgroundDrawList()->AddRect( |
| ImVec2(coverage->GetLeft() / scale, |
| coverage->GetTop() / scale), // p_min |
| ImVec2(coverage->GetRight() / scale, |
| coverage->GetBottom() / scale), // p_max |
| 0x992222FF, // col |
| 0.0, // rounding |
| ImDrawFlags_None, // flags |
| 8.0); // thickness |
| } |
| } |
| } |
| |
| //---------------------------------------------------------------------------- |
| /// Hover coverage highlight. |
| /// |
| |
| if (hovered_element_) { |
| auto coverage_property = |
| hovered_element_->properties.FindFirstByLabel("Coverage"); |
| if (coverage_property) { |
| auto coverage = coverage_property->AsRect(); |
| if (coverage.has_value()) { |
| Scalar scale = ImGui::GetWindowDpiScale(); |
| ImGui::GetBackgroundDrawList()->AddRect( |
| ImVec2(coverage->GetLeft() / scale, |
| coverage->GetTop() / scale), // p_min |
| ImVec2(coverage->GetRight() / scale, |
| coverage->GetBottom() / scale), // p_max |
| 0x66FF2222, // col |
| 0.0, // rounding |
| ImDrawFlags_None, // flags |
| 8.0); // thickness |
| } |
| } |
| } |
| } |
| |
| void AiksInspector::RenderCaptureElement(CaptureElement& element) { |
| ImGui::PushID(&element); |
| |
| bool is_selected = selected_element_ == &element; |
| bool has_children = element.children.Count() > 0; |
| |
| bool opened = ImGui::TreeNodeEx( |
| element.label.c_str(), (is_selected ? ImGuiTreeNodeFlags_Selected : 0) | |
| (has_children ? 0 : ImGuiTreeNodeFlags_Leaf) | |
| ImGuiTreeNodeFlags_SpanFullWidth | |
| ImGuiTreeNodeFlags_OpenOnArrow | |
| ImGuiTreeNodeFlags_DefaultOpen); |
| if (ImGui::IsItemClicked()) { |
| selected_element_ = &element; |
| } |
| if (ImGui::IsItemHovered()) { |
| hovered_element_ = &element; |
| } |
| if (opened) { |
| element.children.Iterate( |
| [&](CaptureElement& child) { RenderCaptureElement(child); }); |
| ImGui::TreePop(); |
| } |
| ImGui::PopID(); |
| } |
| |
| } // namespace impeller |
