file_path
stringlengths 20
202
| content
stringlengths 9
3.85M
| size
int64 9
3.85M
| lang
stringclasses 9
values | avg_line_length
float64 3.33
100
| max_line_length
int64 8
993
| alphanum_fraction
float64 0.26
0.93
|
|---|---|---|---|---|---|---|
omniverse-code/kit/exts/omni.kit.welcome.window/omni/kit/welcome/window/welcome_model.py
|
from typing import Callable, List, Optional
import carb
import carb.settings
import omni.ui as ui
from .welcome_page_item import WelcomePageItem
SETTING_WELCOME_PAGES = "/app/welcome/page"
class WelcomeModel(ui.AbstractItemModel):
def __init__(self):
super().__init__()
self.__settings = carb.settings.get_settings()
self._items = [WelcomePageItem(page) for page in self.__settings.get(SETTING_WELCOME_PAGES)]
self._items.sort(key=lambda item: item.order)
def get_item_children(self, item: Optional[WelcomePageItem]) -> List[WelcomePageItem]:
return self._items
def register_page(self, ext_id: str, build_fn: Callable[[None], None]) -> bool:
for item in self._items:
if item.extension_id == ext_id:
item.build_fn = build_fn
return True
carb.log_warn(f"Extension {ext_id} not defined in welcome window.")
return False
| 945 |
Python
| 30.533332 | 100 | 0.65291 |
omniverse-code/kit/exts/omni.kit.welcome.window/omni/kit/welcome/window/actions.py
|
def register_actions(extension_id, extension_inst):
try:
import omni.kit.actions.core
action_registry = omni.kit.actions.core.get_action_registry()
actions_tag = "Welcome"
action_registry.register_action(
extension_id,
"toggle_window",
extension_inst.toggle_window,
display_name="File->Welcome",
description="Show/Hide welcome window",
tag=actions_tag,
)
except ImportError:
pass
def deregister_actions(extension_id):
try:
import omni.kit.actions.core
action_registry = omni.kit.actions.core.get_action_registry()
action_registry.deregister_all_actions_for_extension(extension_id)
except ImportError:
pass
| 777 |
Python
| 28.923076 | 74 | 0.622909 |
omniverse-code/kit/exts/omni.kit.welcome.window/omni/kit/welcome/window/tests/__init__.py
|
from .test_window import *
| 26 |
Python
| 25.999974 | 26 | 0.769231 |
omniverse-code/kit/exts/omni.kit.welcome.window/omni/kit/welcome/window/tests/test_window.py
|
from omni.ui.tests.test_base import OmniUiTest
from pathlib import Path
import omni.ui as ui
from ..extension import register_page, _extension_instance as welcome_instance
CURRENT_PATH = Path(__file__).parent
TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests")
class TestWelcomeWindow(OmniUiTest):
# Before running each test
async def setUp(self):
await super().setUp()
self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute()
# Register page build function
register_page("omni.kit.welcome.window", self.__build_ui)
# Show window
self._window = welcome_instance._window
self._window.visible = True
# After running each test
async def tearDown(self):
await super().tearDown()
async def test_window(self):
await self.docked_test_window(window=self._window, width=1280, height=720, block_devices=False)
await self.finalize_test(golden_img_dir=self._golden_img_dir, golden_img_name="window.png")
def __build_ui(self):
with ui.VStack():
ui.Label("PLACE PAGE WIDGETS HERE!", height=0)
| 1,186 |
Python
| 32.914285 | 103 | 0.680438 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/config/extension.toml
|
[package]
version = "1.1.3"
title = "Live Session Management Widgets"
category = "Internal"
description = "This extension includes shared live session widgets used by other extentions to re-use widgets for session management."
keywords = ["Live Session", "Layers", "Widget"]
changelog = "docs/CHANGELOG.md"
authors = ["NVIDIA"]
repository = ""
[dependencies]
"omni.ui" = {}
"omni.client" = {}
"omni.kit.usd.layers" = {}
"omni.kit.widget.prompt" = {}
"omni.kit.window.filepicker" = {}
"omni.kit.notification_manager" = {}
"omni.kit.collaboration.channel_manager" = {}
"omni.kit.window.file" = {}
[[python.module]]
name = "omni.kit.widget.live_session_management"
[[test]]
waiver = "Tests covered in omni.kit.widget.layers"
| 725 |
TOML
| 26.923076 | 134 | 0.704828 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/share_session_link_window.py
|
import carb
import omni.kit.usd.layers as layers
import omni.ui as ui
import omni.kit.clipboard
from .live_session_model import LiveSessionModel
from .layer_icons import LayerIcons
class ShareSessionLinkWindow:
def __init__(self, layers_interface: layers.Layers, layer_identifier):
self._window = None
self._layers_interface = layers_interface
self._base_layer_identifier = layer_identifier
self._buttons = []
self._existing_sessions_combo = None
self._existing_sessions_model = LiveSessionModel(self._layers_interface, layer_identifier, False)
self._key_functions = {
int(carb.input.KeyboardInput.ENTER): self._on_ok_button_fn,
int(carb.input.KeyboardInput.ESCAPE): self._on_cancel_button_fn
}
self._build_ui()
def _on_layer_event(event: carb.events.IEvent):
payload = layers.get_layer_event_payload(event)
if payload.event_type == layers.LayerEventType.LIVE_SESSION_LIST_CHANGED:
if self._base_layer_identifier not in payload.identifiers_or_spec_paths:
return
self._existing_sessions_model.refresh_sessions(force=True)
self._update_dialog_states()
self._layers_event_subscription = layers_interface.get_event_stream().create_subscription_to_pop(
_on_layer_event, name="Session Start Window Events"
)
def destroy(self):
self._layers_interface = None
for button in self._buttons:
button.set_clicked_fn(None)
self._buttons.clear()
if self._window:
self._window.visible = False
self._window = None
if self._existing_sessions_model:
self._existing_sessions_model.destroy()
self._existing_sessions_model = None
self._layers_event_subscription = None
self._existing_sessions_combo = None
self._existing_sessions_empty_hint = None
self._error_label = None
@property
def visible(self):
return self._window and self._window.visible
@visible.setter
def visible(self, value):
if self._window:
self._window.visible = value
if not self._window.visible:
self._existing_sessions_model.stop_channel()
def _on_ok_button_fn(self):
current_session = self._existing_sessions_model.current_session
if not current_session or self._existing_sessions_model.empty():
self._error_label.text = "No Valid Session Selected."
return
omni.kit.clipboard.copy(current_session.shared_link)
self._error_label.text = ""
self.visible = False
def _on_cancel_button_fn(self):
self.visible = False
def _on_key_pressed_fn(self, key, mod, pressed):
if not pressed:
return
func = self._key_functions.get(key)
if func:
func()
def _update_dialog_states(self):
if self._existing_sessions_model.empty():
self._existing_sessions_empty_hint.visible = True
else:
self._existing_sessions_empty_hint.visible = False
self._error_label.text = ""
def _build_ui(self):
"""Construct the window based on the current parameters"""
self._window = ui.Window(
"SHARE LIVE SESSION LINK", visible=False, height=0,
auto_resize=True, dockPreference=ui.DockPreference.DISABLED
)
self._window.flags = (
ui.WINDOW_FLAGS_NO_COLLAPSE | ui.WINDOW_FLAGS_NO_SCROLLBAR |
ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_MOVE
)
self._window.set_key_pressed_fn(self._on_key_pressed_fn)
self._window.flags = self._window.flags | ui.WINDOW_FLAGS_MODAL
self._existing_sessions_model.refresh_sessions(True)
STYLES = {
"Button.Image::confirm_button": {
"image_url": LayerIcons.get("link"), "alignment" : ui.Alignment.RIGHT_CENTER
},
"Label::copy_link": {"font_size": 14},
"Rectangle::hovering": {"border_radius": 2, "margin": 0, "padding": 0},
"Rectangle::hovering:hovered": {"background_color": 0xCC9E9E9E},
}
with self._window.frame:
with ui.VStack(height=0, style=STYLES):
ui.Spacer(width=0, height=10)
with ui.HStack(height=0):
ui.Spacer(width=20)
self._error_label = ui.Label(
"", name="error_label", style={"color": 0xFF0000CC},
alignment=ui.Alignment.LEFT, word_wrap=True
)
ui.Spacer(width=20)
ui.Spacer(width=0, height=5)
with ui.HStack(height=0):
ui.Spacer(width=20)
with ui.ZStack(height=0):
self._existing_sessions_combo = ui.ComboBox(
self._existing_sessions_model, width=self._window.width - 40, height=0
)
self._existing_sessions_empty_hint = ui.Label(
" No Existing Sessions", alignment=ui.Alignment.LEFT_CENTER, style={"color": 0xFF3F3F3F}
)
ui.Spacer(width=20)
ui.Spacer(width=0, height=30)
with ui.HStack(height=0):
ui.Spacer()
with ui.ZStack(width=120, height=30):
ui.Rectangle(name="hovering")
with ui.HStack():
ui.Spacer()
ui.Label("Copy Link", width=0, name="copy_link")
ui.Spacer(width=8)
ui.Image(LayerIcons.get("link"), width=20)
ui.Spacer()
ok_button = ui.InvisibleButton(name="confirm_button")
ok_button.set_clicked_fn(self._on_ok_button_fn)
self._buttons.append(ok_button)
ui.Spacer()
ui.Spacer(width=0, height=20)
self._update_dialog_states()
| 6,306 |
Python
| 38.41875 | 116 | 0.550428 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/layer_icons.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from pathlib import Path
class LayerIcons:
"""A singleton that scans the icon folder and returns the icon depending on the type"""
_icons = {}
@staticmethod
def on_startup(extension_path):
current_path = Path(extension_path)
icon_path = current_path.joinpath("icons")
# Read all the svg files in the directory
LayerIcons._icons = {icon.stem: icon for icon in icon_path.glob("*.svg")}
@staticmethod
def get(name, default=None):
"""Checks the icon cache and returns the icon if exists"""
found = LayerIcons._icons.get(name)
if not found and default:
found = LayerIcons._icons.get(default)
if found:
return str(found)
return None
| 1,194 |
Python
| 34.147058 | 91 | 0.688442 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/live_session_user_list.py
|
__all__ = ["LiveSessionUserList"]
import carb
import omni.usd
import omni.client.utils as clientutils
import omni.ui as ui
import omni.kit.usd.layers as layers
import omni.kit.collaboration.presence_layer as pl
from .utils import build_live_session_user_layout, is_extension_loaded
from omni.ui import color as cl
TOOLTIP_STYLE = {
"color": cl("#979797"),
"Tooltip": {"background_color": 0xEE222222}
}
PRESENTER_STYLE = {"background_color": 0xff2032dc} # blue alternative: 0xffff851a
class LiveSessionUserList:
"""Widget to build an user list to show all live session users of interested layer."""
def __init__(self, usd_context: omni.usd.UsdContext, base_layer_identifier: str, **kwargs):
"""
Constructor.
Args:
usd_context (omni.usd.UsdContext): USD Context instance.
base_layer_identifier (str): Interested layer to listen to.
follow_user_with_double_click (bool): Whether to enable follow user function of double click.
Kwargs:
icon_size (int): The width and height of the user icon. 16 pixel by default.
spacing (int): The horizonal spacing between two icons. 2 pixel by default.
show_myself (int): Whether to show local user or not. True by default
show_myself_to_leftmost (bool): Whether to show local user to the left most, or right most otherwise.
True by default.
maximum_users (int): The maximum users to show, and show others with overflow. Unlimited by default.
prim_path (Sdf.Path): Track Live Session for this prim only.
"""
self.__icon_size = kwargs.get("icon_size", 16)
self.__spacing = kwargs.get("spacing", 2)
self.__show_myself = kwargs.get("show_myself", True)
self.__show_myself_to_leftmost = kwargs.get("show_myself_to_leftmost", True)
self.__maximum_count = kwargs.get("maximum_users", None)
self.__follow_user_with_double_click = kwargs.get("follow_user_with_double_click", False)
timeline_ext_loaded = is_extension_loaded("omni.timeline.live_session")
self.__allow_timeline_settings = kwargs.get("allow_timeline_settings", False) and timeline_ext_loaded
self.__prim_path = kwargs.get("prim_path", None)
self.__base_layer_identifier = base_layer_identifier
self.__usd_context = usd_context
self.__layers = layers.get_layers(usd_context)
self.__live_syncing = layers.get_live_syncing()
self.__layers_event_subscriptions = []
self.__main_layout: ui.HStack = ui.HStack(width=0, height=0)
self.__all_user_layouts = {}
self.__overflow = None
self.__overflow_button = None
self.__initialize()
@property
def layout(self) -> ui.HStack:
return self.__main_layout
def track_layer(self, layer_identifier):
"""Switches the base layer to listen to."""
if self.__base_layer_identifier != layer_identifier:
self.__base_layer_identifier = layer_identifier
self.__initialize()
def empty(self):
return len(self.__all_user_layouts) == 0
def __initialize(self):
if not clientutils.is_local_url(self.__base_layer_identifier):
for event in [
layers.LayerEventType.LIVE_SESSION_STATE_CHANGED,
layers.LayerEventType.LIVE_SESSION_USER_JOINED,
layers.LayerEventType.LIVE_SESSION_USER_LEFT,
]:
layers_event_subscription = self.__layers.get_event_stream().create_subscription_to_pop_by_type(
event, self.__on_layers_event,
name=f"omni.kit.widget.live_session_management.LiveSessionUserList {str(event)}"
)
self.__layers_event_subscriptions.append(layers_event_subscription)
else:
self.__layers_event_subscriptions = []
self.__build_ui()
def __is_in_session(self):
if self.__prim_path:
return self.__live_syncing.is_prim_in_live_session(self.__prim_path, self.__base_layer_identifier)
else:
return self.__live_syncing.is_layer_in_live_session(self.__base_layer_identifier)
def __build_myself(self):
current_live_session = self.__live_syncing.get_current_live_session(self.__base_layer_identifier)
if not current_live_session:
return
logged_user = current_live_session.logged_user
with ui.ZStack(width=0, height=0):
with ui.HStack():
ui.Spacer()
self.__build_user_layout_or_overflow(current_live_session, logged_user, True, spacing=0)
ui.Spacer()
if self.__is_presenting(logged_user):
with ui.VStack():
ui.Spacer()
with ui.HStack(height=2, width=24):
ui.Rectangle(
height=2, width=12, alignment=ui.Alignment.BOTTOM, style={"background_color": 0xff00b86b}
)
ui.Rectangle(
height=2, width=12, alignment=ui.Alignment.BOTTOM, style=PRESENTER_STYLE
)
else:
with ui.VStack():
ui.Spacer()
ui.Rectangle(
height=2, width=24, alignment=ui.Alignment.BOTTOM, style={"background_color": 0xff00b86b}
)
def __build_ui(self):
# Destroyed
if not self.__main_layout:
return
self.__overflow = False
self.__main_layout.clear()
self.__all_user_layouts.clear()
self.__overflow_button = None
if not self.__is_in_session():
return
current_live_session = self.__live_syncing.get_current_live_session(self.__base_layer_identifier)
with self.__main_layout:
if self.__show_myself and self.__show_myself_to_leftmost:
self.__build_myself()
for peer_user in current_live_session.peer_users:
self.__build_user_layout_or_overflow(current_live_session, peer_user, False, self.__spacing)
if self.__overflow:
break
if self.__show_myself and not self.__show_myself_to_leftmost:
ui.Spacer(self.__spacing)
self.__build_myself()
if self.empty():
self.__main_layout.visible = False
else:
self.__main_layout.visible = True
@carb.profiler.profile
def __on_layers_event(self, event):
payload = layers.get_layer_event_payload(event)
if payload.event_type == layers.LayerEventType.LIVE_SESSION_STATE_CHANGED:
if not payload.is_layer_influenced(self.__base_layer_identifier):
return
if self.__allow_timeline_settings:
import omni.timeline.live_session
timeline_session = omni.timeline.live_session.get_timeline_session()
if timeline_session is not None:
timeline_session.add_presenter_changed_fn(self.__on_presenter_changed)
self.__build_ui()
elif (
payload.event_type == layers.LayerEventType.LIVE_SESSION_USER_JOINED or
payload.event_type == layers.LayerEventType.LIVE_SESSION_USER_LEFT
):
if not payload.is_layer_influenced(self.__base_layer_identifier):
return
if not self.__is_in_session():
return
current_live_session = self.__live_syncing.get_current_live_session(self.__base_layer_identifier)
user_id = payload.user_id
if payload.event_type == layers.LayerEventType.LIVE_SESSION_USER_LEFT:
self.__all_user_layouts.pop(user_id, None)
# FIXME: omni.ui does not support to remove single child.
self.__build_ui()
else:
if user_id in self.__all_user_layouts or self.__overflow:
# OMFP-2909: Refresh overflow button to rebuild tooltip.
if self.__overflow and self.__overflow_button:
self.__overflow_button.set_tooltip_fn(self.__build_tooltip)
return
user_info = current_live_session.get_peer_user_info(user_id)
if not user_info:
return
self.__main_layout.add_child(
self.__build_user_layout_or_overflow(current_live_session, user_info, False, self.__spacing)
)
def destroy(self): # pragma: no cover
self.__overflow_button = None
self.__main_layout = None
self.__layers_event_subscriptions = []
self.__layers = None
self.__live_syncing = None
self.__user_menu = None
self.__all_user_layouts.clear()
def __on_follow_user(
self, x : float, y : float, button : int, modifier, user_info: layers.LiveSessionUser
):
if button != int(carb.input.MouseInput.LEFT_BUTTON): # only left MB click
return
current_live_session = self.__live_syncing.get_current_live_session(self.__base_layer_identifier)
if not current_live_session or current_live_session.logged_user_id == user_info.user_id:
return
presence_layer = pl.get_presence_layer_interface(self.__usd_context)
if presence_layer:
presence_layer.enter_follow_mode(user_info.user_id)
def __on_mouse_clicked(
self, x : float, y : float, button : int, modifier, user_info: layers.LiveSessionUser
):
if button == int(carb.input.MouseInput.RIGHT_BUTTON): # right click to open menu
import omni.timeline.live_session
timeline_session = omni.timeline.live_session.get_timeline_session()
if timeline_session is not None and timeline_session.am_i_owner():
self.__user_menu = ui.Menu("global_live_timeline_user")
show = False
with self.__user_menu:
if timeline_session.is_presenter(user_info) and not timeline_session.is_owner(user_info):
ui.MenuItem(
"Withdraw Timeline Presenter",
triggered_fn=lambda *args: self.__set_presenter(timeline_session, timeline_session.owner)
)
show = True
elif not timeline_session.is_presenter(user_info):
ui.MenuItem(
"Set as Timeline Presenter",
triggered_fn=lambda *args: self.__set_presenter(timeline_session, user_info)
)
show = True
if show:
self.__user_menu.show()
def __set_presenter(self, timeline_session, user_info: layers.LiveSessionUser):
timeline_session.presenter = user_info
def __is_presenting(self, user_info: layers.LiveSessionUser) -> bool:
if not self.__allow_timeline_settings:
return False
timeline_session = omni.timeline.live_session.get_timeline_session()
return timeline_session.is_presenter(user_info) if timeline_session is not None else False
def __on_presenter_changed(self, _):
self.__build_ui()
def __build_user_layout(
self, live_session: layers.LiveSession, user_info: layers.LiveSessionUser, me: bool, spacing=2
):
if me:
tooltip = f"{user_info.user_name} - Me"
if live_session.merge_permission:
tooltip += " (owner)"
else:
tooltip = f"{user_info.user_name} ({user_info.from_app})"
if not live_session.merge_permission and live_session.owner == user_info.user_name:
tooltip += " - owner"
layout = ui.ZStack(width=0, height=0)
with layout:
with ui.HStack():
ui.Spacer(width=spacing)
user_layout = build_live_session_user_layout(
user_info, self.__icon_size, tooltip, self.__on_follow_user if self.__follow_user_with_double_click else None,
self.__on_mouse_clicked if self.__allow_timeline_settings else None
)
user_layout.set_style(TOOLTIP_STYLE)
current_live_session = self.__live_syncing.get_current_live_session(self.__base_layer_identifier)
logged_user = current_live_session.logged_user
if logged_user.user_id != user_info.user_id and self.__is_presenting(user_info):
with ui.VStack():
ui.Spacer()
ui.Rectangle(
height=2, width=24, alignment=ui.Alignment.BOTTOM, style=PRESENTER_STYLE
)
return layout
def __build_tooltip(self): # pragma: no cover
live_session = self.__live_syncing.get_current_live_session(self.__base_layer_identifier)
if not live_session:
return
total_users = len(live_session.peer_users)
if self.__show_myself:
total_users += 1
with ui.VStack():
with ui.HStack(style={"color": cl("#757575")}):
ui.Spacer()
ui.Label(f"{total_users} Users Connected", style={"font_size": 12})
ui.Spacer()
ui.Spacer(height=0)
ui.Separator(style={"color": cl("#4f4f4f")})
ui.Spacer(height=4)
all_users = []
if self.__show_myself:
all_users = [live_session.logged_user]
all_users.extend(live_session.peer_users)
for user in all_users:
item_title = f"{user.user_name} ({user.from_app})"
if live_session.owner == user.user_name:
item_title += " - owner"
with ui.HStack():
build_live_session_user_layout(
user, self.__icon_size, "", self.__on_follow_user if self.__follow_user_with_double_click else None,
self.__on_mouse_clicked if self.__allow_timeline_settings else None
)
ui.Spacer(width=4)
ui.Label(item_title, style={"font_size": 14})
ui.Spacer(height=2)
@carb.profiler.profile
def __build_user_layout_or_overflow(
self, live_session: layers.LiveSession, user_info: layers.LiveSessionUser, me: bool, spacing=2
): # pragma: no cover
current_count = len(self.__all_user_layouts)
if self.__overflow:
return None
if self.__maximum_count is not None and current_count >= self.__maximum_count:
layout = ui.HStack(width=0)
with layout:
ui.Spacer(width=4)
with ui.ZStack():
ui.Label("...", style={"font_size": 16}, aligment=ui.Alignment.V_CENTER)
self.__overflow_button = ui.InvisibleButton(style=TOOLTIP_STYLE)
self.__overflow_button.set_tooltip_fn(self.__build_tooltip)
self.__overflow = True
else:
layout = self.__build_user_layout(live_session, user_info, me, spacing)
self.__all_user_layouts[user_info.user_id] = layout
self.__main_layout.visible = True
self.__overflow_button = None
return layout
| 15,529 |
Python
| 42.379888 | 130 | 0.57267 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/live_session_preferences.py
|
from .utils import QUICK_JOIN_ENABLED
from .utils import SESSION_LIST_SELECT, SESSION_LIST_SELECT_DEFAULT_SESSION, SESSION_LIST_SELECT_LAST_SESSION
import carb.settings
import omni.ui as ui
from omni.kit.widget.settings import SettingType
from omni.kit.window.preferences import PreferenceBuilder
class LiveSessionPreferences(PreferenceBuilder):
SETTING_PAGE_NAME = "Live"
def __init__(self):
super().__init__(LiveSessionPreferences.SETTING_PAGE_NAME)
self._settings = carb.settings.get_settings()
self._checkbox_quick_join_enabled = None
self._combobox_session_list_select = None
def destroy(self):
self._settings = None
self._checkbox_quick_join_enabled = None
self._combobox_session_list_select = None
def build(self):
self._checkbox_quick_join_enabled = None
self._combobox_session_list_select = None
with ui.VStack(height=0):
with self.add_frame("Join"):
with ui.VStack():
checkbox = self.create_setting_widget(
"Quick Join Enabled",
QUICK_JOIN_ENABLED,
SettingType.BOOL,
tooltip="Quick Join, creates and joins a Default session and bypasses dialogs."
)
self._checkbox_quick_join_enabled = checkbox
ui.Spacer()
combo = self.create_setting_widget_combo(
"Session List Select",
SESSION_LIST_SELECT,
[SESSION_LIST_SELECT_DEFAULT_SESSION, SESSION_LIST_SELECT_LAST_SESSION]
)
self._combobox_session_list_select = combo
ui.Spacer()
ui.Spacer(height=10)
| 1,823 |
Python
| 37.80851 | 109 | 0.582556 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/extension.py
|
__all__ = ["stop_or_show_live_session_widget", "LiveSessionWidgetExtension"]
import asyncio
import os
import carb
import omni.ext
import omni.kit.app
import omni.usd
import omni.client
import omni.ui as ui
import omni.kit.notification_manager as nm
import omni.kit.usd.layers as layers
import omni.kit.clipboard
from typing import Union
from enum import Enum
from omni.kit.widget.prompt import PromptButtonInfo, PromptManager
from .layer_icons import LayerIcons
from .live_session_start_window import LiveSessionStartWindow
from .live_session_end_window import LiveSessionEndWindow
from .utils import is_extension_loaded, join_live_session, is_viewer_only_mode, is_quick_join_enabled
from .join_with_session_link_window import JoinWithSessionLinkWindow
from .share_session_link_window import ShareSessionLinkWindow
from pxr import Sdf
from .live_style import Styles
_extension_instance = None
_debugCollaborationWindow = None
class LiveSessionMenuOptions(Enum):
QUIT_ONLY = 0
MERGE_AND_QUIT = 1
class LiveSessionWidgetExtension(omni.ext.IExt):
def on_startup(self, ext_id):
global _extension_instance
_extension_instance = self
extension_path = omni.kit.app.get_app_interface().get_extension_manager().get_extension_path(ext_id)
self._settings = None
LayerIcons.on_startup(extension_path)
self._live_session_end_window = None
self._live_session_start_window = None
self._join_with_session_link_window = None
self._share_session_link_window = None
self._live_session_menu = None
self._app = omni.kit.app.get_app()
try:
from omni.kit.window.preferences import register_page
from .live_session_preferences import LiveSessionPreferences
self._settings = register_page(LiveSessionPreferences())
except ImportError: # pragma: no cover
pass
Styles.on_startup()
def on_shutdown(self):
global _extension_instance
_extension_instance = None
self._live_session_menu = None
if self._live_session_end_window:
self._live_session_end_window.destroy()
self._live_session_end_window = None
if self._live_session_start_window:
self._live_session_start_window.destroy()
self._live_session_start_window = None
if self._join_with_session_link_window:
self._join_with_session_link_window.destroy()
self._join_with_session_link_window = None
if self._share_session_link_window:
self._share_session_link_window.destroy()
self._share_session_link_window = None
if self._settings:
try:
from omni.kit.window.preferences import unregister_page
unregister_page(self._settings)
except ImportError:
pass
self._settings = None
@staticmethod
def get_instance():
global _extension_instance
return _extension_instance
def _show_live_session_end_window(self, layers_interface: layers.Layers, layer_identifier):
if self._live_session_end_window:
self._live_session_end_window.destroy()
async def show_dialog():
self._live_session_end_window = LiveSessionEndWindow(layers_interface, layer_identifier)
async with self._live_session_end_window:
pass
asyncio.ensure_future(show_dialog())
def _show_join_with_session_link_window(self, layers_interface):
current_session_link = None
# Destroys it to center the window.
if self._join_with_session_link_window:
current_session_link = self._join_with_session_link_window.current_session_link
self._join_with_session_link_window.destroy()
self._join_with_session_link_window = JoinWithSessionLinkWindow(layers_interface)
self._join_with_session_link_window.visible = True
if current_session_link:
self._join_with_session_link_window.current_session_link = current_session_link
def _show_share_session_link_window(self, layers_interface, layer_identifier):
# Destroys it to center the window.
if self._share_session_link_window:
self._share_session_link_window.destroy()
self._share_session_link_window = ShareSessionLinkWindow(layers_interface, layer_identifier)
self._share_session_link_window.visible = True
def _show_live_session_menu_options(self, layers_interface, layer_identifier, is_stage_session, prim_path=None):
live_syncing = layers_interface.get_live_syncing()
current_session = live_syncing.get_current_live_session(layer_identifier)
self._live_session_menu = ui.Menu("global_live_update")
is_omniverse_stage = layer_identifier.startswith("omniverse://")
is_live_prim = prim_path or live_syncing.is_layer_in_live_session(layer_identifier, live_prim_only=True)
with self._live_session_menu:
if is_omniverse_stage:
if current_session:
# If layer is in the live session already, showing `leave` and `end and merge`
ui.MenuItem(
"Leave Session",
triggered_fn=lambda *args: self._on_leave_live_session_menu_options(
layers_interface, LiveSessionMenuOptions.QUIT_ONLY, layer_identifier
),
)
if not is_viewer_only_mode():
ui.MenuItem(
"End and Merge",
triggered_fn=lambda *args: self._on_leave_live_session_menu_options(
layers_interface, LiveSessionMenuOptions.MERGE_AND_QUIT, layer_identifier
),
)
ui.Separator()
else:
# If it's not in the live session, show `join` and `create`.
ui.MenuItem(
"Join Session",
triggered_fn=lambda *args: self._show_live_session_start_window(
layers_interface, layer_identifier, True, prim_path
),
)
ui.MenuItem(
"Create Session",
triggered_fn=lambda *args: self._show_live_session_start_window(
layers_interface, layer_identifier, False, prim_path
),
)
# Don't show those options for live prim
if not is_live_prim:
# If layer_identifier is given, it's to show menu options for sublayer.
# Show `copy` to copy session link. Otherwise, show share session dialog
# to choose session to share.
if is_stage_session:
ui.Separator()
ui.MenuItem(
"Share Session Link",
triggered_fn=lambda *args: self._show_share_session_link_window(
layers_interface, layer_identifier
),
)
elif current_session:
ui.Separator()
ui.MenuItem(
"Copy Session Link",
triggered_fn=lambda *args: self._copy_session_link(layers_interface),
)
# If layer identifier is gven, it will not show `join with session link` menu option.
if is_stage_session and not is_live_prim:
ui.MenuItem(
"Join With Session Link",
triggered_fn=lambda *args: self._show_join_with_session_link_window(layers_interface),
)
if is_extension_loaded("omni.kit.collaboration.debug_options"): # pragma: no cover
ui.Separator()
ui.MenuItem(
"Open Debug Window",
triggered_fn=lambda *args: self._on_open_debug_window(),
)
if is_omniverse_stage and current_session and is_extension_loaded("omni.timeline.live_session"):
ui.Separator()
import omni.timeline.live_session
timeline_session = omni.timeline.live_session.get_timeline_session()
if timeline_session is not None:
session_window = omni.timeline.live_session.get_session_window()
ui.MenuItem(
"Synchronize Timeline",
triggered_fn=lambda *args: self._on_timeline_sync_triggered(
layers_interface, layer_identifier, timeline_session
),
checkable=True,
checked=timeline_session.is_sync_enabled()
)
if timeline_session.am_i_owner():
ui.MenuItem(
"Set Timeline Owner",
triggered_fn=lambda *args: self._on_open_timeline_session_window(
layers_interface, layer_identifier, timeline_session, session_window
),
)
elif not timeline_session.am_i_presenter():
if not self._requested_timeline_control(timeline_session):
ui.MenuItem(
"Request Timeline Ownership",
triggered_fn=lambda *args: self._on_request_timeline_control(timeline_session),
)
else:
ui.MenuItem(
"Withdraw Timeline Ownership Request",
triggered_fn=lambda *args: self._on_withdraw_timeline_control(timeline_session),
)
self._live_session_menu.show()
def _show_live_session_start_window(self, layers_interface, layer_identifier, join_session=None, prim_path=None):
if self._live_session_start_window:
self._live_session_start_window.destroy()
self._live_session_start_window = LiveSessionStartWindow(layers_interface, layer_identifier, prim_path)
self._live_session_start_window.visible = True
if join_session is not None:
self._live_session_start_window.set_focus(join_session)
def _show_session_start_window_or_menu(
self, layers_interface: layers.Layers, show_join_options, layer_identifier, is_stage_session, join_session=None, prim_path=None
):
if show_join_options:
return self._show_live_session_menu_options(
layers_interface, layer_identifier, is_stage_session, prim_path
)
else:
self._show_live_session_start_window(layers_interface, layer_identifier, join_session, prim_path)
return None
def _requested_timeline_control(self, timeline_session) -> bool:
return timeline_session is not None and\
timeline_session.live_session_user in timeline_session.get_request_controls()
def _on_request_timeline_control(self, timeline_session):
if timeline_session is not None:
timeline_session.request_control(True)
def _on_withdraw_timeline_control(self, timeline_session):
if timeline_session is not None:
timeline_session.request_control(False)
def _on_timeline_sync_triggered(
self, layers_interface: layers.Layers,
layer_identifier: str,
timeline_session
):
timeline_session.enable_sync(not timeline_session.is_sync_enabled())
def _on_open_timeline_session_window(
self, layers_interface: layers.Layers,
layer_identifier: str,
timeline_session,
session_window,
):
session_window.show()
def _on_open_debug_window(
self,
): # pragma: no cover
import omni.kit.collaboration.debug_options
from omni.kit.collaboration.debug_options import CollaborationWindow
global _debugCollaborationWindow
if _debugCollaborationWindow is None :
_debugCollaborationWindow = CollaborationWindow(width=480, height=320)
_debugCollaborationWindow.visible = True
def _on_leave_live_session_menu_options(
self, layers_interface: layers.Layers,
options: LiveSessionMenuOptions,
layer_identifier: str,
):
live_syncing = layers_interface.get_live_syncing()
current_session = live_syncing.get_current_live_session(layer_identifier)
if current_session:
if options == LiveSessionMenuOptions.QUIT_ONLY:
if self._can_quit_session_directly(live_syncing, layer_identifier):
live_syncing.stop_live_session(layer_identifier)
else:
PromptManager.post_simple_prompt(
"Leave Session",
f"You are about to leave '{current_session.name}' session.",
PromptButtonInfo("LEAVE", lambda: live_syncing.stop_live_session(layer_identifier)),
PromptButtonInfo("CANCEL")
)
elif options == LiveSessionMenuOptions.MERGE_AND_QUIT:
layers_state = layers_interface.get_layers_state()
is_read_only_on_disk = layers_state.is_layer_readonly_on_disk(layer_identifier)
if current_session.merge_permission and not is_read_only_on_disk:
self._show_live_session_end_window(layers_interface, layer_identifier)
else:
if is_read_only_on_disk:
owner = layers_state.get_layer_owner(layer_identifier)
else:
owner = current_session.owner
logged_user_name = current_session.logged_user_name
if logged_user_name == owner and current_session.merge_permission:
message = f"You currently do not have merge privileges as base layer is read-only on disk."\
" Do you want to quit this live session?"
else:
if is_read_only_on_disk:
message = f"You currently do not have merge privileges as base layer is read-only on disk."\
f" Please contact '{owner}' to grant you write access. Do you want to quit this live session?"
else:
message = f"You currently do not have merge privileges, please contact '{owner}'"\
" to merge any changes from the live session. Do you want to quit this live session?"
PromptManager.post_simple_prompt(
"Permission Denied",
message,
PromptButtonInfo("YES", lambda: live_syncing.stop_live_session(layer_identifier)),
PromptButtonInfo("NO")
)
def _can_quit_session_directly(self, live_syncing: layers.LiveSyncing, layer_identifier):
current_live_session = live_syncing.get_current_live_session(layer_identifier)
if current_live_session:
if current_live_session.peer_users:
return False
layer = Sdf.Find(current_live_session.root)
if layer and len(layer.rootPrims) > 0:
return False
return True
def _copy_session_link(self, layers_interface):
live_syncing = layers_interface.get_live_syncing()
current_session = live_syncing.get_current_live_session()
if not current_session:
return
omni.kit.clipboard.copy(current_session.shared_link)
def _stop_or_show_live_session_widget_internal(
self, layers_interface: layers.Layers,
stop_session_only,
stop_session_forcely,
show_join_options,
layer_identifier,
quick_join="",
prim_path=None
):
usd_context = layers_interface.usd_context
stage = usd_context.get_stage()
# Skips it if stage is not opened.
if not stage:
return None
# By default, it will join live session of tht root layer.
if not layer_identifier:
# If layer identifier is not provided, it's to show global
# menu that includes share sesison link and join session with link.
# Otherwise, it will show menu for the sublayer session only.
is_stage_session = True
root_layer = stage.GetRootLayer()
layer_identifier = root_layer.identifier
else:
is_stage_session = False
layer_handle = Sdf.Find(layer_identifier)
if (
not layer_handle or
(not prim_path and not stage.HasLocalLayer(layer_handle)) or
(prim_path and layer_handle not in stage.GetUsedLayers())
):
nm.post_notification(
"Only a layer opened in the current stage can start a live-sync session.",
status=nm.NotificationStatus.WARNING
)
return None
if not layer_identifier.startswith("omniverse://"):
if is_stage_session and not prim_path:
return self._show_live_session_menu_options(layers_interface, layer_identifier, is_stage_session)
else:
nm.post_notification(
"Only a layer in Nucleus can start a live-sync session.",
status=nm.NotificationStatus.WARNING
)
return None
live_syncing = layers_interface.get_live_syncing()
if not live_syncing.is_layer_in_live_session(layer_identifier):
if not quick_join and not show_join_options:
quick_join = "Default"
elif quick_join and show_join_options:
show_join_options = False
if quick_join:
# This runs when the main live button is pressed.
live_syncing = layers_interface.get_live_syncing()
quick_session = live_syncing.find_live_session_by_name(layer_identifier, quick_join)
if is_quick_join_enabled():
if not quick_session:
quick_session = live_syncing.create_live_session(
layer_identifier=layer_identifier,
name=quick_join
)
if not quick_session:
nm.post_notification(
"Cannot create a Live session on a read only location. Please\n"
"save root file in a writable location.",
status=nm.NotificationStatus.WARNING
)
return None
join_live_session(
layers_interface, layer_identifier, quick_session, prim_path,
is_viewer_only_mode()
)
return None
else:
join_session = True if quick_session is not None else False
return self._show_session_start_window_or_menu(
layers_interface, False, layer_identifier, False, join_session, prim_path
)
else:
return self._show_session_start_window_or_menu(
layers_interface, show_join_options, layer_identifier, is_stage_session, prim_path
)
elif stop_session_forcely:
live_syncing.stop_live_session(layer_identifier)
elif stop_session_only:
self._on_leave_live_session_menu_options(
layers_interface, LiveSessionMenuOptions.QUIT_ONLY, layer_identifier
)
else:
return self._show_live_session_menu_options(layers_interface, layer_identifier, is_stage_session, prim_path)
return None
def stop_or_show_live_session_widget(
usd_context: Union[str, omni.usd.UsdContext] = "",
stop_session_only: bool = False,
stop_session_forcely: bool = False,
show_join_options: bool = True,
layer_identifier: str = None,
quick_join: str = False,
prim_path: Union[str, Sdf.Path] = None,
):
"""Stops current live session or shows widget to join/leave session. If current session is empty, it will show
the session start dialog. If current session is not empty, it will stop session directly or show stop session menu.
Args:
usd_context: The current usd context to operate on.
stop_session_only: If it's true, it will ask user to stop session if session is not empty without showing merge options.
If it's false, it will show both leave and merge session options.
stop_session_forcely: If it's true, it will stop session forcely even if current sesison is not empty.
Otherwise, it will show leave session or both leave and merge options that's dependent on
if stop_session_only is true or false.
show_join_options: If it's true, it will show menu options.
If it's false, it will show session dialog directly.
This option is only used when layer is not in a live session. If both quick_join and
this param have the same value, it will do quick join.
layer_identifier: By default, it will join/stop the live session of the root layer.
If layer_identifier is not None, it will join/stop the live session for the specific sublayer.
quick_join: Quick Join / Leave a session without bringing up a dialog.
This option is only used when layer is not in a live session. If both show_join_options and
this param have the same value, this param will be True.
prim_path: If prim path is specified, it will join live session for the prim instead of sublayers. Only prim with
references or payloads supports to join a live session. Prim path is not needed when it's to
stop a live session.
Returns:
It will return the menu widgets created if it needs to create options menu. Otherwise, it will return None.
"""
instance = LiveSessionWidgetExtension.get_instance()
if not instance: # pragma: no cover
carb.log_error("omni.kit.widget.live_session_management extension must be enabled.")
return
layers_interface = layers.get_layers(usd_context)
return instance._stop_or_show_live_session_widget_internal(
layers_interface,
stop_session_only,
stop_session_forcely,
show_join_options,
layer_identifier,
quick_join=quick_join,
prim_path=prim_path
)
| 23,531 |
Python
| 44.34104 | 135 | 0.576984 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/__init__.py
|
from .extension import *
from .utils import *
from .live_session_user_list import *
from .live_session_model import *
from .live_session_camera_follower_list import *
| 166 |
Python
| 32.399994 | 48 | 0.771084 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/file_picker.py
|
import omni
import carb
import os
import omni.client
import omni.kit.notification_manager as nm
from omni.kit.widget.prompt import PromptButtonInfo, PromptManager
from .filebrowser import FileBrowserMode, FileBrowserSelectionType, FileBrowserUI
class FilePicker:
def __init__(self, title, mode, file_type, filter_options, save_extensions=None):
self._mode = mode
self._ui_handler = None
self._app = omni.kit.app.get_app()
self._open_handler = None
self._cancel_handler = None
self._save_extensions = save_extensions
self._ui_handler = FileBrowserUI(
title, mode, file_type, filter_options, enable_versioning_pane=(mode == FileBrowserMode.OPEN)
)
def _show_prompt(self, file_path, file_save_handler):
def _on_file_save():
if file_save_handler:
file_save_handler(file_path, True)
PromptManager.post_simple_prompt(
f'{omni.kit.ui.get_custom_glyph_code("${glyphs}/exclamation.svg")} Overwrite',
f"File {os.path.basename(file_path)} already exists, do you want to overwrite it?",
ok_button_info=PromptButtonInfo("YES", _on_file_save),
cancel_button_info=PromptButtonInfo("NO")
)
def _save_and_prompt_if_exists(self, file_path, file_save_handler=None):
result, _ = omni.client.stat(file_path)
if result == omni.client.Result.OK:
self._show_prompt(file_path, file_save_handler)
elif file_save_handler:
file_save_handler(file_path, False)
def _on_file_open(self, path, filter_index=-1):
if self._mode == FileBrowserMode.SAVE:
_, ext = os.path.splitext(path)
if (
filter_index >= 0
and self._save_extensions
and filter_index < len(self._save_extensions)
and ext not in self._save_extensions
):
path += self._save_extensions[filter_index]
self._save_and_prompt_if_exists(path, self._open_handler)
elif self._open_handler:
self._open_handler(path, False)
def _on_cancel_open(self):
if self._cancel_handler:
self._cancel_handler()
def set_file_selected_fn(self, file_open_handler):
self._open_handler = file_open_handler
def set_cancel_fn(self, cancel_handler):
self._cancel_handler = cancel_handler
def show(self, dir=None, filename=None):
if self._ui_handler:
if dir:
self._ui_handler.set_current_directory(dir)
if filename:
self._ui_handler.set_current_filename(filename)
self._ui_handler.open(self._on_file_open, self._on_cancel_open)
def hide(self):
if self._ui_handler:
self._ui_handler.hide()
def set_current_directory(self, dir):
if self._ui_handler:
self._ui_handler.set_current_directory(dir)
def set_current_filename(self, filename):
if self._ui_handler:
self._ui_handler.set_current_filename(filename)
def get_current_filename(self):
if self._ui_handler:
return self._ui_handler.get_current_filename()
return None
def destroy(self):
if self._ui_handler:
self._ui_handler.destroy()
self._ui_handler = None
| 3,413 |
Python
| 33.836734 | 105 | 0.600938 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/utils.py
|
__all__ = ["build_live_session_user_layout", "is_viewer_only_mode", "VIEWER_ONLY_MODE_SETTING"]
import asyncio
import carb
import os
import omni.usd
import omni.kit.app
import omni.ui as ui
import omni.kit.usd.layers as layers
from omni.kit.async_engine import run_coroutine
from omni.kit.widget.prompt import PromptManager, PromptButtonInfo
from pxr import Sdf
from typing import Union, List
# When this setting is True, it will following the rules:
# * When joining a live session, if the user has unsaved changes,
# skip the dialog and automatically reload the stage, then join the session.
# * When creating a live session, if the user has unsaved changes,
# skip the dialog and automatically reload the stage, then create the session.
# * When leaving a live session, do not offer to merge changes,
# instead reload the stage to its original state
VIEWER_ONLY_MODE_SETTING = "/exts/omni.kit.widget.live_session_management/viewer_only_mode"
# When this setting is True, it will show the Join/Create Session dialog wqhen the quick live button is pressed.
# When this setting if False, it will auto Create Session or Join with no dialog shown.
QUICK_JOIN_ENABLED = "/exts/omni.kit.widget.live_session_management/quick_join_enabled"
SESSION_LIST_SELECT = "/exts/omni.kit.widget.live_session_management/session_list_select"
SESSION_LIST_SELECT_DEFAULT_SESSION = "DefaultSession"
SESSION_LIST_SELECT_LAST_SESSION = "LastSession"
def is_viewer_only_mode():
return carb.settings.get_settings().get(VIEWER_ONLY_MODE_SETTING) or False
def is_quick_join_enabled():
return carb.settings.get_settings().get(QUICK_JOIN_ENABLED) or False
def get_session_list_select():
return carb.settings.get_settings().get(SESSION_LIST_SELECT)
def join_live_session(layers_interface, layer_identifier, current_session, prim_path=None, force_reload=False):
layers_state = layers_interface.get_layers_state()
live_syncing = layers_interface.get_live_syncing()
layer_handle = Sdf.Find(layer_identifier)
def fetch_and_join(layer_identifier):
with Sdf.ChangeBlock():
layer = Sdf.Find(layer_identifier)
if layer:
layer.Reload(True)
if layers_state.is_auto_reload_layer(layer_identifier):
layers_state.remove_auto_reload_layer(layer_identifier)
return live_syncing.join_live_session(current_session, prim_path)
async def post_simple_prompt(title, text, ok_button_info, cancel_button_info):
await omni.kit.app.get_app().next_update_async()
PromptManager.post_simple_prompt(
title, text,
ok_button_info=ok_button_info,
cancel_button_info=cancel_button_info
)
is_outdated = layers_state.is_layer_outdated(layer_identifier)
if force_reload and (is_outdated or layer_handle.dirty):
fetch_and_join(layer_identifier)
elif is_outdated:
asyncio.ensure_future(
post_simple_prompt(
"Join Session",
"The file you would like to go live on is not up to date, "
"a newer version must be fetched for joining a live session. "
"Press Fetch to get the most recent version or use Cancel "
"if you would like to save a copy first.",
ok_button_info=PromptButtonInfo(
"Fetch",
lambda: fetch_and_join(layer_identifier)
),
cancel_button_info=PromptButtonInfo("Cancel")
)
)
elif layer_handle.dirty:
asyncio.ensure_future(
post_simple_prompt(
"Join Session",
"There are unsaved changes to your file. Joining this live session will discard any unsaved changes.",
ok_button_info=PromptButtonInfo(
"Join",
lambda: fetch_and_join(layer_identifier)
),
cancel_button_info=PromptButtonInfo("Cancel")
)
)
else:
if layers_state.is_auto_reload_layer(layer_identifier):
layers_state.remove_auto_reload_layer(layer_identifier)
return live_syncing.join_live_session(current_session, prim_path)
return True
def is_extension_loaded(extansion_name: str) -> bool:
"""
Returns True if the extension with the given name is loaded.
"""
def is_ext(id: str, extension_name: str) -> bool:
id_name = id.split("-")[0]
return id_name == extension_name
app = omni.kit.app.get_app_interface()
ext_manager = app.get_extension_manager()
extensions = ext_manager.get_extensions()
loaded = next((ext for ext in extensions if is_ext(ext["id"], extansion_name) and ext["enabled"]), None)
return not not loaded
def build_live_session_user_layout(user_info: layers.LiveSessionUser, size=16, tooltip = "", on_double_click_fn: callable = None, on_mouse_click_fn: callable = None) -> ui.ZStack:
"""Builds user icon."""
user_layout = ui.ZStack(width=size, height=size)
with user_layout:
circle = ui.Circle(
style={"background_color": ui.color(*user_info.user_color)}
)
if on_double_click_fn:
circle.set_mouse_double_clicked_fn(lambda x, y, b, m, user_info_t=user_info: on_double_click_fn( x, y, b, m, user_info_t))
if on_mouse_click_fn:
circle.set_mouse_pressed_fn(lambda x, y, b, m, user_info_t=user_info: on_mouse_click_fn( x, y, b, m, user_info_t))
ui.Label(
layers.get_short_user_name(user_info.user_name), style={"font_size": size - 5, "color": 0xFFFFFFFF},
alignment=ui.Alignment.CENTER
)
if tooltip:
user_layout.set_tooltip(tooltip)
return user_layout
def reload_outdated_layers(
layer_identifiers: Union[str, List[str]], usd_context_name_or_instance: Union[str, omni.usd.UsdContext] = None
) -> None:
"""Reloads outdated layer. It will show prompt to user if layer is in a Live Session."""
if isinstance(usd_context_name_or_instance, str):
usd_context = omni.usd.get_context(usd_context_name_or_instance)
elif isinstance(usd_context_name_or_instance, omni.usd.UsdContext):
usd_context = usd_context_name_or_instance
elif not usd_context_name_or_instance:
usd_context = omni.usd.get_context()
if not usd_context:
carb.log_error("Failed to reload layer as usd context is not invalid.")
return
if isinstance(layer_identifiers, str):
layer_identifiers = [layer_identifiers]
live_syncing = layers.get_live_syncing(usd_context)
layers_state = layers.get_layers_state(usd_context)
all_layer_ids = layers_state.get_all_outdated_layer_identifiers()
if not all_layer_ids:
return
layer_identifiers = [layer_id for layer_id in layer_identifiers if layer_id in all_layer_ids]
if not layer_identifiers:
return
count = 0
for layer_identifier in layer_identifiers:
if live_syncing.is_layer_in_live_session(layer_identifier):
count += 1
if count == 1:
title = f"{os.path.basename(layer_identifier)} is in a Live Session"
else:
title = "Reload Layers In Live Session"
def reload_layers(layer_identifiers):
async def reload(layer_identifiers):
layers.LayerUtils.reload_all_layers(layer_identifiers)
run_coroutine(reload(layer_identifiers))
if count != 0:
PromptManager.post_simple_prompt(
title,
"Reloading live layers has performance implications and some live edits may be lost - OK to proceed?",
PromptButtonInfo("YES", lambda: reload_layers(layer_identifiers)),
PromptButtonInfo("NO")
)
else:
reload_layers(layer_identifiers)
| 7,853 |
Python
| 36.4 | 179 | 0.657328 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/join_with_session_link_window.py
|
__all__ = ["JoinWithSessionLinkWindow"]
import asyncio
import carb
import omni.kit.usd.layers as layers
import omni.ui as ui
import omni.kit.notification_manager as nm
import omni.kit.app
import omni.kit.clipboard
from pxr import Usd
from .layer_icons import LayerIcons
class JoinWithSessionLinkWindow:
def __init__(self, layers_interface: layers.Layers):
self._window = None
self._layers_interface = layers_interface
self._buttons = []
self._session_link_input_field = None
self._session_link_input_hint = None
self._error_label = None
self._session_link_begin_edit_cb = None
self._session_link_end_edit_cb = None
self._session_link_edit_cb = None
self._key_functions = {
int(carb.input.KeyboardInput.ENTER): self._on_ok_button_fn,
int(carb.input.KeyboardInput.ESCAPE): self._on_cancel_button_fn
}
self._build_ui()
def destroy(self):
self._layers_interface = None
for button in self._buttons:
button.set_clicked_fn(None)
self._buttons.clear()
if self._window:
self._window.visible = False
self._window = None
self._session_link_input_hint = None
self._session_link_input_field = None
self._session_link_begin_edit_cb = None
self._session_link_end_edit_cb = None
self._session_link_edit_cb = None
self._error_label = None
@property
def visible(self):
return self._window and self._window.visible
@visible.setter
def visible(self, value):
if self._window:
self._window.visible = value
if value:
async def focus_field():
await omni.kit.app.get_app().next_update_async()
if self._session_link_input_field:
self._session_link_input_field.focus_keyboard()
asyncio.ensure_future(focus_field())
@property
def current_session_link(self):
if self._session_link_input_field:
return self._session_link_input_field.model.get_value_as_string()
return ""
@current_session_link.setter
def current_session_link(self, value):
if self._session_link_input_field:
self._session_link_input_field.model.set_value(value)
def _validate_session_link(self, str):
return str and Usd.Stage.IsSupportedFile(str)
def _on_ok_button_fn(self):
if not self._update_button_status():
return
self._error_label.text = ""
self.visible = False
session_link = self._session_link_input_field.model.get_value_as_string()
session_link = session_link.strip()
live_syncing = self._layers_interface.get_live_syncing()
async def open_stage_with_live_session(live_syncing, session_link):
(success, error) = await live_syncing.open_stage_with_live_session_async(session_link)
if not success:
nm.post_notification(f"Failed to open stage {session_link} with live session: {error}.")
asyncio.ensure_future(open_stage_with_live_session(live_syncing, session_link))
def _on_cancel_button_fn(self):
self.visible = False
def _on_key_pressed_fn(self, key, mod, pressed):
if not pressed:
return
func = self._key_functions.get(key)
if func:
func()
def _update_button_status(self):
if not self._session_link_input_field:
return False
session_link = self._session_link_input_field.model.get_value_as_string()
session_link = session_link.strip()
join_button = self._buttons[0]
if not self._validate_session_link(session_link):
if session_link:
self._error_label.text = "The link is not supported for USD."
else:
self._error_label.text = ""
join_button.enabled = False
else:
self._error_label.text = ""
join_button.enabled = True
if not session_link:
self._session_link_input_hint.visible = True
else:
self._session_link_input_hint.visible = False
return join_button.enabled
def _on_session_link_begin_edit(self, model):
self._update_button_status()
def _on_session_link_end_edit(self, model):
self._update_button_status()
def _on_session_link_edit(self, model):
self._update_button_status()
def _on_paste_link_fn(self):
link = omni.kit.clipboard.paste()
if link:
self._session_link_input_field.model.set_value(link)
def _build_ui(self):
"""Construct the window based on the current parameters"""
self._window = ui.Window(
"JOIN LIVE SESSION WITH LINK", visible=False, width=500, height=0,
auto_resize=True, dockPreference=ui.DockPreference.DISABLED
)
self._window.flags = (
ui.WINDOW_FLAGS_NO_COLLAPSE | ui.WINDOW_FLAGS_NO_SCROLLBAR |
ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_MOVE
)
self._window.set_key_pressed_fn(self._on_key_pressed_fn)
self._window.flags = self._window.flags | ui.WINDOW_FLAGS_MODAL
STYLES = {
"Rectangle::hovering": {"background_color": 0x0, "border_radius": 2, "margin": 0, "padding": 0},
"Rectangle::hovering:hovered": {"background_color": 0xFF9E9E9E},
"Button.Image::paste_button": {"image_url": LayerIcons().get("paste"), "color": 0xFFD0D0D0},
"Button::paste_button": {"background_color": 0x0, "margin": 0},
"Button::paste_button:checked": {"background_color": 0x0},
"Button::paste_button:hovered": {"background_color": 0x0},
"Button::paste_button:pressed": {"background_color": 0x0},
}
with self._window.frame:
with ui.VStack(height=0, style=STYLES):
ui.Spacer(width=0, height=10)
with ui.HStack(height=0):
ui.Spacer(width=20)
self._error_label = ui.Label("", name="error_label", style={"color": 0xFF0000CC}, alignment=ui.Alignment.LEFT, word_wrap=True)
ui.Spacer(width=20)
ui.Spacer(width=0, height=5)
with ui.ZStack(height=0):
with ui.HStack(height=0):
ui.Spacer(width=20)
with ui.ZStack(width=20, height=20):
ui.Rectangle(name="hovering")
paste_link_button = ui.ToolButton(name="paste_button", image_width=20, image_height=20)
paste_link_button.set_clicked_fn(self._on_paste_link_fn)
ui.Spacer(width=4)
with ui.VStack():
ui.Spacer()
with ui.ZStack(height=0):
self._session_link_input_field = ui.StringField(
name="new_session_link_field", width=self._window.width - 40, height=0
)
self._session_link_input_hint = ui.Label(
" Paste Live Session Link Here", alignment=ui.Alignment.LEFT_CENTER,
style={"color": 0xFF3F3F3F}
)
self._session_link_begin_edit_cb = self._session_link_input_field.model.subscribe_begin_edit_fn(
self._on_session_link_begin_edit
)
self._session_link_end_edit_cb = self._session_link_input_field.model.subscribe_end_edit_fn(
self._on_session_link_end_edit
)
self._session_link_edit_cb = self._session_link_input_field.model.subscribe_value_changed_fn(
self._on_session_link_edit
)
ui.Spacer()
ui.Spacer(width=20)
ui.Spacer(width=0, height=30)
with ui.HStack(height=0):
ui.Spacer(height=0)
ok_button = ui.Button("JOIN", name="confirm_button", width=120, height=0)
ok_button.set_clicked_fn(self._on_ok_button_fn)
cancel_button = ui.Button("CANCEL", name="cancel_button", width=120, height=0)
cancel_button.set_clicked_fn(self._on_cancel_button_fn)
self._buttons.append(ok_button)
self._buttons.append(cancel_button)
ui.Spacer(height=0, width=20)
ui.Spacer(width=0, height=20)
# 0 for ok button, 0 for cancel button and appends paste link button at last
self._buttons.append(paste_link_button)
self._update_button_status()
| 9,226 |
Python
| 40.008889 | 146 | 0.54574 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/reload_widget.py
|
__all__ = ["build_reload_widget"]
import carb
import omni.usd
import omni.kit.app
import omni.ui as ui
import omni.kit.usd.layers as layers
import weakref
from functools import partial
from typing import Union
from .live_style import Styles
from .layer_icons import LayerIcons
from .utils import reload_outdated_layers
from omni.kit.async_engine import run_coroutine
class ReloadWidgetWrapper(ui.ZStack):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.auto_reload_menu = None
def __del__(self):
if self.auto_reload_menu:
self.auto_reload_menu.hide()
self.auto_reload_menu = None
def show_reload_menu(layer_identifier, usd_context, widget, button, global_auto):
"""Creates and shows a reload menu relative to widget position"""
layers_state = layers.get_layers_state(usd_context)
live_syncing = layers.get_live_syncing()
is_outdated = layers_state.is_layer_outdated(layer_identifier)
in_session = live_syncing.is_layer_in_live_session(layer_identifier)
def toggle_auto_reload(layer_identifier, widget):
async def toggle(layer_identifier):
is_auto = layers_state.is_auto_reload_layer(layer_identifier)
if not is_auto:
layers_state.add_auto_reload_layer(layer_identifier)
widget.set_style(Styles.RELOAD_AUTO)
button.tooltip = "Auto Reload Enabled"
else:
layers_state.remove_auto_reload_layer(layer_identifier)
widget.set_style(Styles.RELOAD_BTN)
button.tooltip = "Reload"
run_coroutine(toggle(layer_identifier))
def reload_layer(layer_identifier):
reload_outdated_layers(layer_identifier, layers_state._usd_context)
auto_reload_menu = ui.Menu("auto_reload_menu")
with auto_reload_menu:
ui.MenuItem(
"Reload Layer",
triggered_fn=lambda *args: reload_layer(layer_identifier),
enabled=is_outdated,
visible=not global_auto
)
ui.MenuItem(
"Auto Reload",
triggered_fn=lambda *args: toggle_auto_reload(layer_identifier, widget),
checkable=True,
checked=layers_state.is_auto_reload_layer(layer_identifier),
visible=not global_auto,
enabled=not in_session
)
_x = widget.screen_position_x
_y = widget.screen_position_y
_h = widget.computed_height
auto_reload_menu.show_at(_x - 95, _y + _h / 2 + 2)
return auto_reload_menu
def build_reload_widget(
layer_identifier: str,
usd_context_name_or_instance: Union[str, omni.usd.UsdContext] = None,
is_outdated=False,
is_auto=False,
global_auto=False
) -> None:
"""Builds reload widget."""
if isinstance(usd_context_name_or_instance, str):
usd_context = omni.usd.get_context(usd_context_name_or_instance)
elif isinstance(usd_context_name_or_instance, omni.usd.UsdContext):
usd_context = usd_context_name_or_instance
elif not usd_context_name_or_instance:
usd_context = omni.usd.get_context()
if not usd_context:
carb.log_error("Failed to reload layer as usd context is not invalid.")
return
reload_stack = ReloadWidgetWrapper(width=0, height=0)
if global_auto:
is_auto = global_auto
reload_stack.name = "reload-auto" if is_auto else "reload-outd" if is_outdated else "reload"
reload_stack.set_style(Styles.RELOAD_AUTO if is_auto and not is_outdated else Styles.RELOAD_OTD if is_outdated else Styles.RELOAD_BTN)
with reload_stack:
with ui.VStack(width=0, height=0):
ui.Spacer(width=22, height=12)
with ui.HStack(width=0):
ui.Spacer(width=16)
ui.Image(
LayerIcons.get("drop_down"),
width=6, height=6, alignment=ui.Alignment.RIGHT_BOTTOM,
name="drop_down"
)
ui.Image(LayerIcons.get("reload"), width=20, name="reload")
tooltip = "Auto Reload All Enabled" if global_auto else "Auto Reload Enabled" if is_auto else "Reload"
if is_outdated:
tooltip = "Reload Outdated"
reload_button = ui.InvisibleButton(width=20, tooltip=tooltip)
def on_reload_clicked(layout_weakref, x, y, b, m):
if (b == 0):
reload_outdated_layers(layer_identifier, usd_context)
return
auto_reload_menu = show_reload_menu(layer_identifier, usd_context, reload_stack, reload_button, global_auto)
if layout_weakref():
# Hold the menu handle to release it along with the stack.
layout_weakref().auto_reload_menu = auto_reload_menu
layout_weakref = weakref.ref(reload_stack)
reload_button.set_mouse_pressed_fn(partial(on_reload_clicked, layout_weakref))
return reload_stack
| 4,919 |
Python
| 34.142857 | 138 | 0.639561 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/live_session_start_window.py
|
import asyncio
import carb
import omni.kit.app
import omni.kit.usd.layers as layers
import omni.ui as ui
import re
from .layer_icons import LayerIcons
from .utils import join_live_session, is_viewer_only_mode, get_session_list_select, SESSION_LIST_SELECT_DEFAULT_SESSION
from omni.kit.widget.prompt import PromptButtonInfo, PromptManager
from pxr import Sdf
from .live_session_model import LiveSessionModel
class LiveSessionStartWindow:
def __init__(self, layers_interface: layers.Layers, layer_identifier, prim_path):
self._window = None
self._layers_interface = layers_interface
self._base_layer_identifier = layer_identifier
self._live_prim_path = prim_path
self._buttons = []
self._existing_sessions_combo = None
self._session_name_input_field = None
self._session_name_input_hint = None
self._error_label = None
self._session_name_begin_edit_cb = None
self._session_name_end_edit_cb = None
self._session_name_edit_cb = None
self._existing_sessions_model = LiveSessionModel(self._layers_interface, layer_identifier)
self._participants_list = None
self._participants_layout = None
self._existing_sessions_model.set_user_update_callback(self._on_channel_users_update)
self._existing_sessions_model.add_value_changed(self._on_session_list_changed)
self._update_user_list_task: asyncio.Future = None
self._join_create_radios = None
self._key_functions = {
int(carb.input.KeyboardInput.ENTER): self._on_ok_button_fn,
int(carb.input.KeyboardInput.ESCAPE): self._on_cancel_button_fn
}
self._build_ui()
def _on_layer_event(event: carb.events.IEvent):
payload = layers.get_layer_event_payload(event)
if payload.event_type == layers.LayerEventType.LIVE_SESSION_LIST_CHANGED:
if self._base_layer_identifier not in payload.identifiers_or_spec_paths:
return
self._existing_sessions_model.refresh_sessions(force=True)
self._update_dialog_states()
self._layers_event_subscription = layers_interface.get_event_stream().create_subscription_to_pop(
_on_layer_event, name="Session Start Window Events"
)
def destroy(self):
self._layers_interface = None
for button in self._buttons:
button.set_clicked_fn(None)
self._buttons.clear()
self._participants_list = None
if self._window:
self._window.visible = False
self._window = None
if self._existing_sessions_model:
self._existing_sessions_model.set_user_update_callback(None)
self._existing_sessions_model.destroy()
self._existing_sessions_model = None
self._participants_layout = None
self._layers_event_subscription = None
self._existing_sessions_combo = None
self._existing_sessions_empty_hint = None
self._join_create_radios = None
self._session_name_input_hint = None
self._session_name_input_field = None
self._session_name_begin_edit_cb = None
self._session_name_end_edit_cb = None
self._session_name_edit_cb = None
self._error_label = None
if self._update_user_list_task:
try:
self._update_user_list_task.cancel()
except Exception:
pass
self._update_user_list_task = None
@property
def visible(self):
return self._window and self._window.visible
@visible.setter
def visible(self, value):
if self._window:
self._window.visible = value
if not self._window.visible:
if self._update_user_list_task:
try:
self._update_user_list_task.cancel()
except Exception:
pass
self._update_user_list_task = None
self._existing_sessions_model.stop_channel()
def set_focus(self, join_session):
if not self._join_create_radios:
return
if join_session:
self._join_create_radios.model.set_value(0)
if get_session_list_select() == SESSION_LIST_SELECT_DEFAULT_SESSION:
self._existing_sessions_model.select_default_session()
else:
self._join_create_radios.model.set_value(1)
async def async_focus_keyboard():
await omni.kit.app.get_app().next_update_async()
self._session_name_input_field.focus_keyboard()
omni.kit.async_engine.run_coroutine(async_focus_keyboard())
def _on_channel_users_update(self):
async def _update_users():
all_users = self._existing_sessions_model.all_users
current_session = self._existing_sessions_model.current_session
if not current_session:
return
self._participants_list.clear()
with self._participants_list:
if len(all_users) > 0:
for _, user in all_users.items():
is_owner = current_session.owner == user.user_name
with ui.VStack(height=0):
ui.Spacer(height=5)
with ui.HStack(height=0):
ui.Spacer(width=10)
if is_owner:
ui.Label(f"{user.user_name} - {user.from_app} (owner)", style={"color": 0xFF808080})
else:
ui.Label(f"{user.user_name} - {user.from_app}", style={"color": 0xFF808080})
else:
self._build_empty_participants_list()
if not self._update_user_list_task or self._update_user_list_task.done():
self._update_user_list_task = asyncio.ensure_future(_update_users())
def _validate_session_name(self, str):
if re.match(r'^[a-zA-Z][a-zA-Z0-9-_]*$', str):
return True
return False
def _on_join_session(self, current_session):
layer_identifier = self._base_layer_identifier
layers_interface = self._layers_interface
prim_path = self._live_prim_path
return join_live_session(
layers_interface, layer_identifier, current_session, prim_path, is_viewer_only_mode()
)
def _on_ok_button_fn(self): # pragma: no cover
live_syncing = self._layers_interface.get_live_syncing()
current_option = self._join_create_radios.model.as_int
join_session = current_option == 0
if join_session:
current_session = self._existing_sessions_model.current_session
if not current_session:
self._error_label.text = "No Valid Session Selected"
self._error_label.visible = True
elif self._on_join_session(current_session):
self._error_label.text = ""
self._error_label.visible = False
self.visible = False
else:
self._error_label.text = "Failed to join session, please check console for more details."
self._error_label.visible = True
else:
session_name = self._session_name_input_field.model.get_value_as_string()
session_name = session_name.strip()
if not session_name or not self._validate_session_name(session_name):
self._update_button_status(session_name)
self._error_label.text = "Session name must be given."
self._error_label.visible = True
else:
session = live_syncing.create_live_session(layer_identifier=self._base_layer_identifier, name=session_name)
if not session:
self._error_label.text = "Failed to create session, please check console for more details."
self._error_label.visible = True
elif not self._on_join_session(session):
self._error_label.text = "Failed to join session, please check console for more details."
self._error_label.visible = True
else:
self._error_label.text = ""
self._error_label.visible = False
self.visible = False
def _on_cancel_button_fn(self):
self.visible = False
def _on_key_pressed_fn(self, key, mod, pressed):
if not pressed:
return
func = self._key_functions.get(key)
if func:
func()
def _build_option_checkbox(self, name, text, default_value, tooltip=""): # pragma: no cover
with ui.HStack(height=0, width=0):
checkbox = ui.CheckBox(width=20, name=name)
checkbox.model.set_value(default_value)
label = ui.Label(text, alignment=ui.Alignment.LEFT)
if tooltip:
label.set_tooltip(tooltip)
return checkbox, label
def _build_option_radio(self, collection, name, text, tooltip=""):
style = {
"": {"background_color": 0x0, "image_url": LayerIcons.get("radio_off")},
":checked": {"image_url": LayerIcons.get("radio_on")},
}
with ui.HStack(height=0, width=0):
radio = ui.RadioButton(radio_collection=collection, width=28, height=28, name=name, style=style)
ui.Spacer(width=4)
label = ui.Label(text, alignment=ui.Alignment.LEFT_CENTER)
if tooltip:
label.set_tooltip(tooltip)
return radio
def _update_button_status(self, session_name):
join_button = self._buttons[0]
if session_name and not self._validate_session_name(session_name):
if not str.isalpha(session_name[0]):
self._error_label.text = "Session name must be prefixed with letters."
else:
self._error_label.text = "Only alphanumeric letters, hyphens, or underscores are supported."
self._error_label.visible = True
join_button.enabled = False
else:
self._error_label.text = ""
self._error_label.visible = False
join_button.enabled = True
def _on_session_name_begin_edit(self, model):
self._session_name_input_hint.visible = False
session_name = model.get_value_as_string().strip()
self._update_button_status(session_name)
def _on_session_name_end_edit(self, model):
if len(model.get_value_as_string()) == 0:
self._session_name_input_hint.visible = True
session_name = model.get_value_as_string().strip()
self._update_button_status(session_name)
def _on_session_name_edit(self, model):
session_name = model.get_value_as_string().strip()
self._update_button_status(session_name)
def _update_dialog_states(self):
self._error_label.text = ""
current_option = self._join_create_radios.model.as_int
show_join_session = current_option == 0
join_button = self._buttons[0]
if show_join_session:
self._existing_sessions_combo.visible = True
self._session_name_input_field.visible = False
self._session_name_input_hint.visible = False
self._participants_layout.visible = True
self._existing_sessions_model.refresh_sessions()
if self._existing_sessions_model.empty():
self._existing_sessions_empty_hint.visible = True
else:
self._existing_sessions_empty_hint.visible = False
join_button.text = "JOIN"
else:
self._participants_layout.visible = False
self._existing_sessions_combo.visible = False
self._session_name_input_field.visible = True
self._session_name_input_hint.visible = False
self._existing_sessions_empty_hint.visible = False
self._existing_sessions_model.clear()
join_button.text = "CREATE"
new_session_name = self._existing_sessions_model.create_new_session_name()
self._session_name_input_field.model.set_value(new_session_name)
self._session_name_input_field.focus_keyboard()
def _on_radios_changed_fn(self, model):
self._update_dialog_states()
self._on_checkbox_changed_called = False
def _on_session_list_changed(self, model):
if self._participants_list:
self._participants_list.clear()
def _build_ui(self):
"""Construct the window based on the current parameters"""
self._window = ui.Window("Live Session", visible=False, height=0, auto_resize=True, dockPreference=ui.DockPreference.DISABLED)
self._window.flags = (
ui.WINDOW_FLAGS_NO_COLLAPSE | ui.WINDOW_FLAGS_NO_SCROLLBAR |
ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_MOVE
)
self._window.set_key_pressed_fn(self._on_key_pressed_fn)
self._window.flags = self._window.flags | ui.WINDOW_FLAGS_MODAL
self._existing_sessions_model.refresh_sessions()
empty_sessions = self._existing_sessions_model.empty()
with self._window.frame:
with ui.VStack(height=0):
ui.Spacer(width=0, height=10)
with ui.HStack(height=0):
ui.Spacer()
self._join_create_radios = ui.RadioCollection()
self._build_option_radio(self._join_create_radios, "join_session_radio_button", "Join Session")
ui.Spacer(width=20)
self._build_option_radio(self._join_create_radios, "create_session_radio_button", "Create Session")
ui.Spacer()
self._join_create_radios.model.add_value_changed_fn(lambda _: self._update_dialog_states())
ui.Spacer(width=0, height=15)
with ui.HStack(height=0):
ui.Spacer(width=20)
self._error_label = ui.Label("", name="error_label", style={"color": 0xFF0000CC}, alignment=ui.Alignment.LEFT, word_wrap=True)
ui.Spacer(width=20)
ui.Spacer(width=0, height=5)
with ui.ZStack(height=0):
with ui.HStack(height=0):
ui.Spacer(width=20)
with ui.ZStack(height=0):
self._session_name_input_field = ui.StringField(
name="new_session_name_field", width=self._window.width - 40, height=0
)
self._session_name_input_hint = ui.Label(
" New Session Name", alignment=ui.Alignment.LEFT_CENTER, style={"color": 0xFF3F3F3F}
)
self._session_name_begin_edit_cb = self._session_name_input_field.model.subscribe_begin_edit_fn(
self._on_session_name_begin_edit
)
self._session_name_end_edit_cb = self._session_name_input_field.model.subscribe_end_edit_fn(
self._on_session_name_end_edit
)
self._session_name_edit_cb = self._session_name_input_field.model.subscribe_value_changed_fn(
self._on_session_name_edit
)
ui.Spacer(width=20)
with ui.HStack(height=0):
ui.Spacer(width=20)
with ui.ZStack(height=0):
self._existing_sessions_combo = ui.ComboBox(
self._existing_sessions_model, width=self._window.width - 40, height=0
)
self._existing_sessions_empty_hint = ui.Label(
" No Existing Sessions", alignment=ui.Alignment.LEFT_CENTER, style={"color": 0xFF3F3F3F}
)
ui.Spacer(width=20)
ui.Spacer(width=0, height=10)
self._participants_layout = ui.VStack(height=0)
with self._participants_layout:
with ui.HStack(height=0):
ui.Spacer(width=20)
with ui.VStack(height=0, width=0):
with ui.HStack(height=0, width=0):
ui.Label("Participants: ", alignment=ui.Alignment.CENTER)
with ui.HStack():
ui.Spacer()
ui.Image(LayerIcons.get("participants"), width=28, height=28)
ui.Spacer()
ui.Spacer(width=0, height=5)
with ui.HStack(height=0):
with ui.ScrollingFrame(height=120, style={"background_color": 0xFF24211F}):
self._participants_list = ui.VStack(height=0)
with self._participants_list:
self._build_empty_participants_list()
ui.Spacer(width=20)
ui.Spacer(width=0, height=30)
with ui.HStack(height=0):
ui.Spacer(height=0)
ok_button = ui.Button("JOIN", name="confirm_button", width=120, height=0)
ok_button.set_clicked_fn(self._on_ok_button_fn)
cancel_button = ui.Button("CANCEL", name="cancel_button", width=120, height=0)
cancel_button.set_clicked_fn(self._on_cancel_button_fn)
self._buttons.append(ok_button)
self._buttons.append(cancel_button)
ui.Spacer(height=0, width=20)
ui.Spacer(width=0, height=20)
if empty_sessions:
self._join_create_radios.model.set_value(1)
else:
self._update_dialog_states()
def _build_empty_participants_list(self):
with ui.VStack(height=0):
ui.Spacer(height=5)
with ui.HStack(height=0):
ui.Spacer(width=10)
ui.Label("No users currently in session.", style={"color": 0xFF808080})
| 18,527 |
Python
| 44.635468 | 146 | 0.559454 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/live_session_end_window.py
|
import carb
import asyncio
import omni.ui as ui
import omni.kit.app
import omni.kit.usd.layers as layers
import omni.kit.notification_manager as nm
from omni.kit.widget.prompt import PromptManager
from pxr import Sdf
from .file_picker import FilePicker, FileBrowserMode, FileBrowserSelectionType
class LiveSessionEndWindow:
def __init__(self, layers_interface: layers.Layers, layer_identifier):
self._window = None
self._live_syncing = layers_interface.get_live_syncing()
self._base_layer_identifier = layer_identifier
self._buttons = []
self._options_combo = None
self._file_picker = None
self._key_functions = {
int(carb.input.KeyboardInput.ENTER): self._on_ok_button_fn,
int(carb.input.KeyboardInput.ESCAPE): self._on_cancel_button_fn
}
self._build_ui()
def destroy(self):
for button in self._buttons:
button.set_clicked_fn(None)
self._buttons.clear()
if self._window:
self._window.visible = False
self._window = None
self._options_combo = None
if self._file_picker:
self._file_picker.destroy()
self._file_picker = None
async def __aenter__(self):
await self._live_syncing.broadcast_merge_started_message_async(self._base_layer_identifier)
self.visible = True
# Wait until dialog disappears
while self.visible:
await asyncio.sleep(0.1)
async def __aexit__(self, exc_type, exc, tb):
self.visible = False
@property
def visible(self):
return self._window and self._window.visible
@visible.setter
def visible(self, value):
if self._window:
self._window.visible = value
def _on_ok_button_fn(self):
self.visible = False
if not self._live_syncing.is_layer_in_live_session(self._base_layer_identifier):
return
prompt = None
async def pre_merge(current_session):
nonlocal prompt
app = omni.kit.app.get_app()
await app.next_update_async()
await app.next_update_async()
prompt = PromptManager.post_simple_prompt(
"Merging",
"Merging live layers into base layers...",
None,
shortcut_keys=False
)
async def post_merge(success):
nonlocal prompt
if prompt:
prompt.destroy()
prompt = None
if success:
await self._live_syncing.broadcast_merge_done_message_async(
layer_identifier=self._base_layer_identifier
)
current_session = self._live_syncing.get_current_live_session(self._base_layer_identifier)
comment = self._description_field.model.get_value_as_string()
option = self._options_combo.model.get_item_value_model().as_int
if option == 1:
def save_model(file_path: str, overwrite_existing: bool):
layer = Sdf.Layer.FindOrOpen(file_path)
if not layer:
layer = Sdf.Layer.CreateNew(file_path)
if not layer:
error = f"Failed to save live changes to layer {file_path} as it's not writable."
carb.log_error(error)
nm.post_notification(error, status=nm.NotificationStatus.WARNING)
return
asyncio.ensure_future(
self._live_syncing.merge_and_stop_live_session_async(
file_path, comment, pre_merge=pre_merge, post_merge=post_merge,
layer_identifier=self._base_layer_identifier
)
)
usd_context = self._live_syncing.usd_context
stage = usd_context.get_stage()
root_layer_identifier = stage.GetRootLayer().identifier
root_layer_name = current_session.name
self._show_file_picker(save_model, root_layer_identifier, root_layer_name)
elif option == 0:
asyncio.ensure_future(
self._live_syncing.merge_and_stop_live_session_async(
comment=comment, pre_merge=pre_merge, post_merge=post_merge,
layer_identifier=self._base_layer_identifier
)
)
def _on_cancel_button_fn(self):
self.visible = False
def _on_key_pressed_fn(self, key, mod, pressed):
if not pressed:
return
func = self._key_functions.get(key)
if func:
func()
def _create_file_picker(self):
filter_options = [
(r"^(?=.*.usd$)((?!.*\.(sublayer)\.usd).)*$", "USD File (*.usd)"),
(r"^(?=.*.usda$)((?!.*\.(sublayer)\.usda).)*$", "USDA File (*.usda)"),
(r"^(?=.*.usdc$)((?!.*\.(sublayer)\.usdc).)*$", "USDC File (*.usdc)"),
("(.*?)", "All Files (*.*)"),
]
layer_file_picker = FilePicker(
"Save Live Changes",
FileBrowserMode.SAVE,
FileBrowserSelectionType.FILE_ONLY,
filter_options,
[".usd", ".usda", ".usdc", ".usd"],
)
return layer_file_picker
def _show_file_picker(self, file_handler, default_location=None, default_filename=None):
if not self._file_picker:
self._file_picker = self._create_file_picker()
self._file_picker.set_file_selected_fn(file_handler)
self._file_picker.show(default_location, default_filename)
def _on_description_begin_edit(self, model):
self._description_field_hint_label.visible = False
def _on_description_end_edit(self, model):
if len(model.get_value_as_string()) == 0:
self._description_field_hint_label.visible = True
def _build_ui(self):
"""Construct the window based on the current parameters"""
self._window = ui.Window("Merge Options", visible=False, height=0, dockPreference=ui.DockPreference.DISABLED)
self._window.flags = (
ui.WINDOW_FLAGS_NO_COLLAPSE | ui.WINDOW_FLAGS_NO_SCROLLBAR |
ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_MOVE
)
self._window.set_key_pressed_fn(self._on_key_pressed_fn)
self._window.flags = self._window.flags | ui.WINDOW_FLAGS_MODAL
current_session = self._live_syncing.get_current_live_session(self._base_layer_identifier)
with self._window.frame:
with ui.VStack(height=0):
ui.Spacer(width=0, height=10)
with ui.HStack(height=0):
ui.Spacer()
ui.Label(
"Live Session is ending.", word_wrap=True, alignment=ui.Alignment.CENTER, width=self._window.width - 80, height=0
)
ui.Spacer()
with ui.HStack(height=0):
ui.Spacer()
ui.Label(
f"How do you want to merge changes from '{current_session.name}' session?",
alignment=ui.Alignment.CENTER, word_wrap=True, width=self._window.width - 80, height=0
)
ui.Spacer()
ui.Spacer(width=0, height=10)
with ui.HStack(height=0):
ui.Spacer()
self._options_combo = ui.ComboBox(
0, "Merge to corresponding layers", "Merge to a new layer",
word_wrap=True, width=self._window.width - 80, height=0
)
ui.Spacer()
ui.Spacer(width=0, height=10)
with ui.HStack(height=0):
ui.Spacer(width=40)
self._checkpoint_comment_frame = ui.Frame()
with self._checkpoint_comment_frame:
with ui.VStack(height=0, spacing=5):
ui.Label("Checkpoint Description")
with ui.ZStack():
self._description_field = ui.StringField(multiline=True, height=80)
self._description_field_hint_label = ui.Label(
" Description", alignment=ui.Alignment.LEFT_TOP, style={"color": 0xFF3F3F3F}
)
self._description_begin_edit_sub = self._description_field.model.subscribe_begin_edit_fn(
self._on_description_begin_edit
)
self._description_end_edit_sub = self._description_field.model.subscribe_end_edit_fn(
self._on_description_end_edit
)
ui.Spacer(width=40)
ui.Spacer(width=0, height=30)
with ui.HStack(height=0):
ui.Spacer(height=0)
ok_button = ui.Button("CONTINUE", name="confirm_button", width=120, height=0)
ok_button.set_clicked_fn(self._on_ok_button_fn)
cancel_button = ui.Button("CANCEL", name="cancel_button", width=120, height=0)
cancel_button.set_clicked_fn(self._on_cancel_button_fn)
self._buttons.append(ok_button)
self._buttons.append(cancel_button)
ui.Spacer(height=0)
ui.Spacer(width=0, height=10)
| 9,633 |
Python
| 39.649789 | 137 | 0.534517 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/live_style.py
|
class Styles:
RELOAD_BTN = None
RELOAD_AUTO = None
RELOAD_OTD = None
LIVE_TOOL_TIP = None
@staticmethod
def on_startup():
# from .layer_icons import LayerIcons as li
from omni.ui import color as cl
c_otd = cl("#eb9d00")
c_otdh = cl("#ffaa00")
c_live = cl("#76B900")
c_liveh = cl("#9bf400")
c_lived = cl("#76B900")
c_auto = cl("#34C7FF")
c_autoh = cl("#82dcff")
c_white = cl("#ffffff")
c_rel = cl("#888888")
c_relh = cl("#BBBBBB")
c_disabled = cl("#555555")
Styles.LIVE_TOOL_TIP = {"background_color": 0xEE222222, "color": 0x33333333}
Styles.LIVE_GREEN = {"color": c_live, "Tooltip": Styles.LIVE_TOOL_TIP}
Styles.LIVE_SEL = {"color": c_liveh, "Tooltip": Styles.LIVE_TOOL_TIP}
Styles.LIVE_GREEN_DARKER = {"color": c_lived, "Tooltip": Styles.LIVE_TOOL_TIP}
Styles.RELOAD_BTN = {
"color": c_rel,
":hovered": {"color": c_relh},
":pressed": {"color": c_white},
":disabled": {"color": c_disabled},
}
Styles.RELOAD_AUTO = {
"color": c_auto, "Tooltip": Styles.LIVE_TOOL_TIP,
":hovered": {"color": c_autoh},
":pressed": {"color": c_white},
":disabled": {"color": c_disabled},
}
Styles.RELOAD_OTD = {
"color": c_otd, "Tooltip": Styles.LIVE_TOOL_TIP,
":hovered": {"color": c_otdh},
":pressed": {"color": c_white},
":disabled": {"color": c_disabled},
}
| 1,602 |
Python
| 29.245282 | 86 | 0.500624 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/live_session_model.py
|
__all__ = ["LiveSessionItem", "LiveSessionModel"]
import asyncio
import omni.kit.usd.layers as layers
import omni.ui as ui
from typing import Callable
import itertools
_last_sessions = {}
class LiveSessionItem(ui.AbstractItem):
def __init__(self, session: layers.LiveSession) -> None:
super().__init__()
self._session = session
self.model = ui.SimpleStringModel(session.name)
@property
def session(self):
return self._session
def __str__(self) -> str:
return self._session.name
class LiveSessionModel(ui.AbstractItemModel):
def __init__(self, layers_interface: layers.Layers, layer_identifier, update_users=True) -> None:
super().__init__()
self._layers_interface = layers_interface
self._base_layer_identifier = layer_identifier
self._current_index = ui.SimpleIntModel()
self._current_index.set_value(-1)
id = self._current_index.add_value_changed_fn(self._value_changed_fn)
self._items = []
self._current_session = None
self._current_session_channel = None
self._channel_subscriber = None
self._join_channel_task = None
self._all_users = {}
self._user_update_callback: Callable[[], None] = None
self._all_value_changed_fns = [id]
self._update_users = update_users
self._refreshing_item = False
self._is_default_session_selected = False
def __del__(self):
self.destroy()
@property
def all_users(self):
return self._all_users
@property
def is_default_session_selected(self):
return self._is_default_session_selected
def set_user_update_callback(self, callback: Callable[[], None]):
self._user_update_callback = callback
def stop_channel(self):
self._cancel_current_task()
def _join_current_channel(self):
if not self._current_session or not self._update_users:
return
try:
# OM-108516: Make channel_manager optional
import omni.kit.collaboration.channel_manager as cm
except ImportError:
return
if not self._current_session_channel or self._current_session_channel.url != self._current_session.url:
self._cancel_current_task()
async def join_stage_async(url):
self._current_session_channel = await cm.join_channel_async(url, True)
if not self._current_session_channel:
return
self._channel_subscriber = self._current_session_channel.add_subscriber(self._on_channel_message)
self._join_channel_task = asyncio.ensure_future(join_stage_async(self._current_session.channel_url))
def _on_channel_message(self, message):
try:
# OM-108516: Make channel_manager optional
import omni.kit.collaboration.channel_manager as cm
except ImportError:
return
user = message.from_user
if message.message_type == cm.MessageType.LEFT and user.user_id in self._all_users:
self._all_users.pop(user.user_id, None)
changed = True
elif user.user_id not in self._all_users:
self._all_users[user.user_id] = user
changed = True
else:
changed = False
if changed and self._user_update_callback:
self._user_update_callback()
def _cancel_current_task(self):
if self._join_channel_task and not self._join_channel_task.done():
try:
self._join_channel_task.cancel()
except Exception:
pass
if self._current_session_channel:
self._current_session_channel.stop()
self._current_session_channel = None
self._join_channel_task = None
self._channel_subscriber = None
def add_value_changed(self, fn):
if self._current_index:
id = self._current_index.add_value_changed_fn(fn)
self._all_value_changed_fns.append(id)
def _value_changed_fn(self, model):
if self._refreshing_item:
return
global _last_sessions
index = self._current_index.as_int
if index < 0 or index >= len(self._items):
return
self._current_session = self._items[index].session
self._is_default_session_selected = (self._current_session and self._current_index.as_int == 0)
_last_sessions[self._base_layer_identifier] = self._current_session.url
self._all_users.clear()
if self._user_update_callback:
self._user_update_callback()
self._join_current_channel()
self._refreshing_item = True
self._item_changed(None)
self._refreshing_item = False
def destroy(self):
self._user_update_callback = None
self._cancel_current_task()
if self._current_index:
for fn in self._all_value_changed_fns:
self._current_index.remove_value_changed_fn(fn)
self._all_value_changed_fns.clear()
self._current_index = None
self._layers_interface = None
self._current_session = None
self._items = []
self._all_users = {}
self._layers_event_subscription = None
def clear(self):
self._items = []
self._current_session = None
self._current_index.set_value(-1)
def empty(self):
return len(self._items) == 0
def get_item_children(self, item):
return self._items
@property
def current_session(self):
return self._current_session
def refresh_sessions(self, force=False):
global _last_sessions
live_syncing = self._layers_interface.get_live_syncing()
current_live_session = live_syncing.get_current_live_session(self._base_layer_identifier)
live_sessions = live_syncing.get_all_live_sessions(self._base_layer_identifier)
live_sessions.sort(key=lambda s: s.get_last_modified_time(), reverse=True)
identifier = self._base_layer_identifier
pre_sort = []
for session in live_sessions:
if session.name == "Default":
pre_sort.insert(0, session)
else:
pre_sort.append(session)
self._items.clear()
index = 0 if live_sessions else -1
for i, session in enumerate(pre_sort):
item = LiveSessionItem(session)
if current_live_session and current_live_session.url == session.url:
index = i
elif identifier in _last_sessions and _last_sessions[identifier] == session.url:
index = i
self._items.append(item)
current_index = self._current_index.as_int
if current_index != index:
self._current_index.set_value(index)
elif force:
self._item_changed(None)
self._is_default_session_selected = (self._current_session and self._current_index.as_int == 0)
def get_item_value_model(self, item, column_id):
if item is None:
return self._current_index
return item.model
def select_default_session(self):
live_syncing = self._layers_interface.get_live_syncing()
live_sessions = live_syncing.get_all_live_sessions(self._base_layer_identifier)
if live_sessions and self._current_index.as_int != 0:
self._current_index.set_value(0)
self._item_changed(None)
return
def create_new_session_name(self) -> str:
live_syncing = self._layers_interface.get_live_syncing()
live_sessions = live_syncing.get_all_live_sessions(self._base_layer_identifier)
# first we attempt creating a "Default" as the first new session.
default_session_name = "Default"
if not live_syncing.find_live_session_by_name(self._base_layer_identifier, default_session_name):
return default_session_name
# if there already is a `Default`, then we use <username>_01, <username>_02, ...
layers_instance = live_syncing._layers_instance
live_syncing_interface = live_syncing._live_syncing_interface
logged_user_name = live_syncing_interface.get_logged_in_user_name_for_layer(layers_instance, self._base_layer_identifier)
if "@" in logged_user_name:
logged_user_name = logged_user_name.split('@')[0]
for i in itertools.count(start=1):
user_session_name = "{}_{:02d}".format(logged_user_name, i)
if not live_syncing.find_live_session_by_name(self._base_layer_identifier, user_session_name):
return user_session_name
| 8,699 |
Python
| 35.708861 | 129 | 0.613174 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/live_session_camera_follower_list.py
|
__all__ = ["LiveSessionCameraFollowerList"]
import carb
import omni.usd
import omni.client.utils as clientutils
import omni.ui as ui
import omni.kit.usd.layers as layers
import omni.kit.collaboration.presence_layer as pl
from .utils import build_live_session_user_layout
from pxr import Sdf
from omni.ui import color as cl
TOOLTIP_STYLE = {
"color": cl("#979797"),
"Tooltip": {"background_color": 0xEE222222}
}
class LiveSessionCameraFollowerList:
"""Widget to build an user list to show all followers to the specific camera."""
def __init__(self, usd_context: omni.usd.UsdContext, camera_path: Sdf.Path, **kwargs):
"""
Constructor.
Args:
usd_context (omni.usd.UsdContext): USD Context instance.
camera_path (str): Interested camera.
Kwargs:
icon_size (int): The width and height of the user icon. 16 pixel by default.
spacing (int): The horizonal spacing between two icons. 2 pixel by default.
maximum_users (int): The maximum users to show, and show others with overflow.
show_my_following_users (bool): Whether it should show the users that are following me or not.
"""
self.__icon_size = kwargs.get("icon_size", 16)
self.__spacing = kwargs.get("spacing", 2)
self.__maximum_count = kwargs.get("maximum_users", 3)
self.__show_my_following_users = kwargs.get("show_my_following_users", True)
self.__camera_path = camera_path
self.__usd_context = usd_context
self.__presence_layer = pl.get_presence_layer_interface(self.__usd_context)
self.__layers = layers.get_layers(usd_context)
self.__live_syncing = layers.get_live_syncing()
self.__layers_event_subscriptions = []
self.__main_layout: ui.HStack = ui.HStack(width=0, height=0)
self.__all_user_layouts = {}
self.__initialize()
self.__overflow = False
self.__overflow_button = None
@property
def layout(self) -> ui.HStack:
return self.__main_layout
def empty(self):
return len(self.__all_user_layouts) == 0
def track_camera(self, camera_path: Sdf.Path):
"""Switches the camera path to listen to."""
if self.__camera_path != camera_path:
self.__camera_path = camera_path
self.__initialize()
def __initialize(self):
layer_identifier = self.__usd_context.get_stage_url()
if self.__camera_path and not clientutils.is_local_url(layer_identifier):
for event in [
layers.LayerEventType.LIVE_SESSION_STATE_CHANGED,
layers.LayerEventType.LIVE_SESSION_USER_JOINED,
layers.LayerEventType.LIVE_SESSION_USER_LEFT,
pl.PresenceLayerEventType.BOUND_CAMERA_CHANGED
]:
layers_event_subscription = self.__layers.get_event_stream().create_subscription_to_pop_by_type(
event, self.__on_layers_event,
name=f"omni.kit.widget.live_session_management.LiveSessionCameraFollowerList {str(event)}"
)
self.__layers_event_subscriptions.append(layers_event_subscription)
else:
self.__layers_event_subscriptions = []
self.__build_ui()
def __build_ui(self):
# Destroyed
if not self.__main_layout:
return
self.__main_layout.clear()
self.__all_user_layouts.clear()
self.__overflow = False
self.__overflow_button = None
current_live_session = self.__live_syncing.get_current_live_session()
if not current_live_session or not self.__camera_path:
return
with self.__main_layout:
for peer_user in current_live_session.peer_users:
self.__add_user(current_live_session, peer_user.user_id, False)
if self.__overflow:
break
if self.empty():
self.__main_layout.visible = False
else:
self.__main_layout.visible = True
def __build_tooltip(self): # pragma: no cover
live_session = self.__live_syncing.get_current_live_session(self.__base_layer_identifier)
if not live_session:
return
with ui.VStack():
with ui.HStack(style={"color": cl("#757575")}):
ui.Spacer()
title_label = ui.Label(
"Following by 0 Users", style={"font_size": 12}, width=0
)
ui.Spacer()
ui.Spacer(height=0)
ui.Separator(style={"color": cl("#4f4f4f")})
ui.Spacer(height=4)
valid_users = 0
for user in live_session.peer_users:
if not self.__show_my_following_users:
following_user_id = self.__presence_layer.get_following_user_id(user.user_id)
if following_user_id == live_session.logged_user_id:
continue
bound_camera_prim = self.__presence_layer.get_bound_camera_prim(user.user_id)
if not bound_camera_prim or bound_camera_prim.GetPath() != self.__camera_path:
continue
valid_users += 1
item_title = f"{user.user_name} ({user.from_app})"
with ui.HStack():
build_live_session_user_layout(user, self.__icon_size, "")
ui.Spacer(width=4)
ui.Label(item_title, style={"font_size": 14})
ui.Spacer(height=2)
title_label.text = f"Following by {valid_users} Users"
@carb.profiler.profile
def __add_user(self, current_live_session, user_id, add_child=False):
bound_camera_prim = self.__presence_layer.get_bound_camera_prim(user_id)
if not bound_camera_prim:
return False
if bound_camera_prim.GetPath() == self.__camera_path:
user_info = current_live_session.get_peer_user_info(user_id)
if not user_info:
return False
if not self.__show_my_following_users:
following_user_id = self.__presence_layer.get_following_user_id(user_id)
if following_user_id == current_live_session.logged_user_id:
return False
if user_id not in self.__all_user_layouts:
current_count = len(self.__all_user_layouts)
if current_count > self.__maximum_count or self.__overflow:
# OMFP-2909: Refresh overflow button to rebuild tooltip.
if self.__overflow and self.__overflow_button:
self.__overflow_button.set_tooltip_fn(self.__build_tooltip)
return True
elif current_count == self.__maximum_count:
self.__overflow = True
layout = ui.HStack(width=0)
with layout:
ui.Spacer(width=4)
with ui.ZStack():
ui.Label("...", style={"font_size": 16}, aligment=ui.Alignment.V_CENTER)
self.__overflow_button = ui.InvisibleButton(style=TOOLTIP_STYLE)
self.__overflow_button.set_tooltip_fn(self.__build_tooltip)
if add_child:
self.__main_layout.add_child(layout)
else:
if self.empty():
spacer = 0
else:
spacer = self.__spacing
layout = self.__build_user_layout(user_info, spacer)
if add_child:
self.__main_layout.add_child(layout)
self.__main_layout.visible = True
self.__all_user_layouts[user_id] = layout
return True
return False
@carb.profiler.profile
def __on_layers_event(self, event):
payload = layers.get_layer_event_payload(event)
stage_url = self.__usd_context.get_stage_url()
if payload.event_type == layers.LayerEventType.LIVE_SESSION_STATE_CHANGED:
if stage_url not in payload.identifiers_or_spec_paths:
return
self.__build_ui()
elif (
payload.event_type == layers.LayerEventType.LIVE_SESSION_USER_JOINED or
payload.event_type == layers.LayerEventType.LIVE_SESSION_USER_LEFT
):
if stage_url != payload.layer_identifier:
return
current_live_session = self.__live_syncing.get_current_live_session()
if not current_live_session:
self.__build_ui()
return
user_id = payload.user_id
if payload.event_type == layers.LayerEventType.LIVE_SESSION_USER_LEFT:
user = self.__all_user_layouts.pop(user_id, None)
if user:
# FIXME: omni.ui does not support to remove single child.
self.__build_ui()
else:
self.__add_user(current_live_session, user_id, True)
else:
current_live_session = self.__live_syncing.get_current_live_session()
if not current_live_session:
return
payload = pl.get_presence_layer_event_payload(event)
if not payload or not payload.event_type:
return
if payload.event_type == pl.PresenceLayerEventType.BOUND_CAMERA_CHANGED:
changed_user_ids = payload.changed_user_ids
needs_rebuild = False
for user_id in changed_user_ids:
if not self.__add_user(current_live_session, user_id, True):
# It's not bound to this camera already.
needs_rebuild = user_id in self.__all_user_layouts
break
if needs_rebuild:
self.__build_ui()
def destroy(self): # pragma: no cover
self.__main_layout = None
self.__layers_event_subscriptions = []
self.__layers = None
self.__live_syncing = None
self.__all_user_layouts.clear()
self.__overflow_button = None
def __build_user_layout(self, user_info: layers.LiveSessionUser, spacing=2):
tooltip = f"{user_info.user_name} ({user_info.from_app})"
layout = ui.HStack()
with layout:
ui.Spacer(width=spacing)
build_live_session_user_layout(user_info, self.__icon_size, tooltip)
return layout
| 10,669 |
Python
| 39.264151 | 112 | 0.556472 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/filebrowser/__init__.py
|
from .app_filebrowser import FileBrowserUI, FileBrowserSelectionType, FileBrowserMode
| 85 |
Python
| 84.999915 | 85 | 0.894118 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/filebrowser/app_filebrowser.py
|
import asyncio
import re
import omni.client
import omni.client.utils as clientutils
from omni.kit.window.filepicker import FilePickerDialog
from omni.kit.widget.filebrowser import FileBrowserItem
from typing import Iterable, Tuple, Union
class FileBrowserSelectionType:
FILE_ONLY = 0
DIRECTORY_ONLY = 1
ALL = 2
class FileBrowserMode:
OPEN = 0
SAVE = 1
class FileBrowserUI:
def __init__(self, title, mode, selection_type, filter_options, **kwargs):
if mode == FileBrowserMode.OPEN:
confirm_text = "Open"
else:
confirm_text = "Save"
self._file_picker = FilePickerApp(title, confirm_text, selection_type, filter_options, **kwargs)
def set_current_directory(self, dir):
self._file_picker.set_current_directory(dir)
def set_current_filename(self, filename):
self._file_picker.set_current_filename(filename)
def get_current_filename(self):
return self._file_picker.get_current_filename()
def open(self, select_fn, cancel_fn):
self._file_picker.set_custom_fn(select_fn, cancel_fn)
self._file_picker.show_dialog()
def destroy(self):
self._file_picker.set_custom_fn(None, None)
self._file_picker = None
def hide(self):
self._file_picker.hide_dialog()
class FilePickerApp:
"""
Standalone app to demonstrate the use of the FilePicker dialog.
Args:
title (str): Title of the window.
apply_button_name (str): Name of the confirm button.
selection_type (FileBrowserSelectionType): The file type that confirm event will respond to.
item_filter_options (list): Array of filter options. Element of array
is a tuple that first element of this tuple is the regex string for filtering,
and second element of this tuple is the descriptions, like ("*.*", "All Files").
By default, it will list all files.
kwargs: additional keyword arguments to be passed to FilePickerDialog.
"""
def __init__(
self,
title: str,
apply_button_name: str,
selection_type: FileBrowserSelectionType = FileBrowserSelectionType.ALL,
item_filter_options: Iterable[Tuple[Union[re.Pattern, str], str]] = ((
re.compile(".*"), "All Files (*.*)")),
**kwargs,
):
self._title = title
self._filepicker = None
self._selection_type = selection_type
self._custom_select_fn = None
self._custom_cancel_fn = None
self._apply_button_name = apply_button_name
self._filter_regexes = []
self._filter_descriptions = []
self._current_directory = None
for regex, desc in item_filter_options:
if not isinstance(regex, re.Pattern):
regex = re.compile(regex, re.IGNORECASE)
self._filter_regexes.append(regex)
self._filter_descriptions.append(desc)
self._build_ui(**kwargs)
def set_custom_fn(self, select_fn, cancel_fn):
self._custom_select_fn = select_fn
self._custom_cancel_fn = cancel_fn
def show_dialog(self):
self._filepicker.show(self._current_directory)
self._current_directory = None
def hide_dialog(self):
self._filepicker.hide()
def set_current_directory(self, dir: str):
self._current_directory = dir
if not self._current_directory.endswith("/"):
self._current_directory += "/"
def set_current_filename(self, filename: str):
self._filepicker.set_filename(filename)
def get_current_filename(self):
return self._filepicker.get_filename()
def _build_ui(self, **kwargs):
on_click_open = lambda f, d: asyncio.ensure_future(self._on_click_open(f, d))
on_click_cancel = lambda f, d: asyncio.ensure_future(self._on_click_cancel(f, d))
# Create the dialog
self._filepicker = FilePickerDialog(
self._title,
allow_multi_selection=False,
apply_button_label=self._apply_button_name,
click_apply_handler=on_click_open,
click_cancel_handler=on_click_cancel,
item_filter_options=self._filter_descriptions,
item_filter_fn=lambda item: self._on_filter_item(item),
error_handler=lambda m: self._on_error(m),
**kwargs,
)
# Start off hidden
self.hide_dialog()
def _on_filter_item(self, item: FileBrowserItem) -> bool:
if not item or item.is_folder:
return True
if self._filepicker.current_filter_option >= len(self._filter_regexes):
return False
regex = self._filter_regexes[self._filepicker.current_filter_option]
if regex.match(item.path):
return True
else:
return False
def _on_error(self, msg: str):
"""
Demonstrates error handling. Instead of just printing to the shell, the App can
display the error message to a console window.
"""
print(msg)
async def _on_click_open(self, filename: str, dirname: str):
"""
The meat of the App is done in this callback when the user clicks 'Accept'. This is
a potentially costly operation so we implement it as an async operation. The inputs
are the filename and directory name. Together they form the fullpath to the selected
file.
"""
dirname = dirname.strip()
if dirname and not dirname.endswith("/"):
dirname += "/"
fullpath = clientutils.make_absolute_url_if_possible(dirname, filename)
result, entry = omni.client.stat(fullpath)
if result == omni.client.Result.OK and entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN:
is_folder = True
else:
is_folder = False
if not is_folder and self._selection_type == FileBrowserSelectionType.DIRECTORY_ONLY:
return
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_select_fn:
self._custom_select_fn(fullpath, self._filepicker.current_filter_option)
async def _on_click_cancel(self, filename: str, dirname: str):
"""
This function is called when the user clicks 'Cancel'.
"""
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_cancel_fn:
self._custom_cancel_fn()
| 6,490 |
Python
| 33.343915 | 104 | 0.623729 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/tests/mock_utils.py
|
import carb
import asyncio
import os
import functools
import uuid
import omni.usd
import omni.client
import omni.kit.usd.layers as layers
from typing import Callable, Awaitable
from omni.kit.collaboration.channel_manager.types import PeerUser
from omni.kit.usd.layers import LayersState, LiveSyncing, LiveSession
from ..live_session_model import LiveSessionModel
from ..file_picker import FilePicker
from omni.kit.usd.layers._omni_kit_usd_layers import IWorkflowLiveSyncing
from unittest.mock import Mock, MagicMock
from pxr import Sdf, Usd
_mock_sdf_save_layer_api = None
_mock_layer_states_get_all_outdated_layer_identifiers_api = None
_mock_live_session_model_all_users_api = None
_mock_live_syncing_merge_and_stop_live_session_async_api = None
_mock_filepicker_show_api = None
_mock_filepicker_set_file_selected_fn_api = None
_mock_outdated_layers = []
file_save_handler = None
merge_and_stop_live_session_async_called = False
def append_outdated_layers(layer_id):
global _mock_outdated_layers
_mock_outdated_layers.append(layer_id)
def clear_outdated_layers():
global _mock_outdated_layers
_mock_outdated_layers = []
def get_merge_and_stop_live_session_async_called():
global merge_and_stop_live_session_async_called
return merge_and_stop_live_session_async_called
def _start_mock_api_for_live_session_management():
carb.log_info("Start mock api for live session management...")
def __mock_sdf_save_layer(force):
pass
global _mock_sdf_save_layer_api
_mock_sdf_save_layer_api = Sdf.Layer.Save
Sdf.Layer.Save = Mock(side_effect=__mock_sdf_save_layer)
def __mock_layer_states_get_all_outdated_layer_identifiers_():
global _mock_outdated_layers
return _mock_outdated_layers
global _mock_layer_states_get_all_outdated_layer_identifiers_api
_mock_layer_states_get_all_outdated_layer_identifiers_api = LayersState.get_all_outdated_layer_identifiers
LayersState.get_all_outdated_layer_identifiers = Mock(side_effect=__mock_layer_states_get_all_outdated_layer_identifiers_)
global _mock_live_session_model_all_users_api
_mock_live_session_model_all_users_api = LiveSessionModel.all_users
LiveSessionModel.all_users = {f"user_{i}": PeerUser(f"user_{i}", f"user_{i}", "Kit") for i in range(3)}
async def __mock_live_syncing_merge_and_stop_live_session_async(
self, target_layer: str = None, comment="",
pre_merge: Callable[[LiveSession], Awaitable] = None,
post_merge: Callable[[bool], Awaitable] = None,
layer_identifier: str = None
) -> bool:
global merge_and_stop_live_session_async_called
merge_and_stop_live_session_async_called = True
return True
global _mock_live_syncing_merge_and_stop_live_session_async_api
_mock_live_syncing_merge_and_stop_live_session_async_api = LiveSyncing.merge_and_stop_live_session_async
LiveSyncing.merge_and_stop_live_session_async = Mock(side_effect=__mock_live_syncing_merge_and_stop_live_session_async)
def __mock_filepicker_show(dummy1, dummy2):
global file_save_handler
if file_save_handler:
file_save_handler(dummy1, False)
global _mock_filepicker_show_api
_mock_filepicker_show_api = FilePicker.show
FilePicker.show = Mock(side_effect=__mock_filepicker_show)
def __mock_filepicker_set_file_selected_fn(fn):
global file_save_handler
file_save_handler = fn
global _mock_filepicker_set_file_selected_fn_api
_mock_filepicker_set_file_selected_fn_api = FilePicker.set_file_selected_fn
FilePicker.set_file_selected_fn = Mock(side_effect=__mock_filepicker_set_file_selected_fn)
def _end_mock_api_for_live_session_management():
carb.log_info("Start mock api for live session management...")
global _mock_sdf_save_layer_api
Sdf.Layer.Save = _mock_sdf_save_layer_api
_mock_sdf_save_layer_api = None
global _mock_layer_states_get_all_outdated_layer_identifiers_api
LayersState.get_all_outdated_layer_identifiers = _mock_layer_states_get_all_outdated_layer_identifiers_api
_mock_layer_states_get_all_outdated_layer_identifiers_api = None
global _mock_live_session_model_all_users_api
LiveSessionModel.all_users = _mock_live_session_model_all_users_api
_mock_live_session_model_all_users_api = None
global _mock_live_syncing_merge_and_stop_live_session_async_api
LiveSyncing.merge_and_stop_live_session_async = _mock_live_syncing_merge_and_stop_live_session_async_api
_mock_live_syncing_merge_and_stop_live_session_async_api = None
global _mock_filepicker_show_api
FilePicker.show = _mock_filepicker_show_api
_mock_filepicker_show_api = None
global _mock_filepicker_set_file_selected_fn_api
FilePicker.set_file_selected_fn = _mock_filepicker_set_file_selected_fn_api
_mock_filepicker_set_file_selected_fn_api = None
global merge_and_stop_live_session_async_called
merge_and_stop_live_session_async_called = False
def MockApiForLiveSessionManagement(*args, **kwargs):
if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
func = args[0]
args = args[1:]
else:
func = None
def wrapper(func):
@functools.wraps(func)
def wrapper_api(*args, **kwargs):
try:
_start_mock_api_for_live_session_management()
return func(*args, **kwargs)
finally:
_end_mock_api_for_live_session_management()
@functools.wraps(func)
async def wrapper_api_async(*args, **kwargs):
try:
_start_mock_api_for_live_session_management()
return await func(*args, **kwargs)
finally:
_end_mock_api_for_live_session_management()
if asyncio.iscoroutinefunction(func):
return wrapper_api_async
else:
return wrapper_api
if func:
return wrapper(func)
else:
return wrapper
| 5,995 |
Python
| 37.435897 | 126 | 0.69975 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/tests/__init__.py
|
from .test_live_session_management import *
| 43 |
Python
| 42.999957 | 43 | 0.813953 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/omni/kit/widget/live_session_management/tests/test_live_session_management.py
|
import os
import carb
import omni.usd
import omni.kit.ui_test as ui_test
import omni.ui as ui
import omni.kit.usd.layers as layers
import omni.timeline.live_session
import omni.kit.collaboration.presence_layer as pl
import omni.kit.collaboration.presence_layer.utils as pl_utils
import unittest
import tempfile
import random
import uuid
from omni.kit.test import AsyncTestCase
from omni.kit.window.preferences import register_page, unregister_page
from pxr import Sdf, Usd
from omni.kit.usd.layers.tests.mock_utils import MockLiveSyncingApi, join_new_simulated_user, quit_simulated_user, forbid_session_merge
from ..extension import LiveSessionWidgetExtension, stop_or_show_live_session_widget
from ..live_session_camera_follower_list import LiveSessionCameraFollowerList
from ..live_session_user_list import LiveSessionUserList
from ..file_picker import FilePicker, FileBrowserMode, FileBrowserSelectionType
from ..live_session_preferences import LiveSessionPreferences
from ..reload_widget import build_reload_widget
from ..live_session_start_window import LiveSessionStartWindow
from .mock_utils import (
MockApiForLiveSessionManagement,
append_outdated_layers,
clear_outdated_layers,
get_merge_and_stop_live_session_async_called
)
TEST_URL = "omniverse://__omni.kit.widget.live_session_management__/tests/"
LIVE_SESSION_CONFIRM_BUTTON_PATH = "Live Session//Frame/**/Button[*].name=='confirm_button'"
LIVE_SESSION_CANCEL_BUTTON_PATH = "Live Session//Frame/**/Button[*].name=='cancel_button'"
LEAVE_SESSION_CONFIRM_BUTTON_PATH = "Leave Session//Frame/**/Button[*].name=='confirm_button'"
JOIN_LIVE_SESSION_WITH_LINK_CANCEL_BUTTON_PATH = "JOIN LIVE SESSION WITH LINK//Frame/**/Button[*].name=='cancel_button'"
SHARE_LIVE_SESSION_LINK_COMBO_BOX_PATH = "SHARE LIVE SESSION LINK//Frame/**/ComboBox[0]"
SHARE_LIVE_SESSION_LINK_CONFIRM_BUTTON_PATH = "SHARE LIVE SESSION LINK//Frame/**/InvisibleButton[*].name=='confirm_button'"
MERGE_OPTIONS_CONFIRM_BUTTON_PATH = "Merge Options//Frame/**/Button[*].name=='confirm_button'"
MERGE_OPTIONS_COMBO_BOX_PATH = "Merge Options//Frame/**/ComboBox[0]"
MERGE_PROMPT_LEAVE_BUTTON_PATH = "Permission Denied//Frame/**/Button[*].name=='confirm_button'"
QUICK_JOIN_ENABLED = "/exts/omni.kit.widget.live_session_management/quick_join_enabled"
def _menu_items_as_string_list(items):
return [i.text for i in items]
def _find_menu_item(items, text):
for i in items:
if i.text == text:
return i
return None
def enable_server_tests():
settings = carb.settings.get_settings()
return True or settings.get_as_bool("/exts/omni.kit.widget.live_session_management/enable_server_tests")
class TestLiveSessionManagement(AsyncTestCase):
def get_live_syncing(self):
usd_context = omni.usd.get_context()
self.assertIsNotNone(layers.get_layers(usd_context))
self.assertIsNotNone(layers.get_layers(usd_context).get_live_syncing())
return layers.get_layers(usd_context).get_live_syncing()
async def setUp(self):
self._instance = LiveSessionWidgetExtension.get_instance()
self.assertIsNotNone(self._instance)
self.assertFalse(self.get_live_syncing().is_stage_in_live_session())
pass
async def _close_case(self):
if omni.usd.get_context().get_stage():
live_syncing = self.get_live_syncing()
if live_syncing:
if live_syncing.is_stage_in_live_session():
await self._leave_current_session()
live_syncing.stop_all_live_sessions()
await omni.usd.get_context().close_stage_async()
await ui_test.human_delay(6)
async def _click_menu_item(self, item, right_click=False):
offset = ui_test.Vec2(5, 5)
pos = ui_test.Vec2(item.screen_position_x, item.screen_position_y) + offset
await ui_test.emulate_mouse_move(pos, 4)
await ui_test.human_delay(6)
await ui_test.emulate_mouse_click(right_click=right_click)
await ui_test.human_delay(6)
async def _create_test_usd(self, filename = 'test'):
await omni.client.delete_async(TEST_URL)
stage_url = TEST_URL + f"{filename}.usd"
layer = Sdf.Layer.CreateNew(stage_url)
stage = Usd.Stage.Open(layer.identifier)
self.assertIsNotNone(stage)
return stage
async def _create_test_sublayer_usd(self, filename = 'sublayer'):
layer_url = TEST_URL + f"{filename}.usd"
layer = Sdf.Layer.CreateNew(layer_url)
return layer
async def _expand_live_session_menu(self,
layer_identifier: str=None,
quick_join: str=None):
stop_or_show_live_session_widget(layer_identifier=layer_identifier, quick_join=quick_join)
await ui_test.human_delay(6)
menu = self._instance._live_session_menu
self.assertIsNotNone(menu)
items = ui.Inspector.get_children(menu)
await ui_test.human_delay(6)
return items
def _get_current_menu_item_string_list(self):
menu = ui.Menu.get_current()
self.assertIsNotNone(menu)
items = ui.Inspector.get_children(menu)
return _menu_items_as_string_list(items)
async def _click_on_current_menu(self, text: str):
menu = ui.Menu.get_current()
self.assertIsNotNone(menu)
items = ui.Inspector.get_children(menu)
item_str_list = self._get_current_menu_item_string_list()
self.assertIn(text, item_str_list)
item = _find_menu_item(items, text)
self.assertIsNotNone(item)
await self._click_menu_item(item)
await ui_test.human_delay(6)
async def _click_live_session_menu_item(self,
text: str, layer_identifier = None,
quick_join: str = None):
items = await self._expand_live_session_menu(layer_identifier, quick_join)
self.assertTrue(len(items) > 0)
item_str_list = _menu_items_as_string_list(items)
self.assertIn(text, item_str_list)
item = _find_menu_item(items, text)
self.assertIsNotNone(item)
await self._click_menu_item(item)
await ui_test.human_delay(6)
@MockLiveSyncingApi
async def test_create_session_dialog(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._click_live_session_menu_item("Create Session")
frame = ui_test.find("Live Session")
self.assertIsNotNone(frame)
cancal_button = ui_test.find(LIVE_SESSION_CANCEL_BUTTON_PATH)
self.assertIsNotNone(cancal_button)
await cancal_button.click()
await self._close_case()
async def _create_session(self, session_name: str=None):
await self._click_live_session_menu_item("Create Session")
frame = ui_test.find("Live Session")
self.assertIsNotNone(frame)
if session_name:
name_field = ui_test.find("Live Session//Frame/**/StringField[0]")
self.assertIsNotNone(name_field)
name_field.model.set_value(session_name)
ok_button = ui_test.find(LIVE_SESSION_CONFIRM_BUTTON_PATH)
self.assertIsNotNone(ok_button)
await ok_button.click()
await ui_test.human_delay(6)
async def _create_session_then_leave(self, session_name: str):
self.assertFalse(self.get_live_syncing().is_stage_in_live_session())
await self._create_session(session_name)
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
await self._leave_current_session()
self.assertFalse(self.get_live_syncing().is_stage_in_live_session())
async def _leave_current_session(self):
await self._click_live_session_menu_item("Leave Session")
if ui_test.find("Leave Session"):
button = ui_test.find(LEAVE_SESSION_CONFIRM_BUTTON_PATH)
self.assertIsNotNone(button)
await button.click()
await ui_test.human_delay(6)
@MockLiveSyncingApi
async def test_create_session(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session("test")
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
self.get_live_syncing().stop_all_live_sessions()
self.assertFalse(self.get_live_syncing().is_stage_in_live_session())
await self._close_case()
@MockLiveSyncingApi
async def test_leave_session(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._close_case()
@MockLiveSyncingApi
async def test_join_session(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session_then_leave("test")
await self._click_live_session_menu_item("Join Session")
frame = ui_test.find("Live Session")
self.assertIsNotNone(frame)
ok_button = ui_test.find(LIVE_SESSION_CONFIRM_BUTTON_PATH)
self.assertIsNotNone(ok_button)
await ok_button.click()
await ui_test.human_delay(6)
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
await self._close_case()
@MockLiveSyncingApi
@MockApiForLiveSessionManagement
async def test_join_session_participants(self):
stage = await self._create_test_usd("test")
await omni.usd.get_context().attach_stage_async(stage)
live_session_start_window = LiveSessionStartWindow(layers.get_layers(),
stage.GetRootLayer().identifier,
None)
await self._create_session("test")
live_session_start_window.visible = True
live_session_start_window.set_focus(True)
await ui_test.human_delay(6)
live_session_start_window.visible = False
await self._close_case()
@MockLiveSyncingApi
async def test_join_session_quick(self):
settings = carb.settings.get_settings()
before = settings.get_as_bool(QUICK_JOIN_ENABLED)
settings.set(QUICK_JOIN_ENABLED, True)
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session_then_leave("test")
await self._expand_live_session_menu(quick_join="test")
self.assertEqual("test", self.get_live_syncing().get_current_live_session().name)
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
settings.set(QUICK_JOIN_ENABLED, before)
await self._close_case()
@MockLiveSyncingApi
async def test_join_session_quick_create(self):
settings = carb.settings.get_settings()
before = settings.get_as_bool(QUICK_JOIN_ENABLED)
settings.set(QUICK_JOIN_ENABLED, True)
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._expand_live_session_menu(quick_join="test")
self.assertEqual("test", self.get_live_syncing().get_current_live_session().name)
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
settings.set(QUICK_JOIN_ENABLED, before)
await self._close_case()
@MockLiveSyncingApi
async def test_join_session_options(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session_then_leave(None)
await self._create_session_then_leave(None)
for i in range(3):
await self._create_session_then_leave(f"test_{i}")
await self._click_live_session_menu_item("Join Session")
frame = ui_test.find("Live Session")
self.assertIsNotNone(frame)
combo_box = ui_test.find("Live Session//Frame/**/ComboBox[0]")
items = combo_box.model.get_item_children(None)
names = [i.session.name for i in items]
carb.log_warn(names)
self.assertIn("Default", names)
self.assertIn("simulated_user_name___01", names)
for i in range(3):
self.assertIn(f"test_{i}", names)
index_of_second_test_usd = names.index('test_1')
self.assertTrue(index_of_second_test_usd > -1)
combo_box.model.get_item_value_model(None, 0).set_value(index_of_second_test_usd)
await ui_test.human_delay(6)
ok_button = ui_test.find(LIVE_SESSION_CONFIRM_BUTTON_PATH)
self.assertIsNotNone(ok_button)
await ok_button.click()
await ui_test.human_delay(6)
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
self.assertEqual("test_1", self.get_live_syncing().get_current_live_session().name)
await self._close_case()
@MockLiveSyncingApi
async def test_menu_item_join_with_session_link_without_stage(self):
self.assertIsNone(stop_or_show_live_session_widget())
await self._close_case()
@MockLiveSyncingApi
async def test_menu_item_join_with_session_link_dialog(self):
await omni.usd.get_context().new_stage_async()
await self._click_live_session_menu_item("Join With Session Link")
frame = ui_test.find("JOIN LIVE SESSION WITH LINK")
self.assertIsNotNone(frame)
cancal_button = ui_test.find(JOIN_LIVE_SESSION_WITH_LINK_CANCEL_BUTTON_PATH)
self.assertIsNotNone(cancal_button)
await cancal_button.click()
await self._close_case()
@MockLiveSyncingApi
async def test_menu_item_copy_session_link(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session("test")
layer = stage.GetRootLayer()
await self._click_live_session_menu_item("Copy Session Link", layer.identifier)
current_session = self.get_live_syncing().get_current_live_session()
live_session_link = omni.kit.clipboard.paste()
self.assertEqual(live_session_link, current_session.shared_link)
await self._close_case()
@MockLiveSyncingApi
async def test_menu_item_share_session_link(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
for i in range(3):
await self._create_session_then_leave(f"test_{i}")
await self._click_live_session_menu_item("Share Session Link")
frame = ui_test.find("SHARE LIVE SESSION LINK")
self.assertIsNotNone(frame)
combo_box = ui_test.find(SHARE_LIVE_SESSION_LINK_COMBO_BOX_PATH)
items = combo_box.model.get_item_children(None)
names = [i.session.name for i in items]
index_of_second_test_usd = -1
for i in range(3):
self.assertIn(f"test_{i}", names)
if names[i] == "test_1":
index_of_second_test_usd = i
self.assertTrue(index_of_second_test_usd > -1)
combo_box.model.get_item_value_model(None, 0).set_value(index_of_second_test_usd)
await ui_test.human_delay(6)
confirm_button = ui_test.find(SHARE_LIVE_SESSION_LINK_CONFIRM_BUTTON_PATH)
await confirm_button.click()
live_session_link = omni.kit.clipboard.paste()
self.assertEqual(live_session_link, items[index_of_second_test_usd].session.shared_link)
await self._close_case()
def _create_test_camera(self, name: str='camera'):
camera_path = f"/{name}"
omni.kit.commands.execute("CreatePrimWithDefaultXform", prim_type="Camera", prim_path=camera_path)
return Sdf.Path(camera_path)
async def _setup_camera_follower_list(self, camera_path, maximum_users=3):
camera = omni.usd.get_context().get_stage().GetPrimAtPath(camera_path)
self.assertIsNotNone(camera)
return LiveSessionCameraFollowerList(omni.usd.get_context(), camera_path, maximum_users=maximum_users)
@MockLiveSyncingApi
async def test_live_session_camera_follower_list(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
camera_path = self._create_test_camera()
camera_follower_list = await self._setup_camera_follower_list(camera_path)
await self._close_case()
async def _bound_camera(self, shared_stage: Usd.Stage, user_id: str, camera_path: Sdf.Path):
if not camera_path:
camera_path = Sdf.Path.emptyPath
camera_path = Sdf.Path(camera_path)
bound_camera_property_path = pl_utils.get_bound_camera_property_path(user_id)
property_spec = pl_utils.get_or_create_property_spec(
shared_stage.GetRootLayer(), bound_camera_property_path,
Sdf.ValueTypeNames.String
)
builtin_camera_name = pl_utils.is_local_builtin_camera(camera_path)
if not builtin_camera_name:
property_spec.default = str(camera_path)
else:
property_spec.default = builtin_camera_name
if builtin_camera_name:
persp_camera = pl_utils.get_user_shared_root_path(user_id).AppendChild(builtin_camera_name)
camera_prim = shared_stage.DefinePrim(persp_camera, "Camera")
await ui_test.human_delay(12)
def _get_shared_stage(self, current_session: layers.LiveSession):
shared_data_stage_url = current_session.url + "/shared_data/users.live"
layer = Sdf.Layer.FindOrOpen(shared_data_stage_url)
if not layer:
layer = Sdf.Layer.CreateNew(shared_data_stage_url)
return Usd.Stage.Open(layer)
async def _follow_user(
self, shared_stage: Usd.Stage, user_id: str, following_user_id: str
):
following_user_property_path = pl_utils.get_following_user_property_path(user_id)
property_spec = pl_utils.get_or_create_property_spec(
shared_stage.GetRootLayer(), following_user_property_path,
Sdf.ValueTypeNames.String
)
property_spec.default = following_user_id
await ui_test.human_delay(6)
def _create_shared_stage(self):
current_session = self.get_live_syncing().get_current_live_session()
self.assertIsNotNone(current_session)
shared_stage = self._get_shared_stage(current_session)
self.assertIsNotNone(shared_stage)
return shared_stage
def _create_users(self, count):
return [f"user_{i}" for i in range(count)]
@MockLiveSyncingApi
async def test_live_session_camera_follower_list_user_join(self):
stage = await self._create_test_usd("test_camera")
usd_context = omni.usd.get_context()
presence_layer = pl.get_presence_layer_interface(usd_context)
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session("test_camera")
stage_url = usd_context.get_stage_url()
presence_layer = pl.get_presence_layer_interface(usd_context)
shared_stage = self._create_shared_stage()
camera_path = self._create_test_camera()
camera_follower_list = await self._setup_camera_follower_list(camera_path)
user_list = LiveSessionUserList(usd_context, stage_url)
users = self._create_users(3)
await self._bound_camera(shared_stage, users[0], camera_path)
for user_id in users:
join_new_simulated_user(user_id, user_id)
await ui_test.human_delay(6)
self.assertIsNotNone(presence_layer.get_bound_camera_prim(users[0]))
user_0 = self._get_user_in_session(users[0])
user_list._LiveSessionUserList__on_follow_user(
0.0,
0.0,
int(carb.input.MouseInput.LEFT_BUTTON),
None,
user_0
)
await ui_test.human_delay(6)
async def right_click_on(user):
user_list._LiveSessionUserList__on_mouse_clicked(
0.0,
0.0,
int(carb.input.MouseInput.RIGHT_BUTTON),
None,
user
)
await ui_test.human_delay(6)
timeline_session = omni.timeline.live_session.get_timeline_session()
self.assertFalse(timeline_session.is_presenter(user_0))
await right_click_on(user_0)
await self._click_on_current_menu("Set as Timeline Presenter")
self.assertTrue(timeline_session.is_presenter(user_0))
await right_click_on(user_0)
await self._click_on_current_menu("Withdraw Timeline Presenter")
self.assertFalse(timeline_session.is_presenter(user_0))
self.assertEqual(users[0], presence_layer.get_following_user_id())
await ui_test.human_delay(600)
for user_id in users:
quit_simulated_user(user_id)
await ui_test.human_delay(6)
await self._close_case()
@MockLiveSyncingApi
async def test_live_session_camera_follower_list_bound_change(self):
stage = await self._create_test_usd("test_camera")
usd_context = omni.usd.get_context()
presence_layer = pl.get_presence_layer_interface(usd_context)
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session("test_camera")
stage_url = usd_context.get_stage_url()
presence_layer = pl.get_presence_layer_interface(usd_context)
shared_stage = self._create_shared_stage()
camera_path_1 = self._create_test_camera("camera1")
camera_path_2 = self._create_test_camera("camera2")
camera_follower_list = await self._setup_camera_follower_list(camera_path_1)
user_list = LiveSessionUserList(usd_context, stage_url)
users = self._create_users(2)
for user_id in users:
join_new_simulated_user(user_id, user_id)
await ui_test.human_delay(6)
await self._bound_camera(shared_stage, users[0], camera_path_1)
await self._bound_camera(shared_stage, users[1], camera_path_2)
await self._bound_camera(shared_stage, users[0], camera_path_2)
await self._bound_camera(shared_stage, users[1], camera_path_1)
for user_id in users:
quit_simulated_user(user_id)
await ui_test.human_delay(6)
await self._close_case()
@MockLiveSyncingApi
async def test_live_session_camera_follower_list_user_join_exceed_maximum(self):
stage = await self._create_test_usd("test_camera")
usd_context = omni.usd.get_context()
presence_layer = pl.get_presence_layer_interface(usd_context)
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session("test_camera")
UI_MAXIMUM_USERS = 3
stage_url = usd_context.get_stage_url()
presence_layer = pl.get_presence_layer_interface(usd_context)
shared_stage = self._create_shared_stage()
camera_path = self._create_test_camera()
camera_follower_list = await self._setup_camera_follower_list(camera_path, maximum_users=UI_MAXIMUM_USERS)
user_list = LiveSessionUserList(usd_context, stage_url)
users = self._create_users(UI_MAXIMUM_USERS + 1)
for user in users:
await self._bound_camera(shared_stage, user, camera_path)
for user_id in users:
join_new_simulated_user(user_id, user_id)
await ui_test.human_delay(6)
for user_id in users:
quit_simulated_user(user_id)
await ui_test.human_delay(6)
await self._close_case()
@MockLiveSyncingApi
async def test_end_and_merge(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session("test")
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
await self._click_live_session_menu_item("End and Merge")
frame = ui_test.find("Merge Options")
self.assertIsNotNone(frame)
combo = ui_test.find(MERGE_OPTIONS_COMBO_BOX_PATH)
combo.model.get_item_value_model(None, 0).set_value(0)
ok_button = ui_test.find(MERGE_OPTIONS_CONFIRM_BUTTON_PATH)
self.assertIsNotNone(ok_button)
await ok_button.click()
await ui_test.human_delay(6)
await self._close_case()
@MockLiveSyncingApi
@MockApiForLiveSessionManagement
async def test_end_and_merge_save_file(self):
self.assertFalse(get_merge_and_stop_live_session_async_called())
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session("test")
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
await self._click_live_session_menu_item("End and Merge")
frame = ui_test.find("Merge Options")
self.assertIsNotNone(frame)
combo = ui_test.find(MERGE_OPTIONS_COMBO_BOX_PATH)
combo.model.get_item_value_model(None, 0).set_value(1)
ok_button = ui_test.find(MERGE_OPTIONS_CONFIRM_BUTTON_PATH)
self.assertIsNotNone(ok_button)
await ok_button.click()
await ui_test.human_delay(6)
self.assertTrue(get_merge_and_stop_live_session_async_called())
await self._close_case()
@MockLiveSyncingApi
async def test_end_and_merge_without_permission(self):
stage = await self._create_test_usd()
await omni.usd.get_context().attach_stage_async(stage)
await self._create_session("test")
current_session = self.get_live_syncing().get_current_live_session()
forbid_session_merge(current_session)
self.assertTrue(self.get_live_syncing().is_stage_in_live_session())
await self._click_live_session_menu_item("End and Merge")
frame = ui_test.find("Permission Denied")
self.assertIsNotNone(frame)
ok_button = ui_test.find(MERGE_PROMPT_LEAVE_BUTTON_PATH)
self.assertIsNotNone(ok_button)
await ok_button.click()
await ui_test.human_delay(6)
await self._close_case()
@MockLiveSyncingApi
async def test_reload_widget_on_layer(self):
stage = await self._create_test_usd("test")
usd_context = omni.usd.get_context()
await usd_context.attach_stage_async(stage)
await self._create_session("test")
layer = stage.GetSessionLayer()
window = omni.ui.Window(title='test_reload')
with window.frame:
reload_widget = build_reload_widget(layer.identifier, usd_context, True, True, False)
self.assertIsNotNone(reload_widget)
reload_widget.visible = True
await ui_test.human_delay(10)
window.width, window.height = 50, 50
reload_button = ui_test.find("test_reload//Frame/**/InvisibleButton[0]")
self.assertIsNotNone(reload_button)
await reload_button.click(right_click=True)
await ui_test.human_delay(6)
item_str_list = self._get_current_menu_item_string_list()
self.assertIn("Auto Reload", item_str_list)
self.assertIn("Reload Layer", item_str_list)
self.assertFalse(layers.get_layers_state(usd_context).is_auto_reload_layer(layer.identifier))
await self._click_on_current_menu("Auto Reload")
self.assertTrue(layers.get_layers_state(usd_context).is_auto_reload_layer(layer.identifier))
await reload_button.click(right_click=True)
await ui_test.human_delay(6)
await self._click_on_current_menu("Auto Reload")
self.assertFalse(layers.get_layers_state(usd_context).is_auto_reload_layer(layer.identifier))
await reload_button.click()
await ui_test.human_delay(6)
await self._close_case()
@MockLiveSyncingApi
@MockApiForLiveSessionManagement
async def test_reload_widget_on_outdated_layer(self):
stage = await self._create_test_usd("test")
usd_context = omni.usd.get_context()
await usd_context.attach_stage_async(stage)
await self._create_session("test")
all_layers = []
for i in range(3):
layer = await self._create_test_sublayer_usd(f"layer_{i}")
self.assertIsNotNone(layer)
all_layers.append(layer)
stage.GetRootLayer().subLayerPaths.append(layer.identifier)
window = omni.ui.Window(title='test_reload')
with window.frame:
reload_widget = build_reload_widget(all_layers[0].identifier, usd_context, True, True, False)
self.assertIsNotNone(reload_widget)
reload_widget.visible = True
await ui_test.human_delay(10)
window.width, window.height = 50, 50
reload_button = ui_test.find("test_reload//Frame/**/InvisibleButton[0]")
self.assertIsNotNone(reload_button)
layer = all_layers[0]
custom_data = layer.customLayerData
custom_data['test'] = random.randint(0, 10000000)
layer.customLayerData = custom_data
layer.Save(True)
await ui_test.human_delay(6)
append_outdated_layers(all_layers[0].identifier)
await reload_button.click()
await ui_test.human_delay(6)
clear_outdated_layers()
await self._close_case()
async def test_live_session_preferences(self):
preferences = register_page(LiveSessionPreferences())
omni.kit.window.preferences.show_preferences_window()
await ui_test.human_delay(6)
label = ui_test.find("Preferences//Frame/**/ScrollingFrame[0]/TreeView[0]/Label[*].text=='Live'")
await label.click()
await ui_test.human_delay(6)
self.assertIsNotNone(preferences._checkbox_quick_join_enabled)
self.assertIsNotNone(preferences._combobox_session_list_select)
await ui_test.human_delay(6)
omni.kit.window.preferences.hide_preferences_window()
unregister_page(preferences)
def _get_user_in_session(self, user_id):
current_session = self.get_live_syncing().get_current_live_session()
session_channel = current_session._session_channel()
return session_channel._peer_users.get(user_id, None)
@MockLiveSyncingApi
async def test_file_picker(self):
temp_dir = tempfile.TemporaryDirectory()
def file_save_handler(file_path: str, overwrite_existing: bool):
prefix = "file:/"
self.assertTrue(file_path.startswith(prefix))
nonlocal called
called = True
def file_open_handler(file_path: str, overwrite_existing: bool):
nonlocal called
called = True
filter_options = [
("(.*?)", "All Files (*.*)"),
]
FILE_PICKER_DIALOG_TITLE = "test file picker"
file_picker = FilePicker(
FILE_PICKER_DIALOG_TITLE,
FileBrowserMode.SAVE,
FileBrowserSelectionType.FILE_ONLY,
filter_options,
)
called = False
file_picker.set_file_selected_fn(file_save_handler)
file_picker.show(temp_dir.name, 'test_file_picker')
await ui_test.human_delay(6)
button = ui_test.find(f"{FILE_PICKER_DIALOG_TITLE}//Frame/**/Button[*].text=='Save'")
self.assertIsNotNone(button)
await button.click()
await ui_test.human_delay(6)
self.assertTrue(called)
file_picker = FilePicker(
FILE_PICKER_DIALOG_TITLE,
FileBrowserMode.OPEN,
FileBrowserSelectionType.FILE_ONLY,
filter_options,
)
called = False
file_picker.set_file_selected_fn(file_open_handler)
file_picker.show(temp_dir.name)
await ui_test.human_delay(6)
button = ui_test.find(f"{FILE_PICKER_DIALOG_TITLE}//Frame/**/Button[*].text=='Open'")
self.assertIsNotNone(button)
await button.click()
await ui_test.human_delay(6)
self.assertTrue(called)
| 32,194 |
Python
| 38.024242 | 135 | 0.647139 |
omniverse-code/kit/exts/omni.kit.widget.live_session_management/docs/CHANGELOG.md
|
# Changelog
Omniverse Kit Shared Live Session Widgets
## [1.1.3] - 2022-11-21
### Changed
- Prompt if layer is outdate or dirty before live.
## [1.1.2] - 2022-10-27
### Changed
- Fix deprecated API warnings.
## [1.1.1] - 2022-10-15
### Changed
- Fix issue to refresh session list.
## [1.1.0] - 2022-09-29
### Changed
- Supports sublayer live session workflow.
## [1.0.6] - 2022-09-02
### Changed
- Add name validator for session name input.
## [1.0.5] - 2022-08-30
### Changed
- Show menu options for join.
## [1.0.4] - 2022-08-25
### Changed
- Notifications for read-only stage.
## [1.0.3] - 2022-08-09
### Changed
- Notify user before quitting application that session is live still.
## [1.0.2] - 2022-07-19
### Changed
- Shows menu still even session is empty when it's not forcely quit.
## [1.0.1] - 2022-06-29
### Changed
- Supports more options to control session menus.
## [1.0.0] - 2022-06-15
### Fixed
- Initialize extension.
| 946 |
Markdown
| 19.148936 | 69 | 0.657505 |
omniverse-code/kit/exts/omni.kit.property.camera/omni/kit/property/camera/scripts/camera_properties.py
|
import os
import carb
import omni.ext
from typing import List
from pathlib import Path
from pxr import Kind, Sdf, Usd, UsdGeom, Vt
from omni.kit.property.usd.usd_property_widget import MultiSchemaPropertiesWidget, UsdPropertyUiEntry
from omni.kit.property.usd.usd_property_widget import create_primspec_token, create_primspec_float, create_primspec_bool, create_primspec_string
TEST_DATA_PATH = ""
class CameraPropertyExtension(omni.ext.IExt):
def __init__(self):
self._registered = False
super().__init__()
def on_startup(self, ext_id):
self._register_widget()
manager = omni.kit.app.get_app().get_extension_manager()
extension_path = manager.get_extension_path(ext_id)
global TEST_DATA_PATH
TEST_DATA_PATH = Path(extension_path).joinpath("data").joinpath("tests")
def on_shutdown(self):
if self._registered:
self._unregister_widget()
def _register_widget(self):
import omni.kit.window.property as p
from omni.kit.window.property.property_scheme_delegate import PropertySchemeDelegate
from . import CameraSchemaAttributesWidget
w = p.get_window()
if w:
w.register_widget(
"prim",
"camera",
CameraSchemaAttributesWidget(
"Camera",
UsdGeom.Camera,
[],
[
"cameraProjectionType",
"fthetaWidth",
"fthetaHeight",
"fthetaCx",
"fthetaCy",
"fthetaMaxFov",
"fthetaPolyA",
"fthetaPolyB",
"fthetaPolyC",
"fthetaPolyD",
"fthetaPolyE",
"fthetaPolyF",
"p0",
"p1",
"s0",
"s1",
"s2",
"s3",
"fisheyeResolutionBudget",
"fisheyeFrontFaceResolutionScale",
"interpupillaryDistance", # Only required for 'omniDirectionalStereo'
"isLeftEye", # Only required for 'omniDirectionalStereo'
"cameraSensorType",
"sensorModelPluginName",
"sensorModelConfig",
"sensorModelSignals",
"crossCameraReferenceName"
],
[],
),
)
self._registered = True
def _unregister_widget(self):
import omni.kit.window.property as p
w = p.get_window()
if w:
w.unregister_widget("prim", "camera")
self._registered = False
class CameraSchemaAttributesWidget(MultiSchemaPropertiesWidget):
def __init__(self, title: str, schema, schema_subclasses: list, include_list: list = [], exclude_list: list = []):
"""
Constructor.
Args:
title (str): Title of the widgets on the Collapsable Frame.
schema: The USD IsA schema or applied API schema to filter attributes.
schema_subclasses (list): list of subclasses
include_list (list): list of additional schema named to add
exclude_list (list): list of additional schema named to remove
"""
super().__init__(title, schema, schema_subclasses, include_list, exclude_list)
# custom attributes
cpt_tokens = Vt.TokenArray(9, ("pinhole", "fisheyeOrthographic", "fisheyeEquidistant", "fisheyeEquisolid", "fisheyePolynomial", "fisheyeSpherical", "fisheyeKannalaBrandtK3", "fisheyeRadTanThinPrism", "omniDirectionalStereo"))
cst_tokens = Vt.TokenArray(4, ("camera", "radar", "lidar", "rtxsensor"))
self.add_custom_schema_attribute("cameraProjectionType", lambda p: p.IsA(UsdGeom.Camera), None, "Projection Type", create_primspec_token(cpt_tokens, "pinhole"))
self.add_custom_schema_attribute("fthetaWidth", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(1936.0))
self.add_custom_schema_attribute("fthetaHeight", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(1216.0))
self.add_custom_schema_attribute("fthetaCx", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(970.942444))
self.add_custom_schema_attribute("fthetaCy", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(600.374817))
self.add_custom_schema_attribute("fthetaMaxFov", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(200.0))
self.add_custom_schema_attribute("fthetaPolyA", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(0.0))
self.add_custom_schema_attribute("fthetaPolyB", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(2.45417095720768e-3))
self.add_custom_schema_attribute("fthetaPolyC", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(3.72747912535942e-8))
self.add_custom_schema_attribute("fthetaPolyD", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(-1.43520517692508e-9))
self.add_custom_schema_attribute("fthetaPolyE", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(9.76061787817672e-13))
self.add_custom_schema_attribute("fthetaPolyF", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(0.0))
self.add_custom_schema_attribute("p0", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(-0.0003672190538065101))
self.add_custom_schema_attribute("p1", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(-0.0007413905358394097))
self.add_custom_schema_attribute("s0", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(-0.0005839984838196491))
self.add_custom_schema_attribute("s1", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(-0.0002193412417918993))
self.add_custom_schema_attribute("s2", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(0.0001936268547567258))
self.add_custom_schema_attribute("s3", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(-0.0002042473404798113))
self.add_custom_schema_attribute("fisheyeResolutionBudget", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(1.5))
self.add_custom_schema_attribute("fisheyeFrontFaceResolutionScale", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(1.0))
self.add_custom_schema_attribute("interpupillaryDistance", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_float(6.4))
self.add_custom_schema_attribute("isLeftEye", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_bool(False))
self.add_custom_schema_attribute("sensorModelPluginName", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_string())
self.add_custom_schema_attribute("sensorModelConfig", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_string())
self.add_custom_schema_attribute("sensorModelSignals", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_string())
self.add_custom_schema_attribute("crossCameraReferenceName", lambda p: p.IsA(UsdGeom.Camera), None, "", create_primspec_string())
self.add_custom_schema_attribute("cameraSensorType", lambda p: p.IsA(UsdGeom.Camera), None, "Sensor Type", create_primspec_token(cst_tokens, "camera"))
def on_new_payload(self, payload):
"""
See PropertyWidget.on_new_payload
"""
if not super().on_new_payload(payload):
return False
if not self._payload or len(self._payload) == 0:
return False
used = []
for prim_path in self._payload:
prim = self._get_prim(prim_path)
if not prim or not prim.IsA(self._schema):
return False
used += [attr for attr in prim.GetAttributes() if attr.GetName() in self._schema_attr_names and not attr.IsHidden()]
camProjTypeAttr = prim.GetAttribute("cameraProjectionType")
if prim.IsA(UsdGeom.Camera) and camProjTypeAttr.GetTypeName() == Sdf.ValueTypeNames.Token:
tokens = camProjTypeAttr.GetMetadata("allowedTokens")
if not tokens:
camProjTypeAttr.SetMetadata("allowedTokens", ["pinhole", "fisheyeOrthographic", "fisheyeEquidistant", "fisheyeEquisolid", "fisheyePolynomial", "fisheyeSpherical", "fisheyeKannalaBrandtK3", "fisheyeRadTanThinPrism", "omniDirectionalStereo"])
if self.is_custom_schema_attribute_used(prim):
used.append(None)
camSensorTypeAttr = prim.GetAttribute("cameraSensorType")
if prim.IsA(UsdGeom.Camera) and camSensorTypeAttr.GetTypeName() == Sdf.ValueTypeNames.Token:
tokens = camSensorTypeAttr.GetMetadata("allowedTokens")
if not tokens:
camSensorTypeAttr.SetMetadata("allowedTokens", ["camera", "radar", "lidar", "rtxsensor"])
return used
def _customize_props_layout(self, attrs):
from omni.kit.property.usd.custom_layout_helper import (
CustomLayoutFrame,
CustomLayoutGroup,
CustomLayoutProperty,
)
from omni.kit.window.property.templates import (
SimplePropertyWidget,
LABEL_WIDTH,
LABEL_HEIGHT,
HORIZONTAL_SPACING,
)
self.add_custom_schema_attributes_to_props(attrs)
anchor_prim = self._get_prim(self._payload[-1])
frame = CustomLayoutFrame(hide_extra=False)
with frame:
with CustomLayoutGroup("Lens"):
CustomLayoutProperty("focalLength", "Focal Length")
CustomLayoutProperty("focusDistance", "Focus Distance")
CustomLayoutProperty("fStop", "fStop")
CustomLayoutProperty("projection", "Projection")
CustomLayoutProperty("stereoRole", "Stereo Role")
with CustomLayoutGroup("Horizontal Aperture"):
CustomLayoutProperty("horizontalAperture", "Aperture")
CustomLayoutProperty("horizontalApertureOffset", "Offset")
with CustomLayoutGroup("Vertical Aperture"):
CustomLayoutProperty("verticalAperture", "Aperture")
CustomLayoutProperty("verticalApertureOffset", "Offset")
with CustomLayoutGroup("Clipping"):
CustomLayoutProperty("clippingPlanes", "Clipping Planes")
CustomLayoutProperty("clippingRange", "Clipping Range")
with CustomLayoutGroup("Fisheye Lens", collapsed=True):
CustomLayoutProperty("cameraProjectionType", "Projection Type")
CustomLayoutProperty("fthetaWidth", "Nominal Width")
CustomLayoutProperty("fthetaHeight", "Nominal Height")
CustomLayoutProperty("fthetaCx", "Optical Center X")
CustomLayoutProperty("fthetaCy", "Optical Center Y")
CustomLayoutProperty("fthetaMaxFov", "Max FOV")
CustomLayoutProperty("fthetaPolyA", "Poly k0")
CustomLayoutProperty("fthetaPolyB", "Poly k1")
CustomLayoutProperty("fthetaPolyC", "Poly k2")
CustomLayoutProperty("fthetaPolyD", "Poly k3")
CustomLayoutProperty("fthetaPolyE", "Poly k4")
CustomLayoutProperty("fthetaPolyF", "Poly k5")
CustomLayoutProperty("p0", "p0")
CustomLayoutProperty("p1", "p1")
CustomLayoutProperty("s0", "s0")
CustomLayoutProperty("s1", "s1")
CustomLayoutProperty("s2", "s2")
CustomLayoutProperty("s3", "s3")
CustomLayoutProperty("fisheyeResolutionBudget", "Max Fisheye Resolution (% of Viewport Resolution")
CustomLayoutProperty("fisheyeFrontFaceResolutionScale", "Front Face Resolution Scale")
CustomLayoutProperty("interpupillaryDistance", "Interpupillary Distance (cm)")
CustomLayoutProperty("isLeftEye", "Is left eye")
with CustomLayoutGroup("Shutter", collapsed=True):
CustomLayoutProperty("shutter:open", "Open")
CustomLayoutProperty("shutter:close", "Close")
with CustomLayoutGroup("Sensor Model", collapsed=True):
CustomLayoutProperty("cameraSensorType", "Sensor Type")
CustomLayoutProperty("sensorModelPluginName", "Sensor Plugin Name")
CustomLayoutProperty("sensorModelConfig", "Sensor Config")
CustomLayoutProperty("sensorModelSignals", "Sensor Signals")
with CustomLayoutGroup("Synthetic Data Generation", collapsed=True):
CustomLayoutProperty("crossCameraReferenceName", "Cross Camera Reference")
return frame.apply(attrs)
def get_additional_kwargs(self, ui_prop: UsdPropertyUiEntry):
"""
Override this function if you want to supply additional arguments when building the label or ui widget.
"""
additional_widget_kwargs = None
if ui_prop.prop_name == "fisheyeResolutionBudget":
additional_widget_kwargs = {"min": 0, "max": 10}
if ui_prop.prop_name == "fisheyeFrontFaceResolutionScale":
additional_widget_kwargs = {"min": 0, "max": 10}
return None, additional_widget_kwargs
| 14,637 |
Python
| 57.087301 | 260 | 0.581813 |
omniverse-code/kit/exts/omni.kit.property.camera/omni/kit/property/camera/scripts/__init__.py
|
from .camera_properties import *
| 33 |
Python
| 15.999992 | 32 | 0.787879 |
omniverse-code/kit/exts/omni.kit.property.camera/omni/kit/property/camera/tests/__init__.py
|
from .test_camera import *
from .test_prim_edits_and_auto_target import *
| 74 |
Python
| 23.999992 | 46 | 0.756757 |
omniverse-code/kit/exts/omni.kit.property.camera/omni/kit/property/camera/tests/test_prim_edits_and_auto_target.py
|
## Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import os
import carb
import omni.kit.app
import omni.kit.commands
import omni.kit.test
import omni.ui as ui
from omni.ui.tests.test_base import OmniUiTest
from pxr import Kind, Sdf, Gf, Usd
class TestPrimEditsAndAutoTarget(omni.kit.test.AsyncTestCase):
def __init__(self, tests=()):
super().__init__(tests)
# Before running each test
async def setUp(self):
self._usd_context = omni.usd.get_context()
await self._usd_context.new_stage_async()
self._stage = self._usd_context.get_stage()
from omni.kit.test_suite.helpers import arrange_windows
await arrange_windows(topleft_window="Property", topleft_height=64, topleft_width=800.0)
await self.wait()
# After running each test
async def tearDown(self):
from omni.kit.test_suite.helpers import wait_stage_loading
await wait_stage_loading()
async def wait(self, updates=3):
for i in range(updates):
await omni.kit.app.get_app().next_update_async()
async def test_built_in_camera_editing(self):
from omni.kit.test_suite.helpers import select_prims, wait_stage_loading
from omni.kit import ui_test
# wait for material to load & UI to refresh
await wait_stage_loading()
prim_path = "/OmniverseKit_Persp"
await select_prims([prim_path])
# Loading all inputs
await self.wait()
all_widgets = ui_test.find_all("Property//Frame/**/.identifier!=''")
self.assertNotEqual(all_widgets, [])
for w in all_widgets:
id = w.widget.identifier
if id.startswith("float_slider_"):
w.widget.scroll_here_y(0.5)
await ui_test.human_delay()
await w.input(str(0.3456))
await ui_test.human_delay()
elif id.startswith("integer_slider_"):
w.widget.scroll_here_y(0.5)
attr = self._stage.GetPrimAtPath(prim_path).GetAttribute(id[15:])
await ui_test.human_delay()
old_value = attr.Get()
new_value = old_value + 1
await w.input(str(new_value))
await ui_test.human_delay()
elif id.startswith("drag_per_channel_int"):
w.widget.scroll_here_y(0.5)
await ui_test.human_delay()
sub_widgets = w.find_all("**/IntSlider[*]")
if sub_widgets == []:
sub_widgets = w.find_all("**/IntDrag[*]")
self.assertNotEqual(sub_widgets, [])
for child in sub_widgets:
child.model.set_value(0)
await child.input("9999")
await ui_test.human_delay()
elif id.startswith("drag_per_channel_"):
w.widget.scroll_here_y(0.5)
await ui_test.human_delay()
sub_widgets = w.find_all("**/FloatSlider[*]")
if sub_widgets == []:
sub_widgets = w.find_all("**/FloatDrag[*]")
self.assertNotEqual(sub_widgets, [])
for child in sub_widgets:
await child.input("0.12345")
await self.wait()
elif id.startswith("bool_"):
w.widget.scroll_here_y(0.5)
attr = self._stage.GetPrimAtPath(prim_path).GetAttribute(id[5:])
await ui_test.human_delay()
old_value = attr.Get()
new_value = not old_value
w.widget.model.set_value(new_value)
elif id.startswith("sdf_asset_"):
w.widget.scroll_here_y(0.5)
await ui_test.human_delay()
new_value = "testpath/abc.png"
w.widget.model.set_value(new_value)
await ui_test.human_delay()
# All property edits to built-in cameras should be retargeted into session layer.
root_layer = self._stage.GetRootLayer()
prim_spec = root_layer.GetPrimAtPath("/OmniverseKit_Persp")
self.assertTrue(bool(prim_spec))
| 4,561 |
Python
| 39.371681 | 96 | 0.578163 |
omniverse-code/kit/exts/omni.kit.property.camera/omni/kit/property/camera/tests/test_camera.py
|
## Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.app
import omni.kit.commands
import omni.kit.test
import omni.ui as ui
from omni.kit import ui_test
from omni.ui.tests.test_base import OmniUiTest
from pxr import Kind, Sdf, Gf
import pathlib
class TestCameraWidget(OmniUiTest):
# Before running each test
async def setUp(self):
await super().setUp()
from omni.kit.property.camera.scripts.camera_properties import TEST_DATA_PATH
self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute()
self._usd_path = TEST_DATA_PATH.absolute()
from omni.kit.property.usd.usd_attribute_widget import UsdPropertiesWidget
import omni.kit.window.property as p
self._w = p.get_window()
# After running each test
async def tearDown(self):
await super().tearDown()
async def test_camera_ui(self):
usd_context = omni.usd.get_context()
await self.docked_test_window(
window=self._w._window,
width=450,
height=675,
restore_window = ui.Workspace.get_window("Layer") or ui.Workspace.get_window("Stage"),
restore_position = ui.DockPosition.BOTTOM)
test_file_path = self._usd_path.joinpath("camera_test.usda").absolute()
await usd_context.open_stage_async(str(test_file_path))
await omni.kit.app.get_app().next_update_async()
# Select the prim.
usd_context.get_selection().set_selected_prim_paths(["/World/Camera"], True)
# Need to wait for an additional frames for omni.ui rebuild to take effect
await ui_test.human_delay(10)
await self.finalize_test(golden_img_dir=self._golden_img_dir, golden_img_name="test_camera_ui.png")
| 2,162 |
Python
| 35.661016 | 107 | 0.691489 |
omniverse-code/kit/exts/omni.kit.property.camera/docs/CHANGELOG.md
|
# Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.0.3] - 2021-02-19
### Changes
- Added UI test
## [1.0.2] - 2020-12-09
### Changes
- Added extension icon
- Added readme
- Updated preview image
## [1.0.1] - 2020-10-22
### Changes
- Improved layout
## [1.0.0] - 2020-09-17
### Changes
- Created
| 348 |
Markdown
| 14.863636 | 80 | 0.632184 |
omniverse-code/kit/exts/omni.kit.property.camera/docs/README.md
|
# omni.kit.property.camera
## Introduction
Property window extensions are for viewing and editing Usd Prim Attributes
## This extension supports editing of these Usd Types;
- UsdGeom.Camera
| 195 |
Markdown
| 16.81818 | 74 | 0.784615 |
omniverse-code/kit/exts/omni.rtx.multinode.dev/config/extension.toml
|
[package]
title = "RTX Multi-Node Prototype"
description="Developer prototype controls for RTX multi-node rendering."
authors = ["NVIDIA"]
version = "0.1.0"
category = "Rendering"
keywords = ["kit", "rtx", "rendering", "multi-node"]
repository = ""
[dependencies]
"omni.gpu_foundation" = {}
"omni.graph.core" = {}
"omni.physx.bundle" = {}
"omni.physx.flatcache" = {}
[[python.module]]
name = "omni.rtx.multinode.dev"
[[test]]
waiver = "Extension is tested externally"
| 471 |
TOML
| 21.476189 | 72 | 0.685775 |
omniverse-code/kit/exts/omni.rtx.multinode.dev/omni/rtx/multinode/dev/multinode.py
|
import traceback
import uuid
import carb
import carb.settings
import omni.ext
import omni.ui as ui
import omni.gpu_foundation_factory
import omni.client
from random import random
import math
from omni.physx.scripts import physicsUtils
from pxr import UsdLux, UsdGeom, Gf, UsdPhysics
def print_exception(exc_info):
print(f"===== Exception: {exc_info[0]}, {exc_info[1]}. Begin Stack Trace =====")
traceback.print_tb(exc_info[2])
print("===== End Stack Trace ===== ")
class Extension(omni.ext.IExt):
def on_startup(self):
# Obtain multi process info
gpu = omni.gpu_foundation_factory.get_gpu_foundation_factory_interface()
processIndex = gpu.get_process_index()
processCount = gpu.get_process_count()
# Settings
self._settings = carb.settings.get_settings()
self._settings.set("/persistent/physics/updateToUsd", False)
self._settings.set("/persistent/physics/updateVelocitiesToUsd", False)
self._settings.set("/persistent/omnihydra/useFastSceneDelegate", True)
self._settings.set("/app/renderer/sleepMsOutOfFocus", 0)
if processIndex > 0:
self._settings.set("/app/window/title", "Kit Worker {} //".format(processIndex))
# UI
self._window = ui.Window("RTX Multi-Node Prototype", dockPreference=ui.DockPreference.LEFT_BOTTOM)
self._window.deferred_dock_in("Console", ui.DockPolicy.CURRENT_WINDOW_IS_ACTIVE)
with self._window.frame:
with omni.ui.HStack(height=0):
omni.ui.Spacer(width=6)
with omni.ui.VStack(height=0):
omni.ui.Spacer(height=10)
with omni.ui.HStack(height=0):
if processIndex == 0:
omni.ui.Label("Master process of {}".format(processCount))
else:
omni.ui.Label("Worker process {} of {}".format(processIndex, processCount))
if processIndex == 0:
omni.ui.Spacer(height=20)
with omni.ui.HStack():
with omni.ui.VStack(height=0):
omni.ui.Label("Settings")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=10)
with omni.ui.VStack(width = 200, height = 0):
with omni.ui.HStack():
omni.ui.Label("Fabric Replication")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/flatcacheReplication/enabled"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/flatcacheReplication/enabled", a.get_value_as_bool()))
omni.ui.Label("Enabled")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/flatcacheReplication/profile"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/flatcacheReplication/profile", a.get_value_as_bool()))
omni.ui.Label("Profile")
omni.ui.Spacer(height=10)
with omni.ui.HStack():
omni.ui.Label("Gather Render Results")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/gatherResults/enabled"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/gatherResults/enabled", a.get_value_as_bool()))
omni.ui.Label("Enabled")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/gatherResults/profile"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/gatherResults/profile", a.get_value_as_bool()))
omni.ui.Label("Profile")
with omni.ui.VStack(width = 200, height=0):
with omni.ui.HStack():
omni.ui.Label("Render Product Replication")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/renderProductReplication/enabled"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/renderProductReplication/enabled", a.get_value_as_bool()))
omni.ui.Label("Enabled")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/renderProductReplication/includeCameraAttributes"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/renderProductReplication/includeCameraAttributes", a.get_value_as_bool()))
omni.ui.Label("Include Camera Attributes")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/renderProductReplication/fullSessionLayer"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/renderProductReplication/fullSessionLayer", a.get_value_as_bool()))
omni.ui.Label("Full Session Layer")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/renderProductReplication/profile"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/renderProductReplication/profile", a.get_value_as_bool()))
omni.ui.Label("Profile")
omni.ui.Spacer(height=5)
with omni.ui.HStack():
omni.ui.Spacer(width=20)
box = omni.ui.CheckBox(width = 22)
box.model.set_value(self._settings.get("/multiNode/renderProductReplication/print"))
box.model.add_value_changed_fn(lambda a: self._settings.set("/multiNode/renderProductReplication/print", a.get_value_as_bool()))
omni.ui.Label("Print")
omni.ui.Spacer(width=200)
with omni.ui.VStack(height=0):
omni.ui.Label("Deprecated: Physics prototype")
omni.ui.Spacer(height=10)
with omni.ui.HStack(height=0):
load_button = omni.ui.Button("Load Stage", width=150, height=30)
load_button.set_clicked_fn(self._on_load_button_fn)
omni.ui.Spacer(height=5)
with omni.ui.HStack(height=0):
self._numBoxesDrag = omni.ui.IntDrag(min = 1, max = 1000000, step = 1, width = 100)
self._numBoxesDrag.model.set_value(1000)
omni.ui.Spacer(width=10)
omni.ui.Label("Boxes")
omni.ui.Spacer(height=5)
with omni.ui.HStack(height=0):
init_button = omni.ui.Button("Init Simulation", width=150, height=30)
init_button.set_clicked_fn(self._on_init_button_fn)
omni.ui.Spacer(height=5)
with omni.ui.HStack(height=0):
play_button = omni.ui.Button("Play Simulation", width=150, height=30)
play_button.set_clicked_fn(self._on_play_button_fn)
omni.ui.Spacer()
def on_shutdown(self):
pass
def _on_load_button_fn(self):
carb.log_warn("Load stage")
srcPath = "omniverse://content.ov.nvidia.com/Users/[email protected]/multi-node/empty.usd"
dstPath = "omniverse://content.ov.nvidia.com/Users/[email protected]/multi-node/gen/" + str(uuid.uuid4()) + ".usd"
# Create a temporary copy
try:
result = omni.client.copy(srcPath, dstPath, omni.client.CopyBehavior.OVERWRITE)
if result != omni.client.Result.OK:
carb.log_error(f"Cannot copy from {srcPath} to {dstPath}, error code: {result}.")
else:
carb.log_warn(f"Copied from {srcPath} to {dstPath}.")
except Exception as e:
traceback.print_exc()
carb.log_error(str(e))
# Load the temporary copy
omni.usd.get_context().open_stage(str(dstPath))
# FIXME: Add compatible API for legacy usage.
# Enable live sync
# omni.usd.get_context().set_stage_live(layers.LayerLiveMode.ALWAYS_ON)
def _on_init_button_fn(self):
carb.log_warn("Init simulation")
# Disable FlatCache replication
self._settings.set("/multiNode/flatcacheReplication/enabled", False)
# set up axis to z
stage = omni.usd.get_context().get_stage()
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
UsdGeom.SetStageMetersPerUnit(stage, 0.01)
# Disable default light
defaultPrimPath = str(stage.GetDefaultPrim().GetPath())
stage.RemovePrim(defaultPrimPath + "/defaultLight")
# light
sphereLight = UsdLux.SphereLight.Define(stage, defaultPrimPath + "/SphereLight")
sphereLight.CreateRadiusAttr(30)
sphereLight.CreateIntensityAttr(50000)
sphereLight.AddTranslateOp().Set(Gf.Vec3f(0.0, 0.0, 150.0))
# Boxes
numBoxes = self._numBoxesDrag.model.get_value_as_int()
size = 25.0
radius = 100.0
self._boxes = [None] * numBoxes
for i in range(numBoxes):
box = UsdGeom.Cube.Define(stage, defaultPrimPath + "/box_" + str(i))
box.CreateSizeAttr(size)
box.CreateExtentAttr([(-size / 2, -size / 2, -size / 2), (size / 2, size / 2, size / 2)])
box.AddTranslateOp().Set(Gf.Vec3f(radius * math.cos(0.5 * i), radius * math.sin(0.5 * i), size + (i * 0.2) * size))
box.AddOrientOp().Set(Gf.Quatf(random(), random(), random(), random()).GetNormalized())
box.CreateDisplayColorAttr().Set([Gf.Vec3f(random(), random(), random())])
self._boxes[i] = box.GetPrim()
# Plane
planeActorPath = defaultPrimPath + "/plane"
size = 1500.0
planeGeom = UsdGeom.Cube.Define(stage, planeActorPath)
self._plane = stage.GetPrimAtPath(planeActorPath)
planeGeom.CreateSizeAttr(size)
planeGeom.CreateExtentAttr([(-size / 2, -size / 2, -size / 2), (size / 2, size / 2, size / 2)])
planeGeom.AddTranslateOp().Set(Gf.Vec3f(0.0, 0.0, 0.0))
planeGeom.AddOrientOp().Set(Gf.Quatf(1.0))
planeGeom.AddScaleOp().Set(Gf.Vec3f(1.0, 1.0, 0.01))
planeGeom.CreateDisplayColorAttr().Set([Gf.Vec3f(0.5)])
def _on_play_button_fn(self):
carb.log_warn("Play simulation")
# FIXME: Add compatible API for legacy usage.
# Disable live sync
# omni.usd.get_context().set_stage_live(layers.LayerLiveMode.TOGGLE_OFF)
# Enable FlatCache replication
self._settings.set("/multiNode/flatcacheReplication/enabled", True)
# Add physics to scene
stage = omni.usd.get_context().get_stage()
defaultPrimPath = str(stage.GetDefaultPrim().GetPath())
scene = UsdPhysics.Scene.Define(stage, defaultPrimPath + "/physicsScene")
scene.CreateGravityDirectionAttr().Set(Gf.Vec3f(0.0, 0.0, -1.0))
scene.CreateGravityMagnitudeAttr().Set(981.0)
for box in self._boxes:
UsdPhysics.CollisionAPI.Apply(box)
physicsAPI = UsdPhysics.RigidBodyAPI.Apply(box)
UsdPhysics.MassAPI.Apply(box)
UsdPhysics.CollisionAPI.Apply(self._plane)
# Play animation
omni.timeline.get_timeline_interface().play()
| 14,830 |
Python
| 53.127737 | 190 | 0.494066 |
omniverse-code/kit/exts/omni.rtx.multinode.dev/omni/rtx/multinode/dev/__init__.py
|
from .multinode import *
| 25 |
Python
| 11.999994 | 24 | 0.76 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/omni/kit/collaboration/selection_outline/extension.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import carb
import omni.ext
from .stage_listener import StageListener
_global_instance = None
class SelectionOutlineExtension(omni.ext.IExt):
def on_startup(self):
global _global_instance
_global_instance = self
self._stage_listener = StageListener()
self._stage_listener.start()
def on_shutdown(self):
global _global_instance
_global_instance = None
self._stage_listener.stop()
@staticmethod
def _get_instance():
global _global_instance
return _global_instance
| 989 |
Python
| 28.999999 | 76 | 0.723964 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/omni/kit/collaboration/selection_outline/stage_listener.py
|
import asyncio
import carb
import omni.client
import omni.usd
import omni.kit.usd.layers as layers
import omni.kit.collaboration.presence_layer as pl
from omni.kit.async_engine import run_coroutine
from .manipulator import PeerUserList
from pxr import Sdf, Usd, UsdGeom, Tf, Trace
from typing import Dict, List, Union
SETTING_MULTI_USER_OUTLINE = "/app/viewport/multiUserOutlineMode"
SETTING_SAVED_OUTLINE_COLOR = "/persistent/app/viewport/live_session/saved_outline_color"
SETTING_OUTLINE_COLOR = "/persistent/app/viewport/outline/color"
SETTING_MAXIMUM_SELECTION_ICONS_PER_USER = "/exts/omni/kit/collaboration/selection_outline/maximum_selection_icons_per_user"
class MultiUserSelectionOutlineManager:
def __init__(self, usd_context: omni.usd.UsdContext) -> None:
self.__usd_context = usd_context
self.__settings = carb.settings.get_settings()
self.__user_last_selected_prims = {}
self.__prim_selection_queue = {}
self.__user_selection_group = {}
self.__selection_group_pool = []
self.__prim_viewport_widget = {}
self._delay_refresh_task_or_future = None
def clear_all_selection(self):
self.__user_last_selected_prims = {}
self.__prim_selection_queue = {}
self.__user_selection_group = {}
for widget in self.__prim_viewport_widget.values():
widget.destroy()
self.__prim_viewport_widget = {}
if self._delay_refresh_task_or_future:
self._delay_refresh_task_or_future.cancel()
self._delay_refresh_task_or_future = None
def clear_selection(self, user_id):
"""Deregister user from selection group."""
selection_group = self.__user_selection_group.pop(user_id, None)
if selection_group:
self.__update_selection_outline_internal(user_id, selection_group, {})
# Returns selection group to re-use as it supports 255 at maximum due to limitation of renderer.
self.__selection_group_pool.append(selection_group)
def on_usd_objects_changed(self, notice):
stage = self.__usd_context.get_stage()
to_remove_paths = []
to_update_paths = []
for widget_path, widget in self.__prim_viewport_widget.items():
prim = stage.GetPrimAtPath(widget_path)
if not prim or not prim.IsActive() or not prim.IsDefined():
to_remove_paths.append(widget_path)
elif notice.ResyncedObject(prim):
to_update_paths.append(widget_path)
else:
changed_info_only_paths = notice.GetChangedInfoOnlyPaths()
slice_object = Sdf.Path.FindPrefixedRange(changed_info_only_paths, widget_path)
if not slice_object:
continue
paths = changed_info_only_paths[slice_object]
if not paths:
continue
for path in paths:
if UsdGeom.Xformable.IsTransformationAffectedByAttrNamed(path.name):
to_update_paths.append(widget_path)
break
for path in to_remove_paths:
widget = self.__prim_viewport_widget.pop(path, None)
widget.destroy()
for path in to_update_paths:
widget = self.__prim_viewport_widget.get(path, None)
widget.on_transform_changed()
def refresh_selection(self, selection_paths: List[Sdf.Path]):
"""
Calls this to refresh selection. This is normally called after selection changed, which will
override the outline of remote users.
"""
if not selection_paths:
return
for path in selection_paths:
self.__set_prim_outline(0, path)
async def delay_refresh(paths):
await omni.kit.app.get_app().next_update_async()
for path in paths:
selection_queue = self.__get_selection_queue(path)
for _, group in selection_queue.items():
self.__set_prim_outline(group, path)
break
self._delay_refresh_task_or_future = None
if self._delay_refresh_task_or_future and not self._delay_refresh_task_or_future.done():
self._delay_refresh_task_or_future.cancel()
self._delay_refresh_task_or_future = run_coroutine(delay_refresh(selection_paths))
def update_selection_outline(self, user_info: layers.LiveSessionUser, selection_paths: List[Sdf.Path]):
user_id = user_info.user_id
selection_group = self.__user_selection_group.get(user_id, None)
if not selection_group:
# Re-use selection group.
if self.__selection_group_pool:
selection_group = self.__selection_group_pool.pop(0)
else:
selection_group = self.__usd_context.register_selection_group()
self.__user_selection_group[user_id] = selection_group
# RGBA
color = (
user_info.user_color[0] / 255.0,
user_info.user_color[1] / 255.0,
user_info.user_color[2] / 255.0,
1.0
)
self.__usd_context.set_selection_group_outline_color(selection_group, color)
self.__usd_context.set_selection_group_shade_color(selection_group, (0.0, 0.0, 0.0, 0.0))
if selection_group == 0:
carb.log_error("The maximum number (255) of selection groups is reached.")
return
selection_paths = [Sdf.Path(path) for path in selection_paths]
selection_paths = Sdf.Path.RemoveDescendentPaths(selection_paths)
stage = self.__usd_context.get_stage()
# Find all renderable prims
all_renderable_prims = {}
for path in selection_paths:
prim = stage.GetPrimAtPath(path)
if not prim:
continue
renderable_prims = []
for prim in Usd.PrimRange(prim, Usd.TraverseInstanceProxies(Usd.PrimAllPrimsPredicate)):
# Camera in Kit has special representation, which needs to be excluded.
if (
not prim.IsActive()
or omni.usd.editor.is_hide_in_ui(prim)
or omni.usd.editor.is_hide_in_stage_window(prim)
):
break
if (
not prim.GetPath().name == "CameraModel"
and not prim.GetPath().GetParentPath().name == "OmniverseKitViewportCameraMesh"
and prim.IsA(UsdGeom.Gprim)
):
renderable_prims.append(prim.GetPath())
if renderable_prims:
all_renderable_prims[path] = renderable_prims
selection_paths = all_renderable_prims
# Draw user icon
maximum_count = self.__settings.get(SETTING_MAXIMUM_SELECTION_ICONS_PER_USER)
if not maximum_count or maximum_count <= 0:
maximum_count = 3
for index, path in enumerate(selection_paths.keys()):
path = Sdf.Path(path)
widget = self.__prim_viewport_widget.get(path, None)
if not widget:
widget = PeerUserList(self.__usd_context, path)
self.__prim_viewport_widget[path] = widget
widget.add_user(user_info)
# OMFP-2736: Don't show all selections to avoid cluttering the viewport.
if index + 1 >= maximum_count:
break
self.__update_selection_outline_internal(user_id, selection_group, selection_paths)
def __update_selection_outline_internal(
self, user_id, selection_group,
all_renderable_paths: Dict[Sdf.Path, List[Sdf.Path]]
):
last_selected_prim_and_renderable_paths = self.__user_last_selected_prims.get(user_id, {})
last_selected_prim_paths = set(last_selected_prim_and_renderable_paths.keys())
selection_paths = set(all_renderable_paths.keys())
if last_selected_prim_paths == selection_paths:
return
if last_selected_prim_paths:
old_selected_paths = last_selected_prim_paths.difference(selection_paths)
new_selected_paths = selection_paths.difference(last_selected_prim_paths)
else:
old_selected_paths = set()
new_selected_paths = selection_paths
# Update selection outline for old paths
to_clear_paths = []
for path in old_selected_paths:
# Remove user icon
widget = self.__prim_viewport_widget.get(path, None)
if widget:
widget.remove_user(user_id)
if widget.empty_user_list():
self.__prim_viewport_widget.pop(path, None)
widget.destroy()
# Remove outline of all renderable prims under the selected path.
renderable_paths = last_selected_prim_and_renderable_paths.get(path, None)
for renderable_path in renderable_paths:
selection_queue = self.__get_selection_queue(renderable_path)
if selection_queue:
# FIFO queue that first user that selects the prim decides the color of selection.
group = next(iter(selection_queue.values()))
same_group = selection_group == group
# Pop this user and outline the prim with next user's selection color.
selection_queue.pop(user_id, None)
if same_group and selection_queue:
for _, group in selection_queue.items():
self.__set_prim_outline(group, renderable_path)
break
elif same_group:
to_clear_paths.append(renderable_path)
# Update selection outline for new paths
to_select_paths = []
for path in new_selected_paths:
renderable_paths = all_renderable_paths.get(path, None)
if not renderable_paths:
continue
for renderable_path in renderable_paths:
selection_queue = self.__get_selection_queue(renderable_path)
has_outline = not not selection_queue
selection_queue[user_id] = selection_group
if not has_outline:
to_select_paths.append(renderable_path)
if to_clear_paths:
self.__clear_prim_outline(to_clear_paths)
if to_select_paths:
self.__set_prim_outline(selection_group, to_select_paths)
self.__user_last_selected_prims[user_id] = all_renderable_paths
def __get_selection_queue(self, prim_path):
prim_path = Sdf.Path(prim_path)
if prim_path not in self.__prim_selection_queue:
# Value is dict to keep order of insertion.
self.__prim_selection_queue[prim_path] = {}
return self.__prim_selection_queue[prim_path]
def __set_prim_outline(self, selection_group, prim_path: Union[Sdf.Path, List[Sdf.Path]]):
if isinstance(prim_path, list):
paths = [str(path) for path in prim_path]
else:
paths = [str(prim_path)]
selection = self.__usd_context.get_selection().get_selected_prim_paths()
for path in paths:
# If it's locally selected, don't override the outline.
if path in selection:
continue
self.__usd_context.set_selection_group(selection_group, path)
def __clear_prim_outline(self, prim_path: Union[Sdf.Path, List[Sdf.Path]]):
self.__set_prim_outline(0, prim_path)
class StageListener:
def __init__(self, usd_context_name=""):
self.__usd_context = omni.usd.get_context(usd_context_name)
self.__presence_layer = pl.get_presence_layer_interface(self.__usd_context)
self.__live_syncing = layers.get_live_syncing(self.__usd_context)
self.__layers = layers.get_layers(self.__usd_context)
self.__layers_event_subscriptions = []
self.__stage_event_subscription = None
self.__settings = carb.settings.get_settings()
self.__selection_paths_initialized = False
self.__stage_objects_changed = None
self.__multi_user_selection_manager = MultiUserSelectionOutlineManager(self.__usd_context)
self.__delayed_task_or_future = None
self.__changed_user_ids = set()
def start(self):
self.__restore_local_outline_color()
for event in [
layers.LayerEventType.LIVE_SESSION_STATE_CHANGED,
layers.LayerEventType.LIVE_SESSION_USER_JOINED,
layers.LayerEventType.LIVE_SESSION_USER_LEFT,
pl.PresenceLayerEventType.SELECTIONS_CHANGED,
]:
layers_event_sub = self.__layers.get_event_stream().create_subscription_to_pop_by_type(
event, self.__on_layers_event, name=f"omni.kit.collaboration.selection_outline {str(event)}"
)
self.__layers_event_subscriptions.append(layers_event_sub)
self.__stage_event_subscription = self.__usd_context.get_stage_event_stream().create_subscription_to_pop(
self.__on_stage_event, name="omni.kit.collaboration.selection_outline stage event"
)
self.__start_subscription()
def __start_subscription(self):
self.__settings.set(SETTING_MULTI_USER_OUTLINE, True)
live_session = self.__live_syncing.get_current_live_session()
if not live_session:
return
for peer_user in live_session.peer_users:
selection_paths = self.__presence_layer.get_selections(peer_user.user_id)
self.__multi_user_selection_manager.update_selection_outline(peer_user, selection_paths)
if not self.__selection_paths_initialized:
self.__selection_paths_initialized = True
selection = self.__usd_context.get_selection().get_selected_prim_paths()
self.__on_selection_changed(selection)
root_layer_session = self.__live_syncing.get_current_live_session()
if root_layer_session:
logged_user = root_layer_session.logged_user
user_color = logged_user.user_color
rgba = (user_color[0] / 255.0, user_color[1] / 255.0, user_color[2] / 255.0, 1.0)
self.__save_and_set_local_outline_color(rgba)
self.__stage_objects_changed = Tf.Notice.Register(
Usd.Notice.ObjectsChanged, self.__on_usd_changed, self.__usd_context.get_stage()
)
@Trace.TraceFunction
@carb.profiler.profile
def __on_usd_changed(self, notice, sender):
if not sender or sender != self.__usd_context.get_stage():
return
self.__multi_user_selection_manager.on_usd_objects_changed(notice)
def __stop_subscription(self):
self.__changed_user_ids.clear()
if self.__delayed_task_or_future and not self.__delayed_task_or_future.done():
self.__delayed_task_or_future.cancel()
self.__delayed_task_or_future = None
self.__restore_local_outline_color()
self.__selection_paths_initialized = False
self.__multi_user_selection_manager.clear_all_selection()
self.__settings.set(SETTING_MULTI_USER_OUTLINE, False)
if self.__stage_objects_changed:
self.__stage_objects_changed.Revoke()
self.__stage_objects_changed = None
def stop(self):
self.__stop_subscription()
self.__layers_event_subscription = None
self.__stage_event_subscription = None
def __save_and_set_local_outline_color(self, color):
old_color = self.__settings.get(SETTING_OUTLINE_COLOR)
if old_color:
self.__settings.set(SETTING_SAVED_OUTLINE_COLOR, old_color)
old_color[-4:] = color
else:
# It has maximum 255 group + selection_outline
old_color = [0] * 256
old_color[-4:] = color
color = old_color
self.__settings.set(SETTING_OUTLINE_COLOR, color)
def __restore_local_outline_color(self):
# It's possible that Kit is shutdown abnormally. So it can
# be used to restore the outline color before live session or abort.
color = self.__settings.get(SETTING_SAVED_OUTLINE_COLOR)
if not color:
return
self.__settings.set(SETTING_OUTLINE_COLOR, color)
# Clear saved color
self.__settings.set(SETTING_SAVED_OUTLINE_COLOR, None)
def __on_stage_event(self, event):
if event.type == int(omni.usd.StageEventType.SELECTION_CHANGED):
if not self.__live_syncing.get_current_live_session():
return
selection = self.__usd_context.get_selection().get_selected_prim_paths()
self.__on_selection_changed(selection)
elif event.type == int(omni.usd.StageEventType.CLOSING):
self.__stop_subscription()
def __on_selection_changed(self, selection_paths):
self.__multi_user_selection_manager.refresh_selection(selection_paths)
def __on_layers_event(self, event):
payload = layers.get_layer_event_payload(event)
if payload.event_type == layers.LayerEventType.LIVE_SESSION_STATE_CHANGED:
if not payload.is_layer_influenced(self.__usd_context.get_stage_url()):
return
if self.__live_syncing.get_current_live_session():
self.__start_subscription()
else:
self.__stop_subscription()
elif payload.event_type == layers.LayerEventType.LIVE_SESSION_USER_JOINED:
if not payload.is_layer_influenced(self.__usd_context.get_stage_url()):
return
user_id = payload.user_id
live_session = self.__live_syncing.get_current_live_session()
user_info = live_session.get_peer_user_info(user_id)
selection_paths = self.__presence_layer.get_selections(user_id)
self.__multi_user_selection_manager.update_selection_outline(user_info, selection_paths)
elif payload.event_type == layers.LayerEventType.LIVE_SESSION_USER_LEFT:
if not payload.is_layer_influenced(self.__usd_context.get_stage_url()):
return
user_id = payload.user_id
self.__multi_user_selection_manager.clear_selection(user_id)
else:
payload = pl.get_presence_layer_event_payload(event)
if payload.event_type == pl.PresenceLayerEventType.SELECTIONS_CHANGED:
self.__changed_user_ids.update(payload.changed_user_ids)
# Delay the selection updates.
if not self.__delayed_task_or_future or self.__delayed_task_or_future.done():
self.__delayed_task_or_future = run_coroutine(self.__handle_selection_changes())
async def __handle_selection_changes(self):
current_live_session = self.__live_syncing.get_current_live_session()
if not current_live_session:
return
for user_id in self.__changed_user_ids:
user_info = current_live_session.get_peer_user_info(user_id)
if not user_info:
continue
selection_paths = self.__presence_layer.get_selections(user_id)
self.__multi_user_selection_manager.update_selection_outline(user_info, selection_paths)
self.__changed_user_ids.clear()
self.__delayed_task_or_future = None
| 19,602 |
Python
| 41.522776 | 124 | 0.604173 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/omni/kit/collaboration/selection_outline/manipulator/peer_user_list_manipulator_model.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["PeerUserListManipulatorModel"]
import carb
import omni.usd
import omni.kit.usd.layers as layers
from omni.ui import scene as sc
from pxr import Gf, UsdGeom, Usd, Sdf, Tf, Trace
class PeerUserListManipulatorModel(sc.AbstractManipulatorModel):
"""The model tracks the position of peer user's camera in a live session."""
class PositionItem(sc.AbstractManipulatorItem):
def __init__(self):
super().__init__()
self.value = [0, 0, 0]
class UserListItem(sc.AbstractManipulatorItem):
def __init__(self):
super().__init__()
self.value = {}
def __init__(self, prim_path, usd_context: omni.usd.UsdContext):
super().__init__()
self.position = PeerUserListManipulatorModel.PositionItem()
self.user_list = PeerUserListManipulatorModel.UserListItem()
self.__prim_path = Sdf.Path(prim_path)
self.__usd_context = usd_context
self.__update_position = True
def destroy(self):
self.position = None
self.__usd_context = None
def add_user(self, user_info: layers.LiveSessionUser):
if user_info.user_id in self.user_list.value:
return
self.user_list.value[user_info.user_id] = user_info
# This makes the manipulator updated
self._item_changed(self.user_list)
def remove_user(self, user_id):
item = self.user_list.value.pop(user_id, None)
if not item:
# This makes the manipulator updated
self._item_changed(self.user_list)
def empty_user_list(self):
return len(self.user_list.value) == 0
def get_item(self, identifier):
if identifier == "position":
return self.position
elif identifier == "user_list":
return self.user_list
return None
def get_as_floats(self, item):
if item == self.position:
# Requesting position
if self.__update_position:
self.position.value = self._get_position()
self.__update_position = False
return self.position.value
return []
def set_floats(self, item, value):
if item != self.position:
return
if not value or item.value == value:
return
# Set directly to the item
item.value = value
self.__update_position = False
# This makes the manipulator updated
self._item_changed(item)
def on_transform_changed(self, position=None):
"""When position is provided, it will not re-calculate position but use provided value instead."""
# Position is changed
if position:
self.set_floats(self.position, position)
else:
self.__update_position = True
self._item_changed(self.position)
def _get_position(self):
"""Returns center position at the top of the bbox for the current selected object."""
stage = self.__usd_context.get_stage()
prim = stage.GetPrimAtPath(self.__prim_path)
if not prim:
return []
# Get bounding box from prim
aabb_min, aabb_max = self.__usd_context.compute_path_world_bounding_box(
str(self.__prim_path)
)
gf_range = Gf.Range3d(
Gf.Vec3d(aabb_min[0], aabb_min[1], aabb_min[2]),
Gf.Vec3d(aabb_max[0], aabb_max[1], aabb_max[2])
)
if gf_range.IsEmpty():
# May be empty (UsdGeom.Xform for example), so build a scene-scaled constant box
world_units = UsdGeom.GetStageMetersPerUnit(stage)
if Gf.IsClose(world_units, 0.0, 1e-6):
world_units = 0.01
xformable_prim = UsdGeom.Xformable(prim)
world_xform = xformable_prim.ComputeLocalToWorldTransform(Usd.TimeCode.Default())
ref_position = world_xform.ExtractTranslation()
extent = Gf.Vec3d(0.1 / world_units) # 10cm by default
gf_range.SetMin(ref_position - extent)
gf_range.SetMax(ref_position + extent)
bboxMin = gf_range.GetMin()
bboxMax = gf_range.GetMax()
position = [(bboxMin[0] + bboxMax[0]) * 0.5, bboxMax[1], (bboxMin[2] + bboxMax[2]) * 0.5]
return position
| 4,784 |
Python
| 32 | 106 | 0.607232 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/omni/kit/collaboration/selection_outline/manipulator/__init__.py
|
from .peer_user_list import PeerUserList
| 41 |
Python
| 19.99999 | 40 | 0.829268 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/omni/kit/collaboration/selection_outline/manipulator/peer_user_list_manipulator.py
|
## Copyright (c) 2018-2021, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
__all__ = ["PeerUserListManipulator"]
import omni.ui as ui
import omni.kit.usd.layers as layers
from omni.ui import scene as sc
from omni.ui import color as cl
class PeerUserListManipulator(sc.Manipulator):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.__position_transform = None
self.__user_list_transform = None
self.__hover_gesture = sc.HoverGesture(
on_began_fn=lambda sender: self.__show_tooltip(sender),
on_ended_fn=lambda sender: self.__show_tooltip(sender)
)
def destroy(self):
self.__hover_gesture = None
self.__clear()
def __clear(self):
if self.__position_transform:
self.__position_transform.clear()
self.__position_transform = None
if self.__user_list_transform:
self.__user_list_transform.clear()
self.__user_list_transform = None
def __show_tooltip(self, sender):
pass
def on_build(self):
"""Called when the model is changed and rebuilds the whole slider"""
if not self.model:
return
position = self.model.get_as_floats(self.model.get_item("position"))
if not position:
return
user_list_item = self.model.get_item("user_list")
if not user_list_item:
return
self.__position_transform = sc.Transform(transform=sc.Matrix44.get_translation_matrix(*position))
with self.__position_transform:
with sc.Transform(look_at=sc.Transform.LookAt.CAMERA):
with sc.Transform(scale_to=sc.Space.SCREEN):
self.__user_list_transform = sc.Transform(transform=sc.Matrix44.get_translation_matrix(0, 30, 0))
with self.__user_list_transform:
self.__build_user_list(user_list_item.value)
def __invalidate(self):
self.__clear()
self.invalidate()
def __build_user_list(self, user_list):
size = min(3, len(user_list))
index = 0
current_offset = 0
space = 4
icon_size = 28
self.__user_list_transform.clear()
with self.__user_list_transform:
for user_info in user_list.values():
if index == size:
with sc.Transform(transform=sc.Matrix44.get_translation_matrix(current_offset, 0, 0)):
sc.Label("...", color=cl.white, alignment=ui.Alignment.CENTER, size=28)
break
with sc.Transform(transform=sc.Matrix44.get_translation_matrix(current_offset, 0, 0)):
color = ui.color(*user_info.user_color)
sc.Arc(radius=icon_size, color=color)
sc.Label(
layers.get_short_user_name(user_info.user_name), color=cl.white,
alignment=ui.Alignment.CENTER, size=16
)
current_offset += icon_size * 2 + space
index += 1
if index > size:
break
def on_model_updated(self, item):
if not self.__position_transform or not self.__user_list_transform or not item:
self.__invalidate()
return
position_item = self.model.get_item("position")
user_list_item = self.model.get_item("user_list")
if item == position_item:
position = self.model.get_as_floats(position_item)
if not position:
return
self.__position_transform.transform = sc.Matrix44.get_translation_matrix(*position)
elif item == user_list_item:
self.__build_user_list(user_list_item.value)
| 4,202 |
Python
| 35.232758 | 117 | 0.583532 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/omni/kit/collaboration/selection_outline/manipulator/peer_user_list.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["PeerUserList"]
import omni.usd
import omni.kit.usd.layers as layers
from pxr import Sdf
from omni.ui import scene as sc
from omni.kit.viewport.utility import get_active_viewport_window
from .peer_user_list_manipulator_model import PeerUserListManipulatorModel
from .peer_user_list_manipulator import PeerUserListManipulator
class PeerUserList:
def __init__(self, usd_context: omni.usd.UsdContext, prim_path: Sdf.Path):
self.__usd_context = usd_context
self.__prim_path = Sdf.Path(prim_path)
self.__manipulator = None
self.__manipulator_model = None
self.__scene_view = None
self.__build_window()
def destroy(self):
if self.__manipulator:
self.__manipulator.destroy()
self.__manipulator = None
if self.__manipulator_model:
self.__manipulator_model.destroy()
self.__manipulator_model = None
if self.__viewport_window:
vp_api = self.__viewport_window.viewport_api
if self.__scene_view:
vp_api.remove_scene_view(self.__scene_view)
self.__scene_view.scene.clear()
self.__scene_view.destroy()
self.__scene_view = None
self.__viewport_window = None
def add_user(self, user_info: layers.LiveSessionUser):
if self.__manipulator_model:
self.__manipulator_model.add_user(user_info)
def remove_user(self, user_id):
if self.__manipulator_model:
self.__manipulator_model.remove_user(user_id)
def empty_user_list(self):
if self.__manipulator_model:
return self.__manipulator_model.empty_user_list()
return True
@property
def position(self):
if self.__manipulator_model:
return self.__manipulator_model._get_position()
return None
def on_transform_changed(self, position=None):
if self.__manipulator_model:
self.__manipulator_model.on_transform_changed(position)
def __build_window(self):
"""Called to build the widgets of the window"""
self.__viewport_window = get_active_viewport_window()
frame = self.__viewport_window.get_frame("selection_outline." + str(self.__prim_path))
with frame:
self.__scene_view = sc.SceneView()
with self.__scene_view.scene:
self.__manipulator_model = PeerUserListManipulatorModel(self.__prim_path, self.__usd_context)
self.__manipulator = PeerUserListManipulator(model=self.__manipulator_model)
vp_api = self.__viewport_window.viewport_api
vp_api.add_scene_view(self.__scene_view)
| 3,188 |
Python
| 33.663043 | 109 | 0.637077 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/omni/kit/collaboration/selection_outline/tests/__init__.py
|
from .test_collaboration_selection_outline import TestCollaborationSelectionOutline
| 84 |
Python
| 41.499979 | 83 | 0.904762 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/omni/kit/collaboration/selection_outline/tests/test_collaboration_selection_outline.py
|
from pathlib import Path
import omni.usd
import omni.client
import omni.kit.app
import omni.kit.usd.layers as layers
from omni.ui.tests.test_base import OmniUiTest
import omni.kit.collaboration.presence_layer.utils as pl_utils
from pxr import Usd, Sdf, UsdGeom, Gf
from typing import List
from omni.kit.usd.layers.tests.mock_utils import MockLiveSyncingApi, join_new_simulated_user, quit_simulated_user
CURRENT_PATH = Path(omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__) + "/data")
class TestCollaborationSelectionOutline(OmniUiTest):
user_counter = 0
# Before running each test
async def setUp(self):
self.previous_retry_values = omni.client.set_retries(0, 0, 0)
self.app = omni.kit.app.get_app()
self.usd_context = omni.usd.get_context()
self.layers = layers.get_layers(self.usd_context)
self.live_syncing = self.layers.get_live_syncing()
await omni.usd.get_context().new_stage_async()
self._golden_img_dir = CURRENT_PATH.absolute().resolve().joinpath("tests")
self.simulated_user_names = []
self.simulated_user_ids = []
self.test_session_name = "test"
self.stage_url = "omniverse://__faked_omniverse_server__/test/live_session.usd"
async def tearDown(self):
if omni.usd.get_context().get_stage():
await omni.usd.get_context().close_stage_async()
self.stage = None
omni.client.set_retries(*self.previous_retry_values)
self.live_syncing.stop_all_live_sessions()
async def __create_fake_stage(self):
format = Sdf.FileFormat.FindByExtension(".usd")
# Sdf.Layer.New will not save layer so it won't fail.
# This can be used to test layer identifier with omniverse sheme without
# touching real server.
layer = Sdf.Layer.New(format, self.stage_url)
stage = Usd.Stage.Open(layer.identifier)
session = self.live_syncing.create_live_session(self.test_session_name, layer_identifier=layer.identifier)
self.assertTrue(session)
await self.usd_context.attach_stage_async(stage)
self.live_syncing.join_live_session(session)
return stage, layer
def __manipulate_stage(self, stage):
sphere = stage.DefinePrim('/sphere01', 'Sphere')
cube = stage.DefinePrim('/cube01', 'Cube')
UsdGeom.XformCommonAPI(sphere).SetTranslate((100, 0, 0))
UsdGeom.XformCommonAPI(sphere).SetScale(Gf.Vec3f(40.0, 40.0, 40.0))
UsdGeom.XformCommonAPI(cube).SetTranslate((0, 100, 0))
UsdGeom.XformCommonAPI(cube).SetScale(Gf.Vec3f(40.0, 40.0, 40.0))
async def __create_simulated_users(self, count=2):
for i in range(count):
user_name = chr(ord('A') + TestCollaborationSelectionOutline.user_counter) # f"test{i}"
user_id = user_name
self.simulated_user_names.append(user_name)
self.simulated_user_ids.append(user_id)
join_new_simulated_user(user_name, user_id)
await self.wait_n_updates(2)
TestCollaborationSelectionOutline.user_counter += 1
def __get_shared_stage(self, current_session: layers.LiveSession):
shared_data_stage_url = current_session.url + "/shared_data/users.live"
layer = Sdf.Layer.FindOrOpen(shared_data_stage_url)
if not layer:
layer = Sdf.Layer.CreateNew(shared_data_stage_url)
return Usd.Stage.Open(layer)
async def __select_prims(self, shared_stage: Usd.Stage, user_id: str, selections: List[str]):
selection_property_path = pl_utils.get_selection_property_path(user_id)
property_spec = pl_utils.get_or_create_property_spec(
shared_stage.GetRootLayer(), selection_property_path,
Sdf.ValueTypeNames.StringArray
)
property_spec.default = selections
await self.wait_n_updates()
async def __prepare_stage(self, num_users=2):
await self.wait_n_updates(n_frames=10)
# create stage and add users
stage, layer = await self.__create_fake_stage()
await self.wait_n_updates(n_frames=10)
self.__manipulate_stage(stage)
await self.__create_simulated_users(num_users)
await self.wait_n_updates(n_frames=10)
current_session = self.live_syncing.get_current_live_session()
shared_stage = self.__get_shared_stage(current_session)
assert(stage is not shared_stage)
return shared_stage
async def __check_and_leave(self):
await self.finalize_test(golden_img_dir=self._golden_img_dir)
self.live_syncing.stop_all_live_sessions()
await self.wait_n_updates(n_frames=10)
@MockLiveSyncingApi(user_name="test", user_id="test")
async def test_1_selection(self):
shared_stage = await self.__prepare_stage()
selections = ["/cube01"]
await self.__select_prims(shared_stage, self.simulated_user_ids[0], selections)
await self.wait_n_updates(n_frames=10)
await self.__check_and_leave()
@MockLiveSyncingApi(user_name="test", user_id="test")
async def test_2_select_two_prims(self):
shared_stage = await self.__prepare_stage()
selections = ["/sphere01", "/cube01"]
await self.__select_prims(shared_stage, self.simulated_user_ids[0], selections)
await self.wait_n_updates(n_frames=10)
await self.__check_and_leave()
@MockLiveSyncingApi(user_name="test", user_id="test")
async def test_3_select_identical_prim(self):
shared_stage = await self.__prepare_stage()
selections = ["/cube01"]
await self.__select_prims(shared_stage, self.simulated_user_ids[0], selections)
await self.wait_n_updates(n_frames=10)
await self.__select_prims(shared_stage, self.simulated_user_ids[1], selections)
await self.wait_n_updates(n_frames=10)
await self.__check_and_leave()
@MockLiveSyncingApi(user_name="test", user_id="test")
async def test_4_selection_overflow(self):
num_users = 4
shared_stage = await self.__prepare_stage(num_users=num_users)
selections = ["/cube01"]
for i in range(num_users):
await self.__select_prims(shared_stage, self.simulated_user_ids[i], selections)
await self.__check_and_leave()
@MockLiveSyncingApi(user_name="test", user_id="test")
async def test_5_select_and_unselect(self):
shared_stage = await self.__prepare_stage()
selections = ["/cube01", "/sphere01"]
await self.__select_prims(shared_stage, self.simulated_user_ids[0], selections)
await self.wait_n_updates(n_frames=10)
selections = ["/sphere01"]
await self.__select_prims(shared_stage, self.simulated_user_ids[0], selections)
await self.wait_n_updates(n_frames=10)
await self.__check_and_leave()
| 6,901 |
Python
| 39.840236 | 116 | 0.656716 |
omniverse-code/kit/exts/omni.kit.collaboration.selection_outline/docs/index.rst
|
omni.kit.collaboration.selection_outline
########################################
Live Session: Selection Outline
Introduction
============
This extension adds support to share selections across live session to visualize the selections of multi-users in the
same live session for more spatial awareness.
| 305 |
reStructuredText
| 32.999996 | 117 | 0.695082 |
omniverse-code/kit/exts/omni.app.setup/omni/app/setup/imgui_helper.py
|
import carb
def _trans_color(color):
if isinstance(color, (list, tuple)):
if len(color) == 3:
return carb.Float4(color[0], color[1], color[2], 1.0)
elif len(color) == 4:
return carb.Float4(color[0], color[1], color[2], color[3])
elif isinstance(color, str):
argb_int = int(color, 16)
r = ((argb_int >> 16) & 0x000000FF) / 255.0
g = ((argb_int >> 8) & 0x000000FF) / 255.0
b = (argb_int & 0x000000FF) / 255.0
w = ((argb_int >> 24) & 0x000000FF) / 255.0
return carb.Float4(r, g, b, w)
elif isinstance(color, float):
return carb.Float4(color, color, color, 1.0)
else:
return None
def setup_imgui():
settings = carb.settings.get_settings()
import omni.kit.imgui as _imgui
imgui = _imgui.acquire_imgui()
imgui_configs = settings.get("/exts/omni.app.setup/imgui")
if not imgui_configs:
return
colors = imgui_configs.get("color", {})
if colors:
for name, value in colors.items():
color = _trans_color(value)
if color:
def _push_color(imgui, name, color):
try:
source = f"imgui.push_style_color(carb.imgui.StyleColor.{name}, {color})"
carb.log_info(f"config style color {name} tp {color}")
exec(source)
except Exception as e:
carb.log_error(f"Failed to config imgui style color {name} to {color}: {e}")
_push_color(imgui, name, color)
else:
carb.log_error(f"Unknown color format for {name}: {value}")
floats = imgui_configs.get("float", {})
if floats:
for name, value in floats.items():
if value != "":
def _push_float_var(imgui, name, value):
try:
source = f"imgui.push_style_var_float(carb.imgui.StyleVar.{name}, {value})"
carb.log_info(f"config float var {name} tp {value}")
exec(source)
except Exception as e:
carb.log_error(f"Failed to config imgui float var {name} to {color}: {e}")
_push_float_var(imgui, name, value)
| 2,308 |
Python
| 34.523076 | 100 | 0.516031 |
omniverse-code/kit/exts/omni.app.setup/omni/app/setup/application_setup.py
|
import asyncio
import sys
import os
import carb.tokens
import omni.ui as ui
import omni.kit.ui
import omni.kit.app
import carb.settings
import omni.kit.menu.utils
import carb.input
import omni.kit.stage_templates as stage_templates
from omni.kit.window.title import get_main_window_title
from typing import Optional, Tuple
class ApplicationSetup:
def __init__(self):
self._settings = carb.settings.get_settings_interface()
# storage for the lazy menu items
self._lazy_menus = []
# storage for the layout menu items
self._layout_menu = None
# storage for workflows
self._workflows = []
async def _load_layout(self, layout_file: str, keep_windows_open=False):
try:
from omni.kit.quicklayout import QuickLayout
# few frames delay to avoid the conflict with the layout of omni.kit.mainwindow
for i in range(3):
await omni.kit.app.get_app().next_update_async()
QuickLayout.load_file(layout_file, keep_windows_open)
# load layout file again to make sure layout correct
for i in range(3):
await omni.kit.app.get_app().next_update_async()
QuickLayout.load_file(layout_file, keep_windows_open)
except Exception as exc:
pass
def force_viewport_settings(self):
display_options = self._settings.get("/persistent/app/viewport/displayOptions")
# Note: flags are from omni/kit/ViewportTypes.h
kShowFlagAxis = 1 << 1
kShowFlagGrid = 1 << 6
kShowFlagSelectionOutline = 1 << 7
kShowFlagLight = 1 << 8
display_options = (
display_options
| (kShowFlagAxis)
| (kShowFlagGrid)
| (kShowFlagSelectionOutline)
| (kShowFlagLight)
)
self._settings.set("/persistent/app/viewport/displayOptions", display_options)
# Make sure these are in sync from changes above
self._settings.set("/app/viewport/show/lights", True)
self._settings.set("/app/viewport/grid/enabled", True)
self._settings.set("/app/viewport/outline/enabled", True)
def setup_application_title(self):
# Adjust the Window Title to show the Create Version
window_title = get_main_window_title()
app_version = self._settings.get("/app/version")
if not app_version:
app_version = open(
carb.tokens.get_tokens_interface().resolve("${app}/../VERSION")
).read()
if app_version:
if "+" in app_version:
app_version, _ = app_version.split("+")
# for RC version we remove some details
production = self._settings.get("/privacy/externalBuild")
if production:
if "-" in app_version:
app_version, _ = app_version.split("-")
if self._settings.get("/app/beta"):
window_title.set_app_version(app_version + " Beta")
else:
window_title.set_app_version(app_version)
def load_default_layout(self, keep_windows_open=False):
default_layout = self._settings.get("/app/layout/default")
default_layout = carb.tokens.get_tokens_interface().resolve(default_layout)
self.__setup_window_task = asyncio.ensure_future(
self._load_layout(default_layout, keep_windows_open=keep_windows_open)
)
def __load_extension_and_show_window(self, menu_path, ext_id, window_name):
# Remove "lazy" menu here because it could not handle menu states while window closed
# Extension should create menu item again and handle menu states
editor_menu = omni.kit.ui.get_editor_menu()
editor_menu.remove_item(menu_path)
manager = omni.kit.app.get_app().get_extension_manager()
# if the extension is not enabled, enable it and show the window
if not manager.is_extension_enabled(ext_id):
manager.set_extension_enabled_immediate(ext_id, True)
ui.Workspace.show_window(window_name, True)
else:
# the extensions was enabled already check for the window and toggle it
window: ui.WindowHandle = ui.Workspace.get_window(window_name)
if window:
ui.Workspace.show_window(window_name, not window.visible)
else:
ui.Workspace.show_window(window_name, True)
def create_trigger_menu(self):
""" Create a menu item for each extension that has a [[trigger]] entry with a menu in it's config."""
editor_menu = omni.kit.ui.get_editor_menu()
manager = omni.kit.app.get_app().get_extension_manager()
include_list = self._settings.get("/exts/omni.app.setup/lazy_menu/include_list") or []
exclude_list = self._settings.get("/exts/omni.app.setup/lazy_menu/exclude_list") or []
for ext in manager.get_extensions():
# if the extensions is already enabled skip it, it already has a menu item if it need
if ext["enabled"]:
continue
ext_id = ext["id"]
info = manager.get_extension_dict(ext_id)
for trigger in info.get("trigger", []):
menu = trigger.get("menu", {})
# enable to discover and debug the auto menu creation
# print(f'menu: {menu} {menu.__class__}')
menu_name = menu.get("name", None)
# If the menu path not in white list or in black list, ignore
if include_list and menu_name not in include_list:
continue
if exclude_list and menu_name in exclude_list:
continue
window_name = menu.get("window", None)
if window_name is None or menu_name is None:
carb.log_error(f"Invalid [[trigger]] entry for extension: {ext_id}")
continue
# get priority or default to 0
priority = menu.get("priority", 0)
self._lazy_menus.append(
editor_menu.add_item(
menu_name,
lambda window, value, menu_path=menu_name, ext_id=ext_id, window_name=window_name: self.__load_extension_and_show_window(
menu_path, ext_id, window_name
),
toggle=True,
value=False,
priority=priority,
)
)
# TODO: this should be validated and those settings clean up
def set_defaults(self):
""" this is trying to setup some defaults for extensions to avoid warning """
self._settings.set_default("/persistent/app/omniverse/bookmarks", {})
self._settings.set_default("/persistent/app/stage/timeCodeRange", [0, 100])
self._settings.set_default(
"/persistent/audio/context/closeAudioPlayerOnStop", False
)
self._settings.set_default(
"/persistent/app/primCreation/PrimCreationWithDefaultXformOps", True
)
self._settings.set_default(
"/persistent/app/primCreation/DefaultXformOpType",
"Scale, Rotate, Translate",
)
self._settings.set_default(
"/persistent/app/primCreation/DefaultRotationOrder", "ZYX"
)
self._settings.set_default(
"/persistent/app/primCreation/DefaultXformOpPrecision", "Double"
)
# omni.kit.property.tagging
self._settings.set_default(
"/persistent/exts/omni.kit.property.tagging/showAdvancedTagView", False
)
self._settings.set_default(
"/persistent/exts/omni.kit.property.tagging/showHiddenTags", False
)
self._settings.set_default(
"/persistent/exts/omni.kit.property.tagging/modifyHiddenTags", False
)
# adjust couple of viewport settings
self._settings.set("/app/viewport/boundingBoxes/enabled", True)
def build_layout_menu(self):
"""Build the layout menu based on registered Layouts and main views"""
editor_menu = omni.kit.ui.get_editor_menu()
self._layout_menu_items = []
self._current_layout_priority = 20
self._current_key_index = 1
def add_layout_menu_entry(name, parameter, workflow=None):
import inspect
menu_path = f"Layout/{name}"
menu = editor_menu.add_item(
menu_path, None, False, self._current_layout_priority
)
self._current_layout_priority = self._current_layout_priority + 1
hotkey = (carb.input.KEYBOARD_MODIFIER_FLAG_CONTROL, eval(f"carb.input.KeyboardInput.KEY_{self._current_key_index}")) if self._current_key_index <= 9 else None
self._current_key_index += 1
if inspect.isfunction(parameter):
menu_action = omni.kit.menu.utils.add_action_to_menu(
menu_path,
lambda *_: parameter(),
name,
hotkey,
)
else:
menu_action = omni.kit.menu.utils.add_action_to_menu(
menu_path,
lambda *_: asyncio.ensure_future(self._activate_layout(parameter, workflow)),
name,
hotkey,
)
self._layout_menu_items.append((menu, menu_action))
# Default layout menu items
add_layout_menu_entry(
"Reset Layout", lambda: self.load_default_layout()
)
add_layout_menu_entry(
"Viewport Only",
"${omni.app.setup}/layouts/viewport_only.json",
)
# Layout menu items for workflows
workflows = self._settings.get("/exts/omni.app.setup/workflow")
active_now = self._settings.get("/exts/omni.app.setup/activeWorkflowAtStartup")
self._workflows = []
if workflows:
for workflow in workflows:
name = workflow.get("name", None)
workflow_name = workflow.get("workflow", None)
layout_name = workflow.get("layout", None)
if name is None:
carb.log_error(f"Invalid [[app.workflow]] entry for extension: {workflow}")
continue
self._workflows.append(workflow)
add_layout_menu_entry(
" ".join([n.capitalize() for n in name.split(" ")]),
layout_name,
workflow_name,
)
if active_now:
self.active_workflow(name)
async def _activate_layout(self, layout: str, workflow: str):
if workflow:
ext_manager = omni.kit.app.get_app_interface().get_extension_manager()
ext_manager.set_extension_enabled_immediate(workflow, True)
if not layout:
layout = self._settings.get(f"/exts/{workflow}/default_layout")
if layout:
await omni.kit.app.get_app().next_update_async()
layout_path = carb.tokens.get_tokens_interface().resolve(layout)
if layout_path:
await self._load_layout(layout_path)
def active_workflow(self, name: str) -> None:
for workflow in self._workflows:
if workflow.get("name") == name:
asyncio.ensure_future(self._activate_layout(workflow.get("layout"), workflow.get("workflow")))
return
else:
carb.log_error(f"Cannot find workflow '{name}'!")
def __config_menu_layout(self, title, info: dict, default_type="Menu"):
from omni.kit.menu.utils import MenuLayout, LayoutSourceSearch
def __split_title(title: str) -> Tuple[str, Optional[str], bool]:
(name, source) = title.split("=") if "=" in title else (title, None)
if name.startswith("-"):
remove = True
name = name[1:]
else:
remove = False
return (name, source, remove)
(name, source, remove) = __split_title(title)
items = info.get("items", None) if info else None
type = info.get("type", default_type) if info else default_type
children = []
if items:
for item_title in items:
(item_name, item_source, _) = __split_title(item_title)
item_info = info.get(item_name, None)
child = self.__config_menu_layout(item_title, item_info, default_type="Item")
if child:
children.append(child)
source_search = LayoutSourceSearch.EVERYWHERE if source else LayoutSourceSearch.LOCAL_ONLY
if name == "":
return MenuLayout.Seperator()
elif type == "Menu":
return MenuLayout.Menu(name, items=children, source=source, source_search=source_search, remove=remove)
elif type == "SubMenu":
return MenuLayout.SubMenu(name, items=children, source=source, source_search=source_search, remove=remove)
elif type == "Item":
return MenuLayout.Item(name, source=source, source_search=source_search, remove=remove)
elif type == "Group":
return MenuLayout.Group(name, items=children, source_search=source_search, source=source)
elif type == "Sort":
exclude_items = info.get("exclude_items", []) if info else []
sort_submenus = info.get("sort_submenus", False) if info else False
return MenuLayout.Sort(exclude_items=exclude_items, sort_submenus=sort_submenus)
else:
return None
def setup_menu_layout(self):
menu_layouts = self._settings.get("/exts/omni.app.setup/menu_layout")
if not menu_layouts:
return
self._layout_menu = []
for (menu_name, menu_info) in menu_layouts.items():
menu = self.__config_menu_layout(menu_name, menu_info)
if menu:
self._layout_menu.append(menu)
omni.kit.menu.utils.add_layout(self._layout_menu)
def setup_menu_order(self):
menu_order_presets = self._settings.get("/exts/omni.app.setup/menu_order")
if menu_order_presets:
menu_self = omni.kit.menu.utils.get_instance()
_, menu_order, _ = menu_self.get_menu_data()
menu_order.update(menu_order_presets)
menu_self.rebuild_menus()
| 14,620 |
Python
| 39.955182 | 171 | 0.577975 |
omniverse-code/kit/exts/omni.app.setup/omni/app/setup/extension.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import carb
import omni.ext
import carb.settings
import omni.kit.app
import asyncio
from .application_setup import ApplicationSetup
from .actions import register_actions, deregister_actions
from .viewport_rendering import enable_viewport_rendering
from .imgui_helper import setup_imgui
class AppSetupExtension(omni.ext.IExt):
"""Create Final Configuration"""
def on_startup(self, ext_id):
""" setup the window layout, menu, final configuration of the extensions etc """
self.__ext_id = omni.ext.get_extension_name(ext_id)
self._settings = carb.settings.get_settings()
setup_editor = self._settings.get("/app/kit/editor/setup")
if not setup_editor:
return
self._application_setup = ApplicationSetup()
self._menu_layout = []
# this is a work around as some Extensions don't properly setup their default setting in time
self._application_setup.set_defaults()
# Force enable Axis, Grid, Outline and Lights
forceEnable = self._settings.get("/app/kit/editor/forceViewportSettings")
if forceEnable:
self._application_setup.force_viewport_settings()
# setup the application title based on settings and few rules
self._application_setup.setup_application_title()
# Keep windows open to make sure Welcome window could be visible at startup
self._application_setup.load_default_layout(keep_windows_open=True)
self._application_setup.create_trigger_menu()
self._application_setup.build_layout_menu()
self._application_setup.setup_menu_layout()
self._application_setup.setup_menu_order()
def on_app_ready(*args, **kwargs):
self._app_ready_sub = None
# OM-93646: setup imgui when app ready otherwise there will be crash in Linux
setup_imgui()
# Start background loading of renderer if requested
bg_render_load = self._settings.get("/exts/omni.app.setup/backgroundRendererLoad/renderer")
if not bg_render_load:
return
# We delay loading those so we leave time for the welcome window
# and the first tab to be displayed
async def __load_renderer(bg_render_load):
# Get setting whether to show the renderer init progress in Viewport
show_viewport_ready = self._settings.get("/exts/omni.app.setup/backgroundRendererLoad/showViewportReady")
# Get setting for the number of frames to wait before starting the load
initial_wait = self._settings.get("/exts/omni.app.setup/backgroundRendererLoad/initialWait")
# When not set it will default to 20
if initial_wait is None:
initial_wait = 20
if initial_wait:
app = omni.kit.app.get_app()
for _ in range(initial_wait):
await app.next_update_async()
# await self._application_setup.start_loading_renderer(bg_render_load)
carb.log_info(f"Loading {bg_render_load} in background")
show_viewport_ready = self._settings.get("/exts/omni.app.setup/backgroundRendererLoad/showViewportReady")
enable_viewport_rendering(renderer=bg_render_load, show_viewport_ready=show_viewport_ready)
self.__setup_window_task = asyncio.ensure_future(__load_renderer(bg_render_load))
self._app_ready_sub = omni.kit.app.get_app().get_startup_event_stream().create_subscription_to_pop_by_type(
omni.kit.app.EVENT_APP_READY,
on_app_ready,
name="omni.app.setup.app_ready.startup"
)
"""
# At some points around here we will want to close the splash Images
splash_interface = None
try:
import omni.splash
splash_interface = omni.splash.acquire_splash_screen_interface()
except (ImportError, ModuleNotFoundError):
splash_interface = None
if splash_interface:
splash_interface.close_all()
"""
register_actions(self.__ext_id, self._application_setup)
def on_shutdown(self):
deregister_actions(self.__ext_id)
self._app_ready_sub = None
| 4,762 |
Python
| 40.060344 | 121 | 0.652877 |
omniverse-code/kit/exts/omni.app.setup/omni/app/setup/viewport_rendering.py
|
# Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["enable_viewport_rendering", "start_render_loading_ui"]
from typing import Optional
import omni.usd
_g_enabled_renderers = []
g_renderers_ready = []
def start_render_loading_ui(ext_manager: "omni.ext.ExtensionManager", renderer: str):
import carb
import time
time_begin = time.time()
# Extension to show viewport loading progress
ext_manager.set_extension_enabled_immediate("omni.activity.profiler", True)
ext_manager.set_extension_enabled_immediate("omni.activity.pump", True)
carb.settings.get_settings().set("/exts/omni.kit.viewport.ready/startup/enabled", False)
ext_manager.set_extension_enabled_immediate("omni.kit.viewport.ready", True)
from omni.kit.viewport.ready.viewport_ready import ViewportReady, ViewportReadyDelegate
class TimerDelegate(ViewportReadyDelegate):
def __init__(self, time_begin):
super().__init__()
self.__timer_start = time.time()
self.__vp_ready_cost = self.__timer_start - time_begin
@property
def font_size(self) -> float:
return 48
@property
def message(self) -> str:
rtx_mode = {
"RaytracedLighting": "Real-Time",
"PathTracing": "Interactive (Path Tracing)",
"LightspeedAperture": "Aperture (Game Path Tracer)"
}.get(carb.settings.get_settings().get("/rtx/rendermode"), "Real-Time")
renderer_label = {
"rtx": f"RTX - {rtx_mode}",
"iray": "RTX - Accurate (Iray)",
"pxr": "Pixar Storm",
"index": "RTX - Scientific (IndeX)"
}.get(renderer, renderer)
return f"Waiting for {renderer_label} to start"
def on_complete(self):
global g_renderers_ready
g_renderers_ready.append(renderer)
rtx_load_time = time.time() - self.__timer_start
super().on_complete()
carb.log_info(f"Time until pixel: {rtx_load_time}")
carb.log_info(f"ViewportReady cost: {self.__vp_ready_cost}")
settings = carb.settings.get_settings()
if settings.get("/exts/omni.kit.welcome.window/autoSetupOnClose"):
async def async_enable_all_renderers(app, renderer: str, all_renderers: str):
for enabled_renderer in all_renderers.split(","):
if enabled_renderer != renderer:
enable_viewport_rendering(enabled_renderer, False)
await app.next_update_async()
import omni.kit.app
import omni.kit.async_engine
omni.kit.async_engine.run_coroutine(async_enable_all_renderers(omni.kit.app.get_app(), renderer,
settings.get("/renderer/enabled") or ""))
return ViewportReady(TimerDelegate(time_begin))
def enable_viewport_rendering(renderer: Optional[str] = None, show_viewport_ready: bool = True):
import carb
settings = carb.settings.get_settings()
# If no renderer is specified, choose the 'active' one or what is set as active, or finally RTX - Realtime
if renderer is None:
renderer = (settings.get("/renderer/active") or
settings.get("/exts/omni.app.setup/backgroundRendererLoad/renderer") or
"rtx")
# Only enable the Viewport for a renderer once, and only do Viewport Ready the first time
global _g_enabled_renderers
if renderer in _g_enabled_renderers:
if renderer not in g_renderers_ready and show_viewport_ready:
import omni.kit.app
app = omni.kit.app.get_app()
ext_manager = app.get_extension_manager()
start_render_loading_ui(ext_manager, renderer)
return
elif show_viewport_ready and bool(_g_enabled_renderers):
show_viewport_ready = False
_g_enabled_renderers.append(renderer)
settings.set("/renderer/asyncInit", True)
settings.set("/rtx/hydra/mdlMaterialWarmup", True)
import omni.kit.app
app = omni.kit.app.get_app()
ext_manager = app.get_extension_manager()
ext_manager.set_extension_enabled_immediate("omni.kit.viewport.bundle", True)
if renderer == "iray" or renderer == "index":
ext_manager.set_extension_enabled_immediate(f"omni.hydra.rtx", True)
ext_manager.set_extension_enabled_immediate(f"omni.hydra.{renderer}", True)
else:
ext_manager.set_extension_enabled_immediate(f"omni.kit.viewport.{renderer}", True)
# we might need to have the engine_name as part of the flow
ext_manager.set_extension_enabled("omni.rtx.settings.core", True)
# TODO: It will block omni.kit.viewport.Ready.ViewportReady while it is enabled before this function
# omni.usd.add_hydra_engine(renderer, usd_context)
if show_viewport_ready:
start_render_loading_ui(ext_manager, renderer)
| 5,417 |
Python
| 41.328125 | 120 | 0.636515 |
omniverse-code/kit/exts/omni.app.setup/omni/app/setup/actions.py
|
from .application_setup import ApplicationSetup
from .viewport_rendering import enable_viewport_rendering
def register_actions(extension_id: str, application_setup: ApplicationSetup):
"""
Register actions.
Args:
extension_id (str): Extension ID which actions belongs to
application_setup: Instance of application_setup
"""
try:
import omni.kit.actions.core
action_registry = omni.kit.actions.core.get_action_registry()
actions_tag = "app.setup"
action_registry.register_action(
extension_id,
"active_workflow",
lambda name: application_setup.active_workflow(name),
display_name="Active workflow",
description="Active workflow",
tag=actions_tag,
)
action_registry.register_action(
extension_id,
"enable_viewport_rendering",
lambda: enable_viewport_rendering(),
display_name="Enable viewport rendering",
description="Enable viewport rendering",
tag=actions_tag,
)
except ImportError:
pass
def deregister_actions(extension_id: str):
"""
Deregister actions.
Args:
extension_id (str): Extension ID whcih actions belongs to
"""
try:
import omni.kit.actions.core
action_registry = omni.kit.actions.core.get_action_registry()
action_registry.deregister_all_actions_for_extension(extension_id)
except ImportError:
pass
| 1,529 |
Python
| 28.999999 | 77 | 0.631131 |
omniverse-code/kit/exts/omni.kit.search_example/omni/kit/search_example/search_model.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from omni.kit.search_core import AbstractSearchItem
from omni.kit.search_core import AbstractSearchModel
import asyncio
import carb
import functools
import omni.client
import traceback
def handle_exception(func):
"""
Decorator to print exception in async functions
"""
@functools.wraps(func)
async def wrapper(*args, **kwargs):
try:
return await func(*args, **kwargs)
except asyncio.CancelledError:
pass
except Exception as e:
carb.log_error(f"Exception when async '{func}'")
carb.log_error(f"{e}")
carb.log_error(f"{traceback.format_exc()}")
return wrapper
class SearchItem(AbstractSearchItem):
def __init__(self, dir_path, file_entry):
super().__init__()
self._dir_path = dir_path
self._file_entry = file_entry
@property
def path(self):
return f"{self._dir_path}/{self._file_entry.relative_path}"
@property
def name(self):
return str(self._file_entry.relative_path)
@property
def date(self):
# TODO: Grid View needs datatime, but Tree View needs a string. We need to make them the same.
return self._file_entry.modified_time
@property
def size(self):
# TODO: Grid View needs int, but Tree View needs a string. We need to make them the same.
return self._file_entry.size
@property
def is_folder(self):
return (self._file_entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN) > 0
class SearchModel(AbstractSearchModel):
def __init__(self, **kwargs):
super().__init__()
self._search_text = kwargs.get("search_text", None)
self._current_dir = kwargs.get("current_dir", None)
self._search_lifetime = kwargs.get("search_lifetime", None)
# omni.client doesn't understand my-computer
if self._current_dir.startswith("my-computer://"):
self._current_dir = self._current_dir[len("my-computer://"):]
self.__list_task = asyncio.ensure_future(self.__list())
self.__items = []
def destroy(self):
if not self.__list_task.done():
self.__list_task.cancel()
self._search_lifetime = None
@property
def items(self):
return self.__items
@handle_exception
async def __list(self):
result, entries = await omni.client.list_async(self._current_dir)
if result != omni.client.Result.OK:
self.__items = []
else:
self.__items = [
SearchItem(self._current_dir, entry) for entry in entries if self._search_text in entry.relative_path
]
self._item_changed()
self._search_lifetime = None
| 3,171 |
Python
| 30.098039 | 117 | 0.637023 |
omniverse-code/kit/exts/omni.kit.search_example/omni/kit/search_example/search_extension.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .search_model import SearchModel
from omni.kit.search_core import SearchEngineRegistry
import omni.ext
class SearchExampleExtension(omni.ext.IExt):
def on_startup(self, ext_id):
self._subscription = SearchEngineRegistry().register_search_model("Example Search", SearchModel)
def on_shutdown(self):
self._subscription = None
| 789 |
Python
| 38.499998 | 104 | 0.782003 |
omniverse-code/kit/exts/omni.kit.search_example/omni/kit/search_example/__init__.py
|
from .search_extension import SearchExampleExtension
| 53 |
Python
| 25.999987 | 52 | 0.886792 |
omniverse-code/kit/exts/omni.kit.search_example/omni/kit/search_example/tests/test_search_example.py
|
## Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
from pathlib import Path
from omni.kit.search_core import SearchEngineRegistry
from ..search_model import SearchModel
from ..search_model import SearchItem
import asyncio
from functools import partial
CURRENT_PATH = Path(__file__).parent
async def _wait_model_changed_async(model: SearchModel):
"""Async wait when the model is changed"""
def _on_item_changed(item: SearchItem, future: asyncio.Future):
"""Callback set the future when called"""
if not future.done():
future.set_result(None)
f = asyncio.Future()
sub = model.subscribe_item_changed(partial(_on_item_changed, future=f))
return await f
class TestSearchExample(omni.kit.test.AsyncTestCase):
async def test_search(self):
model_type = SearchEngineRegistry().get_search_model("Example Search")
self.assertIs(model_type, SearchModel)
model = model_type(search_text="test", current_dir=f"{CURRENT_PATH}")
await _wait_model_changed_async(model)
# In the current folder we only have the file "test_search_example.py"
self.assertEqual(["test_search_example.py"], [item.name for item in model.items])
| 1,619 |
Python
| 36.674418 | 89 | 0.728227 |
omniverse-code/kit/exts/omni.kit.search_example/docs/CHANGELOG.md
|
# Changelog
This document records all notable changes to ``omni.kit.search_example`` extension.
## [1.0.0] - 2020-10-05
### Added
- Initial example implementation of search using omni.client
| 193 |
Markdown
| 23.249997 | 83 | 0.740933 |
omniverse-code/kit/exts/omni.kit.search_example/docs/README.md
|
# omni.kit.search_example
## Python Search Extension Example
The example extension adds a new search engine to the content browser. The
extension is based on `omni.client` and is searching for files in the current
directory. The recursive search is not implemented.
| 268 |
Markdown
| 32.624996 | 77 | 0.798507 |
omniverse-code/kit/exts/omni.kit.tool.collect/config/extension.toml
|
[package]
title = "Project Collector"
description = "It's a tool that could be used to collect and gather all dependencies an USD depends on."
version = "2.1.20"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# URL of the extension source repository.
repository = ""
changelog = "docs/CHANGELOG.md"
readme = "docs/README.md"
category = "Utility"
# Preview image and icon. Folder named "data" automatically goes in git lfs (see .gitattributes file).
# Preview image is shown in "Overview" of Extensions window. Screenshot of an extension might be a good preview image.
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.png"
[dependencies]
"omni.usd" = {}
"omni.client" = {}
"omni.ui" = {}
"omni.kit.window.filepicker" = {}
"omni.kit.window.content_browser" = { optional=true }
"omni.kit.widget.prompt" = {}
"omni.kit.menu.utils" = {}
[[python.module]]
name = "omni.kit.tool.collect"
[[test]]
timeout=300
args = [
"--/app/file/ignoreUnsavedOnExit=true",
"--/app/asyncRendering=false",
"--/app/window/dpiScaleOverride=1.0",
"--/app/window/scaleToMonitor=false",
"--no-window"
]
dependencies = [
"omni.hydra.pxr",
"omni.kit.commands",
"omni.kit.renderer.capture",
"omni.kit.mainwindow",
"omni.kit.ui_test"
]
stdoutFailPatterns.exclude = ["*Cannot copy from*"]
| 1,452 |
TOML
| 26.415094 | 118 | 0.694215 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/async_utils.py
|
import os
import platform
import sys
import re
import asyncio
import traceback
from functools import partial, wraps
from pxr import Sdf, Usd
# This piece of wrapper is borrowed from aiofiles, see following for details
# https://github.com/Tinche/aiofiles/blob/master/aiofiles/os.py
def wrap(func):
@asyncio.coroutine
@wraps(func)
def run(*args, loop=None, executor=None, **kwargs):
if loop is None:
loop = asyncio.get_event_loop()
pfunc = partial(func, *args, **kwargs)
return loop.run_in_executor(executor, pfunc)
return run
def _read_file(path):
with open(path, "rb") as f:
return f.read()
def _encode_content(content):
if type(content) == str:
payload = bytes(content.encode("utf-8"))
elif type(content) != type(None):
payload = bytes(content)
else:
payload = bytes()
return payload
def _write_file(file, content):
with open(file, "wb") as f:
payload = _encode_content(content)
f.write(payload)
def _open_layer(path):
return Sdf.Layer.FindOrOpen(path)
def _open_stage(stage_path):
return Usd.Stage.Open(stage_path)
def _transfer_layer_content(layer, target_layer):
return target_layer.TransferContent(layer)
def _layer_save(layer):
return layer.Save()
def _export_layer_to_string(layer):
return layer.ExportToString()
def _re_find_all(regex, content):
return re.findall(regex, content)
def _replace_all(s, old_text, new_text):
if type(s) == bytes:
s = s.decode()
return s.replace(old_text, new_text)
aio_write_file = wrap(_write_file)
aio_read_file = wrap(_read_file)
aio_open_layer = wrap(_open_layer)
aio_export_layer_to_string = wrap(_export_layer_to_string)
aio_re_find_all = wrap(_re_find_all)
aio_replace_all = wrap(_replace_all)
aio_transfer_layer = wrap(_transfer_layer_content)
aio_open_stage = wrap(_open_stage)
aio_save_layer = wrap(_layer_save)
| 1,951 |
Python
| 21.436781 | 76 | 0.670425 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/mdl_parser.py
|
import os
from .async_utils import aio_replace_all, aio_re_find_all
from .utils import Utils
class MDLImportItem:
def __init__(self):
self.import_clause = "" # The import clause like `import xx`
self.import_package = "" # The package name without import directive
self.package_path = "" # The package path converted from import package
self.module_preset = False # If it's preset.
def __repr__(self):
s = f"<'import_clause': {self.import_clause},"
s += f"'import_package': {self.import_package},"
s += f"'packag_path': {self.package_path}>"
return s
class MDLParser:
"""A parser of mdl file, for get the relative texture files.
Args:
mdl_file_path (str): Human readable string describing the exception.
mdl_content(bytes): MDL content in bytes array.
"""
def __init__(self, mdl_file_path, mdl_content):
self._parsed = False
self._mdl_file_path = mdl_file_path
self._mdl_content = mdl_content
if type(self._mdl_content) == bytes:
self._mdl_content = self._mdl_content.decode()
self._raw_to_absolute_texture_paths = {}
self._mdl_imports = {}
@property
def content(self):
return self._mdl_content
async def parse(self):
if not self._parsed:
self._parsed = True
texture_paths, self._mdl_imports = await self._parse_internal()
absolute_mdl_basepath = os.path.dirname(self._mdl_file_path)
if absolute_mdl_basepath != "/":
absolute_mdl_basepath += "/"
for raw_texture_path in texture_paths:
if not raw_texture_path.strip():
continue
if raw_texture_path[0] == '/':
texture_path = "." + raw_texture_path
else:
texture_path = raw_texture_path
absolute_texture_path = Utils.compute_absolute_path(absolute_mdl_basepath, texture_path)
self._raw_to_absolute_texture_paths[raw_texture_path] = absolute_texture_path
for mdl_import in self._mdl_imports:
mdl_import.package_path = Utils.compute_absolute_path(
absolute_mdl_basepath, mdl_import.package_path
)
return self._raw_to_absolute_texture_paths, self._mdl_imports
async def _parse_internal(self):
if not self._mdl_content:
return [], []
texture_paths = await aio_re_find_all(
'texture_2d[ \t]*\([ \t]*"(.*?)"', self._mdl_content
)
texture_paths.extend(
await aio_re_find_all(
'texture_3d[ \t]*\([ \t]*"(.*?)"', self._mdl_content
)
)
texture_paths.extend(
await aio_re_find_all(
'texture_cube[ \t]*\([ \t]*"(.*?)"', self._mdl_content
)
)
texture_paths.extend(
await aio_re_find_all(
'texture_ptex[ \t]*\([ \t]*"(.*?)"', self._mdl_content
)
)
mdl_packages = await aio_re_find_all("import[ \t]+(.*)::.*;", self._mdl_content)
mdl_imports = await aio_re_find_all("(import[ \t]+.*::.*);", self._mdl_content)
mdl_packages += await aio_re_find_all("using[ \t]+(.*)[ \t]+import.*;", self._mdl_content)
mdl_imports += await aio_re_find_all("(using[ \t]+.*import.*);", self._mdl_content)
mdl_packages += await aio_re_find_all("=[ \t]+(.*)::.*", self._mdl_content)
mdl_imports += await aio_re_find_all("(=[ \t]+.*::.*)", self._mdl_content)
mdl_paths = await self._convert_packages(mdl_packages)
import_items = []
for clause, package, path in zip(mdl_imports, mdl_packages, mdl_paths):
item = MDLImportItem()
item.import_clause = clause
item.import_package = package
item.package_path = path
if clause.startswith("="):
item.module_preset = True
import_items.append(item)
return texture_paths, import_items
async def _convert_packages(self, packages):
paths = []
for mdl_package in packages:
path = await aio_replace_all(mdl_package, "::", "/")
if path:
paths.append(path + ".mdl")
return paths
| 4,407 |
Python
| 33.4375 | 104 | 0.540958 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/main_window.py
|
import os
from omni import ui
from .icons import Icons
from .filebrowser import FileBrowserSelectionType, FileBrowserMode
from .file_picker import FilePicker
class CollectMainWindow:
def __init__(self, collect_button_fn=None, cancel_button_fn=None):
self._collect_button_fn = collect_button_fn
self._cancel_button_fn = cancel_button_fn
self._file_picker = None
self._collection_path_field = None
self._build_content_ui()
def destroy(self):
self._collect_button_fn = None
self._cancel_button_fn = None
self._collection_path_field = None
if self._file_picker:
self._file_picker.destroy()
self._file_picker = None
if self._cancel_button:
self._cancel_button.set_clicked_fn(None)
self._cancel_button = None
if self._collect_button:
self._collect_button.set_clicked_fn(None)
self._collect_button = None
if self._folder_button:
self._folder_button.set_clicked_fn(None)
self._folder_button = None
self._window = None
def set_collect_fn(self, collect_fn):
self._collect_button_fn = collect_fn
def set_cancel_fn(self, cancel_fn):
self._cancel_button_fn = cancel_fn
def _build_content_ui(self):
self._window = ui.Window(
"Collection Options", visible=False, height=0, dockPreference=ui.DockPreference.DISABLED
)
self._window.flags = (
ui.WINDOW_FLAGS_NO_COLLAPSE
| ui.WINDOW_FLAGS_NO_RESIZE
| ui.WINDOW_FLAGS_NO_SCROLLBAR
| ui.WINDOW_FLAGS_NO_RESIZE
| ui.WINDOW_FLAGS_NO_MOVE
)
self._window.flags = self._window.flags | ui.WINDOW_FLAGS_MODAL
def _build_option_checkbox(text, default_value, identifier, tooltip=None):
stack = ui.HStack(height=0, width=0)
with stack:
checkbox = ui.CheckBox(width=20, identifier=identifier, style={"font_size": 16})
checkbox.model.set_value(default_value)
ui.Label(text, alignment=ui.Alignment.LEFT)
if tooltip:
stack.set_tooltip(tooltip)
return checkbox
style = {
"Rectangle::hovering": {"background_color": 0x0, "border_radius": 2, "margin": 0, "padding": 0},
"Rectangle::hovering:hovered": {"background_color": 0xFF9E9E9E},
"Button.Image::folder": {"image_url": Icons().get("folder")},
"Button.Image::folder:checked": {"image_url": Icons().get("folder")},
"Button::folder": {"background_color": 0x0, "margin": 0},
"Button::folder:checked": {"background_color": 0x0, "margin": 0},
"Button::folder:pressed": {"background_color": 0x0, "margin": 0},
"Button::folder:hovered": {"background_color": 0x0, "margin": 0},
}
self._window.width = 600
with self._window.frame:
with ui.HStack(height=0, style=style):
ui.Spacer(width=40)
with ui.VStack(spacing=10):
ui.Spacer(height=10)
# build collection path widgets
with ui.HStack(height=0):
ui.Label("Collection Path: ", width=0)
with ui.VStack(height=0):
ui.Spacer(height=4)
self._collection_path_field = ui.StringField(
height=20, identifier="collect_path", width=ui.Fraction(1)
)
ui.Spacer(height=4)
ui.Spacer(width=5)
with ui.VStack(width=0):
ui.Spacer()
with ui.ZStack(width=20, height=20):
ui.Rectangle(name="hovering")
self._folder_button = ui.Button(
name="folder", identifier="folder_button", width=24, height=24
)
self._folder_button.set_tooltip("Choose folder")
ui.Spacer()
ui.Spacer(width=2)
self._folder_button.set_clicked_fn(lambda: self._show_file_picker())
# build collection options
with ui.HStack(height=0, spacing=10):
self._usd_only_checkbox = _build_option_checkbox(
"USD Only",
False,
"usd_only_checkbox",
"Only USD files will be collected. Any materials bindings will be removed.",
)
self._material_only_checkbox = _build_option_checkbox(
"Material Only",
False,
"material_only_checkbox",
"Only MDL files and their depdendent textures will be collected.",
)
self._flat_collection_checkbox = _build_option_checkbox(
"Flat Collection",
False,
"flat_collection_checkbox",
"By default, it will keep the folder structure after collection. "
"After this option is enabled, assets will be collected into specified folders.",
)
# add value changed callback to enable flat collection settings combo
self._flat_collection_checkbox.model.add_value_changed_fn(self._on_flat_collection_toggled)
# build flat collection texture options (visibility toggled by flat collection checkbox)
with ui.HStack(spacing=10):
tooltip = "Options for grouping for textures.\nTextures can be grouped under parent folders by MDL or USD, or flat in the same hierarchy."
self._flat_options_widgets = [
ui.Label("Flat Collection Texture Option: ", name="label", width=0, tooltip=tooltip),
ui.ComboBox(
0,
"Group By MDL",
"Group By USD",
"Flat",
height=10,
name="choices",
identifier="texture_option_combo",
),
]
for widget in self._flat_options_widgets:
widget.visible = False
ui.Spacer(height=0)
# build action buttons
with ui.HStack(height=0):
ui.Spacer()
self._collect_button = ui.Button("Start", width=120, height=0)
self._collect_button.set_clicked_fn(self._on_collect_button_clicked)
self._cancel_button = ui.Button("Cancel", width=120, height=0)
self._cancel_button.set_clicked_fn(self._on_cancel_button_clicked)
ui.Spacer()
ui.Spacer(height=20)
ui.Spacer(width=40)
def _on_collect_button_clicked(self):
if self._collect_button_fn:
collect_dir = self._collection_path_field.model.get_value_as_string()
usd_only = self._usd_only_checkbox.model.get_value_as_bool()
material_only = self._material_only_checkbox.model.get_value_as_bool()
flat_collection = self._flat_collection_checkbox.model.get_value_as_bool()
texture_option = self._flat_options_widgets[1].model.get_item_value_model().as_int
self._collect_button_fn(collect_dir, usd_only, flat_collection, material_only, texture_option)
self._window.visible = False
def _on_cancel_button_clicked(self):
if self._cancel_button_fn:
self._cancel_button_fn()
self._window.visible = False
def _select_picked_folder_callback(self, path):
self._collection_path_field.model.set_value(path)
self._window.visible = True
def _cancel_picked_folder_callback(self):
self._window.visible = True
def _show_file_picker(self):
self._window.visible = False
if not self._file_picker:
mode = FileBrowserMode.SAVE
file_type = FileBrowserSelectionType.DIRECTORY_ONLY
filters = [(".*", "All Files (*.*)")]
self._file_picker = FilePicker(
"Select Collect Destination", mode=mode, file_type=file_type, filter_options=filters
)
self._file_picker.set_filebar_label_name("Folder name")
self._file_picker.set_file_selected_fn(self._select_picked_folder_callback)
self._file_picker.set_cancel_fn(self._cancel_picked_folder_callback)
path = self._collection_path_field.model.get_value_as_string().rstrip("/")
dir_name = os.path.dirname(path)
folder_name = os.path.basename(path)
self._file_picker.show(dir_name, folder_name)
def _on_flat_collection_toggled(self, model):
for widget in self._flat_options_widgets:
widget.visible = model.as_bool
def show(self, export_folder=None):
if export_folder:
self._collection_path_field.model.set_value(export_folder)
self._window.visible = True
def hide(self):
self._window.visible = False
| 9,770 |
Python
| 45.089622 | 162 | 0.524258 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/extension.py
|
import os
import asyncio
import weakref
import omni
import omni.usd
import carb
from typing import Callable
from omni.kit.widget.prompt import PromptButtonInfo, PromptManager
from .omni_client_wrapper import OmniClientWrapper
from .main_window import CollectMainWindow
from .collector import Collector, CollectorException, CollectorFailureOptions, FlatCollectionTextureOptions
from .progress_popup import ProgressPopup
from .utils import Utils
from omni.kit.menu.utils import MenuItemDescription
g_singleton = None
def get_instance():
global g_singleton
return g_singleton
class PublicExtension(omni.ext.IExt):
def on_startup(self):
self._main_window = None
self._context_menu_name = None
self._register_menus()
global g_singleton
g_singleton = self
def on_shutdown(self):
global g_singleton
g_singleton = None
content_window = self.get_content_window()
if content_window and self._context_menu_name:
content_window.delete_context_menu(self._context_menu_name)
self._context_menu_name = None
if self._main_window:
self._main_window.destroy()
self._main_window = None
def collect(self, filepath: str, finish_callback: Callable[[], None] = None) -> None:
"""
Collect a usd file.
Args:
filepath: Path to usd file to be collected.
"""
if not omni.usd.is_usd_writable_filetype(filepath):
self._show_file_not_supported_popup()
else:
self._show_main_window(filepath, finish_callback)
def _register_menus(self):
content_window = self.get_content_window()
if content_window:
self._context_menu_name = content_window.add_context_menu(
"Collect Asset", "upload.svg",
lambda b, c: self._on_menu_click(b, c),
omni.usd.is_usd_writable_filetype
)
def _collect():
stage = omni.usd.get_context().get_stage()
self.collect(stage.GetRootLayer().identifier)
def _enable_collect_menu():
stage = omni.usd.get_context().get_stage()
return stage is not None and not stage.GetRootLayer().anonymous
self._file_menu_list = [
MenuItemDescription(
name="Collect As...",
glyph="none.svg",
appear_after="Save Flattened As...",
enable_fn=_enable_collect_menu,
onclick_fn=_collect,
)
]
omni.kit.menu.utils.add_menu_items(self._file_menu_list, "File")
def _get_collection_dir(self, folder, usd_file_name):
stage_name = os.path.splitext(usd_file_name)[0]
if not folder.endswith("/"):
folder += "/"
folder = Utils.normalize_path(folder)
return f"{folder}Collected_{stage_name}"
def _show_folder_exist_popup(
self,
usd_path,
collect_dir,
usd_only,
flat_collection,
material_only,
texture_option,
finish_callback: Callable[[], None] = None,
):
def on_confirm():
self._start_collecting(
usd_path, collect_dir, usd_only, flat_collection, material_only, texture_option, finish_callback
)
def on_cancel():
self._show_main_window(usd_path)
PromptManager.post_simple_prompt(
"Overwrite",
"The target directory already exists, do you want to overwrite it?",
PromptButtonInfo("Confirm", on_confirm),
PromptButtonInfo("Cancel", on_cancel),
modal=False,
)
def _start_collecting(
self,
usd_path,
collect_folder,
usd_only,
flat_collection,
material_only,
texture_option,
finish_callback: Callable[[], None] = None,
):
progress_popup = self._show_progress_popup()
progress_popup.status_text = "Collecting dependencies..."
collector = Collector(
usd_path,
collect_folder,
usd_only,
flat_collection,
material_only,
texture_option=FlatCollectionTextureOptions(texture_option),
)
collector_weakref = weakref.ref(collector)
def on_cancel():
carb.log_info("Cancelling collector...")
if not collector_weakref():
return
collector_weakref().cancel()
progress_popup.set_cancel_fn(on_cancel)
def on_progress(step, total):
progress_popup.status_text = f"Collecting USD {os.path.basename(usd_path)}..."
if total != 0:
progress_popup.progress = float(step) / total
else:
progress_popup.progress = 0.0
def on_finish():
if finish_callback:
finish_callback()
progress_popup.hide()
self._refresh_current_directory()
if self._main_window:
self._main_window.set_collect_fn(None)
if not collector_weakref():
return
collector_weakref().destroy()
asyncio.ensure_future(collector.collect(on_progress, on_finish))
def _show_main_window(self, usd_path, finish_callback: Callable[[], None] = None):
if not self._main_window:
self._main_window = CollectMainWindow(None, None)
def on_collect(collect_folder, usd_only, flat_collection, material_only, texture_option):
existed = OmniClientWrapper.exists_sync(collect_folder)
if existed:
self._show_folder_exist_popup(
usd_path, collect_folder, usd_only, flat_collection, material_only, texture_option, finish_callback
)
else:
self._start_collecting(
usd_path, collect_folder, usd_only, flat_collection, material_only, texture_option, finish_callback
)
self._main_window.set_collect_fn(on_collect)
default_folder = self._get_collection_dir(os.path.dirname(usd_path), os.path.basename(usd_path))
self._main_window.show(default_folder)
def _on_menu_click(self, menu, value):
self.collect(value)
def _refresh_current_directory(self):
content_window = self.get_content_window()
if content_window:
content_window.refresh_current_directory()
def _show_progress_popup(self):
progress_popup = ProgressPopup("Collecting")
progress_popup.progress = 0
progress_popup.show()
return progress_popup
def _show_file_not_supported_popup(self):
PromptManager.post_simple_prompt("Warning", "Only USD file can be collected")
def get_content_window(self):
try:
import omni.kit.window.content_browser as content
return content.get_content_window()
except Exception as e:
pass
return None
| 7,097 |
Python
| 30.6875 | 119 | 0.588136 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/__init__.py
|
from .extension import PublicExtension, get_instance, CollectorFailureOptions, Collector, CollectorException
| 109 |
Python
| 53.999973 | 108 | 0.87156 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/file_picker.py
|
import omni
import os
from omni.kit.widget.prompt import PromptManager, PromptButtonInfo
from .omni_client_wrapper import OmniClientWrapper
from .filebrowser import FileBrowserMode
from .filebrowser.app_filebrowser import FileBrowserUI
class FilePicker:
def __init__(self, title, mode, file_type, filter_options, ok_button_title="Open"):
self._mode = mode
self._app = omni.kit.app.get_app()
self._open_handler = None
self._cancel_handler = None
self._ui_handler = FileBrowserUI(title, mode, file_type, filter_options, ok_button_title)
def _show_prompt(self, file_path, file_save_handler):
def on_confirm():
if file_save_handler:
file_save_handler(file_path)
PromptManager.post_simple_prompt(
f'{omni.kit.ui.get_custom_glyph_code("${glyphs}/exclamation.svg")} Overwrite',
f"File {os.path.basename(file_path)} already exists, do you want to overwrite it?",
PromptButtonInfo("Confirm", on_confirm),
PromptButtonInfo("Cancel")
)
def _save_and_prompt_if_exists(self, file_path, file_save_handler=None):
existed = OmniClientWrapper.exists_sync(file_path)
if existed:
self._show_prompt(file_path, file_save_handler)
elif file_save_handler:
file_save_handler(file_path)
def _on_file_open(self, path):
if self._mode == FileBrowserMode.SAVE:
self._save_and_prompt_if_exists(path, self._open_handler)
elif self._open_handler:
self._open_handler(path)
def _on_cancel_open(self):
if self._cancel_handler:
self._cancel_handler()
def set_file_selected_fn(self, file_open_handler):
self._open_handler = file_open_handler
def set_cancel_fn(self, cancel_handler):
self._cancel_handler = cancel_handler
def show(self, dir=None, filename=None):
if self._ui_handler:
if dir and OmniClientWrapper.exists_sync(dir):
self._ui_handler.set_current_directory(dir)
if filename:
self._ui_handler.set_current_filename(filename)
self._ui_handler.open(self._on_file_open, self._on_cancel_open)
def set_current_directory(self, dir):
if self._ui_handler:
if dir and OmniClientWrapper.exists_sync(dir):
self._ui_handler.set_current_directory(dir)
def set_current_filename(self, filename):
if self._ui_handler:
self._ui_handler.set_current_filename(filename)
def set_filebar_label_name(self, name):
if self._ui_handler:
self._ui_handler.set_filebar_label_name(name)
def destroy(self):
self._open_handler = None
self._cancel_handler = None
if self._ui_handler:
self._ui_handler.destroy()
self._ui_handler = None
| 2,900 |
Python
| 34.378048 | 97 | 0.628276 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/progress_popup.py
|
from omni import ui
class CustomProgressModel(ui.AbstractValueModel):
def __init__(self):
super().__init__()
self._value = 0.0
def set_value(self, value):
"""Reimplemented set"""
try:
value = float(value)
except ValueError:
value = None
if value != self._value:
# Tell the widget that the model is changed
self._value = value
self._value_changed()
def get_value_as_float(self):
return self._value
def get_value_as_string(self):
return str(int(self._value * 100)) + "%"
class ProgressPopup:
"""Creates a modal window with a status label and a progress bar inside.
Args:
title (str): Title of this window.
cancel_button_text (str): It will have a cancel button by default. This is the title of it.
cancel_button_fn (function): The callback after cancel button is clicked.
status_text (str): The status text.
min_value: The min value of the progress bar. It's 0 by default.
max_value: The max value of the progress bar. It's 100 by default.
dark_style: If it's to use dark style or light style. It's dark stye by default.
"""
def __init__(self, title, cancel_button_text="Cancel", cancel_button_fn=None, status_text="", modal=False):
self._status_text = status_text
self._title = title
self._cancel_button_text = cancel_button_text
self._cancel_button_fn = cancel_button_fn
self._progress_bar_model = None
self._modal = modal
self._popup = None
self._buttons = []
self._build_ui()
def destroy(self):
self._cancel_button_fn = None
self._progress_bar_model = None
for button in self._buttons:
button.set_clicked_fn(None)
self._popup = None
def __enter__(self):
self._popup.visible = True
return self
def __exit__(self, type, value, trace):
self._popup.visible = False
def set_cancel_fn(self, on_cancel_button_clicked):
self._cancel_button_fn = on_cancel_button_clicked
def set_progress(self, progress):
self._progress_bar.model.set_value(progress)
def get_progress(self):
return self._progress_bar.model.get_value_as_float()
progress = property(get_progress, set_progress)
def set_status_text(self, status_text):
self._status_label.text = status_text
def get_status_text(self):
return self._status_label.text
status_text = property(get_status_text, set_status_text)
def show(self):
self._popup.visible = True
def hide(self):
self._popup.visible = False
def is_visible(self):
return self._popup.visible
def _on_cancel_button_fn(self):
self.hide()
if self._cancel_button_fn:
self._cancel_button_fn()
def _build_ui(self):
self._popup = ui.Window(
self._title, visible=False,
auto_resize=True, height=0,
dockPreference=ui.DockPreference.DISABLED
)
self._popup.flags = (
ui.WINDOW_FLAGS_NO_COLLAPSE
| ui.WINDOW_FLAGS_NO_SCROLLBAR
| ui.WINDOW_FLAGS_NO_RESIZE
)
if self._modal:
self._popup.flags = self._popup.flags | ui.WINDOW_FLAGS_MODAL
with self._popup.frame:
with ui.VStack(height=0, width=400):
ui.Spacer(height=10)
with ui.HStack(height=0):
ui.Spacer()
self._status_label = ui.Label(self._status_text, width=0, height=0)
ui.Spacer()
ui.Spacer(height=10)
with ui.HStack(height=0):
ui.Spacer(width=40)
self._progress_bar_model = CustomProgressModel()
self._progress_bar = ui.ProgressBar(
self._progress_bar_model, width=320, style={"color": 0xFFFF9E3D}
)
ui.Spacer(width=40)
ui.Spacer(height=10)
with ui.HStack(height=0):
ui.Spacer(height=0)
cancel_button = ui.Button(self._cancel_button_text, width=120, height=0)
cancel_button.set_clicked_fn(self._on_cancel_button_fn)
self._buttons.append(cancel_button)
ui.Spacer(height=0)
ui.Spacer(width=0, height=10)
| 4,521 |
Python
| 32.007299 | 111 | 0.564919 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/utils.py
|
import re
import omni
from urllib.parse import unquote
class Utils:
MDL_RE = re.compile("^.*\\.mdl?$", re.IGNORECASE)
# References https://gitlab-master.nvidia.com/omniverse/rtxdev/kit/blob/d37f0906c58cb1a5d8591f9e47125b4154b19b88/rendering/source/plugins/common/UDIM.h#L22
# for regex details to detect udim textures.
UDIM_MARKER_RE = re.compile("^.*(<UDIM>|<UVTILE0>|<UVTILE1>).*")
UDIM_GROUP_RE = re.compile("^(.*)(<UDIM>|<UVTILE0>|<UVTILE1>)(.*)")
@staticmethod
def normalize_path(path):
path = omni.client.normalize_url(path)
# Hard-decoding url currently since combine_urls will encode url
path = unquote(path)
return path.replace("\\", "/")
@staticmethod
def compute_absolute_path(base_path, path):
# Handles old omni path
if path.startswith("omni:"):
path = path[5:]
absolute_path = omni.client.combine_urls(base_path, path)
return Utils.normalize_path(absolute_path)
@staticmethod
def is_material(path):
if not path:
return False
path = Utils.remove_query_from_url(path)
if Utils.MDL_RE.match(path):
return True
return False
@staticmethod
def is_local_path(path):
if not path:
return False
client_url = omni.client.break_url(path)
return client_url and client_url.is_raw
@staticmethod
def is_omniverse_path(path):
return path and path.startswith("omniverse://")
@staticmethod
def remove_query_from_url(url):
if not url:
return url
client_url = omni.client.break_url(url)
url_without_query = omni.client.make_url(
scheme=client_url.scheme,
user=client_url.user,
host=client_url.host,
port=client_url.port,
path=client_url.path,
query=None,
fragment=client_url.fragment,
)
url_without_query = url_without_query.replace("\\", "/")
return url_without_query
@staticmethod
def is_udim_texture(path):
if not path:
return False
path = Utils.remove_query_from_url(path)
url = omni.client.break_url(path)
if url and Utils.UDIM_MARKER_RE.match(url.path):
return True
return False
@staticmethod
def is_udim_wildcard_texture(path, udim_texture_path):
if not path or not udim_texture_path:
return False
udim_path = Utils.remove_query_from_url(udim_texture_path)
url = omni.client.break_url(udim_path)
groups = Utils.UDIM_GROUP_RE.match(url.path)
if not groups:
return False
base_path = groups[1]
suffix_path = groups[3]
wildcard_re = re.compile(re.escape(base_path) + "((\\d\\d\\d\\d)|(_u\\d*_v\\d*))" + suffix_path)
path = Utils.remove_query_from_url(path)
url = omni.client.break_url(path)
if wildcard_re.match(url.path):
return True
return False
@staticmethod
def make_relative_path(relative_to, path):
relative_path = omni.client.make_relative_url(relative_to, path)
return Utils.normalize_path(relative_path)
| 3,259 |
Python
| 28.107143 | 159 | 0.602332 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/icons.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from pathlib import Path
from .singleton import Singleton
@Singleton
class Icons:
"""A singleton that scans the icon folder and returns the icon depending on the type"""
def __init__(self):
self._current_path = Path(__file__).parent
self._icon_path = self._current_path.parent.parent.parent.parent.joinpath("icons")
self._icons = {icon.stem: icon for icon in self._icon_path.glob("*.png")}
def get(self, name, default=None):
"""Checks the icon cache and returns the icon if exists"""
found = self._icons.get(name)
if not found and default:
found = self._icons.get(default)
if found:
return str(found)
| 1,132 |
Python
| 35.548386 | 91 | 0.699647 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/collector.py
|
import os
import asyncio
import omni
import omni.usd
import carb
import traceback
from enum import IntFlag, Enum
from pxr import Sdf, Usd, UsdUtils, UsdShade, UsdLux, Tf
from .omni_client_wrapper import OmniClientWrapper
from .utils import Utils
from .async_utils import aio_open_layer, aio_replace_all, aio_save_layer
from .mdl_parser import MDLParser
from .async_utils import wrap
class CollectorFailureOptions(IntFlag):
"""Options to customize failure options"""
SILENT = 0 # Silent for all failures except root USD.
EXTERNAL_USD_REFERENCES = 1 # Throws exception if any external USD file is not found.
OTHER_EXTERNAL_REFERENCES = 4 # Throws exception if external references other than all above are missing.
class CollectorException(Exception):
def __init__(self, error: str):
self._error = error
def __str__(self):
return self._error
class CollectorTaskType:
"""Task type"""
READ_TASK = 0
WRITE_TASK = 1
COPY_TASK = 2
RESOLVE_TASK = 3
class FlatCollectionTextureOptions(Enum):
"""Collection options for textures under 'Flat Collection' mode"""
BY_MDL = 0 # group textures by MDL
BY_USD = 1 # group textures by USD
FLAT = 2 # all textures will be under the same hierarchy, flat
class Collector:
"""Collect stage related asset to {target_folder}/collected_stagename/}.
Args:
usd_path (str): The usd stage to be collected.
collect_dir (str): The target dir to collect the usd stage to.
usd_only (bool): Collects usd files only or not. It will ignore all asset types.
flat_collection (bool): Collects stage without keeping the original dir structure.
material_only (bool): Collects material and textures only or not. It will ignore all other asset types.
skip_existing (bool): If files already exist in the target location, don't copy again. Be careful of corrupt files
texture_option (FlatCollectionTextureOptions): Specifies how textures are grouped in flat collection mode.
This is to avoid name collision which results in textures overwriting each other in the cases where textures
for different assets are not uniquely named.
If both `usd_only` and `material_only` are true, it will collect all.
"""
def __init__(
self,
usd_path: str,
collect_dir: str,
usd_only: bool,
flat_collection: bool,
material_only: bool = False,
failure_options=CollectorFailureOptions.SILENT,
skip_existing: bool = False,
max_concurrent_tasks=64,
texture_option=FlatCollectionTextureOptions.BY_MDL,
):
self._usd_path = Utils.normalize_path(usd_path)
self._collect_dir = Utils.normalize_path(collect_dir)
if not self._collect_dir.endswith("/"):
self._collect_dir += "/"
self._usd_only = usd_only and not material_only
self._material_only = material_only and not usd_only
self._flat_collection = flat_collection
self._texture_option = texture_option
self._finished = False
self._cancelled = False
self.MAX_CONCURRENT_TASKS = max_concurrent_tasks
self._current_tasks = set([])
self._finished_callback = None
self._progress_callback = None
self._unique_path_name = {} # Records the count key that appears in the collected paths to generate unique name
self._source_target_path_mapping = {} # It records source to target
self._failure_options = failure_options
self._skip_existing = skip_existing
self._layer_store = {}
self._mdl_parsers = {}
self._sublayer_offsets = {}
self._other_asset_paths = set({})
self._current_progress = 0
self._total_steps = 0
self._all_read_paths = set({})
def destroy(self):
self._finished_callback = None
self._progress_callback = None
def _caculate_flat_target_path(self, path, parent_asset=None):
target_dir = self._collect_dir
master_usd = Utils.normalize_path(path) == self._usd_path
material_only = self._material_only
file_url = omni.client.break_url(path)
target_url = omni.client.break_url(target_dir)
file_path = file_url.path
file_name = os.path.basename(file_path)
if omni.usd.is_usd_writable_filetype(path) and master_usd:
int_dir = ""
else:
if not material_only:
int_dir = "SubUSDs/"
else:
int_dir = ""
if Utils.is_material(file_name):
int_dir = f"{int_dir}materials/"
elif not omni.usd.is_usd_writable_filetype(file_name):
int_dir = f"{int_dir}textures/"
# OM-52799 add options to group textures by MDL / USD assets to avoid name collision causing overwrites
if parent_asset:
parent_name, _ = os.path.splitext(os.path.basename(parent_asset))
# currently not including the file extension in parent folder names, but could add it in if it is
# more clear to show the ext as a suffix to the folder name
int_dir += f"{parent_name}/"
target_path = target_url.path + int_dir + file_name
if file_url.query:
branch_checkpoint = omni.client.get_branch_and_checkpoint_from_query(file_url.query)
if branch_checkpoint:
branch, checkpoint = branch_checkpoint
file_path, ext = os.path.splitext(target_path)
if not branch:
branch = "default"
target_path = f"{file_path}__{branch}__v{checkpoint}{ext}"
target_path = omni.client.make_url(
scheme=target_url.scheme,
user=target_url.user,
host=target_url.host,
port=target_url.port,
path=target_path,
query=None,
fragment=None,
)
return Utils.normalize_path(target_path)
# All paths must be absolute path
def _calculate_target_path(self, file_path, parent_asset=None):
file_path = Utils.normalize_path(file_path)
if self._flat_collection:
return self._caculate_flat_target_path(file_path, parent_asset=parent_asset)
target_dir = self._collect_dir
if not target_dir.endswith("/"):
target_dir += "/"
stage_path = self._usd_path
stage_url = omni.client.break_url(stage_path)
if not stage_url.scheme:
stage_path_with_scheme = "file://" + stage_path
else:
stage_path_with_scheme = stage_path
file_url = omni.client.break_url(file_path)
if not file_url.scheme:
file_path_with_shceme = "file://" + file_path
else:
file_path_with_shceme = file_path
stage_url = omni.client.break_url(stage_path_with_scheme)
file_url = omni.client.break_url(file_path_with_shceme)
target_url = omni.client.break_url(target_dir)
if stage_url.scheme != file_url.scheme or stage_url.host != file_url.host:
file_path = file_url.path.lstrip("/")
if file_url.host:
target_path = target_url.path + file_url.host + "/" + file_path
else:
target_path = target_url.path + file_path
else:
stage_url_path = stage_url.path.replace("//", "/")
file_url_path = file_url.path.replace("//", "/")
common_path = os.path.commonpath([os.path.dirname(stage_url_path), os.path.dirname(file_url_path)])
common_path = common_path.replace("\\", "/")
file_path = file_url_path[len(common_path) :].lstrip("/")
target_path = target_url.path + file_path
if file_url.query:
branch_checkpoint = omni.client.get_branch_and_checkpoint_from_query(file_url.query)
if branch_checkpoint:
branch, checkpoint = branch_checkpoint
file_name, ext = os.path.splitext(target_path)
if not branch:
branch = "default"
target_path = f"{file_name}__{branch}__v{checkpoint}{ext}"
target_path = omni.client.make_url(
scheme=target_url.scheme,
user=target_url.user,
host=target_url.host,
port=target_url.port,
path=target_path,
query=None,
fragment=None,
)
return Utils.normalize_path(target_path)
async def _get_total_steps(self):
stage_path = self._usd_path
collect_usd_only = self._usd_only
carb.log_info(f"Downloading and collecting dependencies: {stage_path}...")
# Pre-warming to download all USDs and MDLs in parallel.
target_path = self._calculate_target_path(stage_path)
self._source_target_path_mapping[stage_path] = target_path
if target_path and target_path == stage_path:
self._raise_or_log(
stage_path, f"Failed to collect layer {stage_path} as it tries to overwrite itself.", True
)
await self.__add_read_task(stage_path)
# Cancelled
if not await self.wait_all_unfinished_tasks(True):
return None
if collect_usd_only:
total = len(self._layer_store)
else:
total_textures = 0
for parser in self._mdl_parsers.values():
raw_to_absolute_texture_paths, _ = await parser.parse()
total_textures += len(raw_to_absolute_texture_paths)
total_material_assets = len(self._mdl_parsers) + total_textures
if self._material_only:
total = len(self._other_asset_paths) + total_material_assets
else:
total = len(self._layer_store) + len(self._other_asset_paths) + total_material_assets
return total
def _remove_prim_spec(self, layer: Sdf.Layer, prim_spec_path: str):
prim_spec = layer.GetPrimAtPath(prim_spec_path)
if not prim_spec:
return False
if prim_spec.nameParent:
name_parent = prim_spec.nameParent
else:
name_parent = layer.pseudoRoot
if not name_parent:
return False
name = prim_spec.name
if name in name_parent.nameChildren:
del name_parent.nameChildren[name]
def _remove_all_materials_and_bindings(self, stage_path):
stage = Usd.Stage.Open(stage_path)
if not stage:
return
to_be_removed = []
for prim in stage.Traverse():
if prim.IsA(UsdShade.Material):
to_be_removed.append(prim)
binding_api = UsdShade.MaterialBindingAPI(prim)
if binding_api:
binding_api.UnbindAllBindings()
if prim.IsA(UsdLux.DomeLight):
dome_light = UsdLux.DomeLight(prim)
dome_light.GetTextureFileAttr().Set("")
for prim in to_be_removed:
to_remove_paths = []
if prim:
for prim_spec in prim.GetPrimStack():
layer = prim_spec.layer
to_remove_paths.append((layer, prim_spec.path))
for item in to_remove_paths:
self._remove_prim_spec(item[0], item[1])
stage.Save()
def __modify_external_references(self, original_layer_identifier, target_layer):
def modifiy_paths_cb(path):
absolute_path = Utils.compute_absolute_path(original_layer_identifier, path)
target_path = self._source_target_path_mapping.get(absolute_path, None)
if not target_path:
return path
return Utils.make_relative_path(target_layer.identifier, target_path)
try:
UsdUtils.ModifyAssetPaths(target_layer, modifiy_paths_cb)
except Exception as e:
carb.log_error(f"Failed to modify asset paths {target_layer.identifier}:" + str(e))
LAYER_OMNI_CUSTOM_KEY = "omni_layer"
LAYER_MUTENESS_CUSTOM_KEY = "muteness"
custom_data = target_layer.customLayerData
if LAYER_OMNI_CUSTOM_KEY in custom_data:
omni_data = custom_data[LAYER_OMNI_CUSTOM_KEY]
if LAYER_MUTENESS_CUSTOM_KEY in omni_data:
new_muteness_data = {}
for path, muted in omni_data[LAYER_MUTENESS_CUSTOM_KEY].items():
absolute_path = Utils.compute_absolute_path(original_layer_identifier, path)
target_path = self._source_target_path_mapping.get(absolute_path, None)
if target_path:
target_path = Utils.make_relative_path(target_layer.identifier, target_path)
new_muteness_data[target_path] = muted
if new_muteness_data:
omni_data[LAYER_MUTENESS_CUSTOM_KEY] = new_muteness_data
custom_data[LAYER_OMNI_CUSTOM_KEY] = omni_data
target_layer.customLayerData = custom_data
def __mapping_source_path(self, source_path, parent_asset=None):
if source_path in self._source_target_path_mapping:
return False
# OM-52799 add options to group textures by MDL / USD assets to avoid name collision causing overwrites
target_path = self._calculate_target_path(source_path, parent_asset=parent_asset)
target_path = self._make_sure_unique_path(target_path)
self._source_target_path_mapping[source_path] = target_path
return True
# Gets external references.
async def __get_external_references(self, original_layer_identifier, target_layer):
stage_path = self._usd_path
try:
sublayer_paths, reference_paths, payload_paths = UsdUtils.ExtractExternalReferences(target_layer.identifier)
except Exception as e:
carb.log_error(f"Failed to collect {target_layer.identifier}: " + str(e))
sublayer_paths = []
reference_paths = []
payload_paths = []
all_usd_paths = set()
all_mdl_paths = set()
other_asset_paths = set()
async def track_path(path):
absolute_path = Utils.compute_absolute_path(original_layer_identifier, path)
if absolute_path in self._source_target_path_mapping:
return
if Utils.is_material(path):
existed = await OmniClientWrapper.exists(absolute_path)
# OM-44975: If it's not existed locally and it cannot be resolved with search paths,
# just leave the path as it is.
if not existed:
absolute_path = Utils.compute_absolute_path(stage_path, path)
# OM-43965: resolve agaist stage path.
existed = await OmniClientWrapper.exists(absolute_path)
if not existed:
return
mapping_kwargs = {}
if Utils.is_udim_texture(absolute_path):
all_asset_paths = await self.__populate_udim_textures(absolute_path)
for path in all_asset_paths:
self.__mapping_source_path(path, **mapping_kwargs)
else:
all_asset_paths = [absolute_path]
if omni.usd.is_usd_writable_filetype(absolute_path):
all_usd_paths.add(absolute_path)
elif Utils.is_material(absolute_path):
all_mdl_paths.add(absolute_path)
else:
# should only add parent asset option in mapping if the current path is not USD or MDL
if self._flat_collection and self._texture_option is FlatCollectionTextureOptions.BY_USD:
# do not add the root stage itself as a parent
if original_layer_identifier != self._usd_path:
mapping_kwargs["parent_asset"] = original_layer_identifier
# Adds udim mapping but not into copy list.
if Utils.is_udim_texture(absolute_path):
all_asset_paths = await self.__populate_udim_textures(absolute_path)
for path in all_asset_paths:
self.__mapping_source_path(path, **mapping_kwargs)
else:
all_asset_paths = [absolute_path]
other_asset_paths.update(all_asset_paths)
self.__mapping_source_path(absolute_path, **mapping_kwargs)
async def check_paths(paths):
tasks = []
for path in paths:
future = asyncio.ensure_future(track_path(path))
tasks.append(future)
if tasks:
await asyncio.wait(tasks, return_when=asyncio.ALL_COMPLETED)
await check_paths(sublayer_paths)
await check_paths(reference_paths)
await check_paths(payload_paths)
return all_usd_paths, all_mdl_paths, other_asset_paths
async def open_or_create_layer(self, layer_path, clear=True):
# WA to fix OM-33212
await omni.client.create_folder_async(os.path.dirname(layer_path))
layer = await aio_open_layer(layer_path)
if not layer:
layer = Sdf.Layer.CreateNew(layer_path)
elif clear:
layer.Clear()
return layer
async def add_copy_task(self, source, target, skip_if_existed=False):
if self._skip_existing and await OmniClientWrapper.exists(target):
carb.log_info(f"Asset file {target} already exists, skipping copy")
else:
carb.log_info(f"Adding copy task from {source} to {target}")
task = asyncio.ensure_future(OmniClientWrapper.copy(source, target, True))
task.source = source
task.target = target
task.task_type = CollectorTaskType.COPY_TASK
self._current_tasks.add(task)
if len(self._current_tasks) >= self.MAX_CONCURRENT_TASKS:
await self.wait_all_unfinished_tasks()
async def add_write_task(self, target, content):
carb.log_info(f"Adding write task to {target}")
task = asyncio.ensure_future(OmniClientWrapper.write(target, content))
task.task_type = CollectorTaskType.WRITE_TASK
task.source = None
task.target = target
self._current_tasks.add(task)
if len(self._current_tasks) >= self.MAX_CONCURRENT_TASKS:
await self.wait_all_unfinished_tasks()
async def __add_layer_resolve_task(self, source_layer_path, target_layer):
carb.log_info(f"Adding layer resolve task for {target_layer.identifier}")
task = asyncio.ensure_future(self.__resolve_layer(source_layer_path, target_layer))
task.task_type = CollectorTaskType.RESOLVE_TASK
task.source = target_layer.identifier
task.target = None
self._current_tasks.add(task)
if len(self._current_tasks) >= self.MAX_CONCURRENT_TASKS:
await self.wait_all_unfinished_tasks()
async def __resolve_layer(self, source_layer_path, target_layer):
# Resolve all external assets
__aio_modify_external_references = wrap(self.__modify_external_references)
await __aio_modify_external_references(source_layer_path, target_layer)
# OM-40291: Copy sublayer offsets.
sublayer_offsets = self._sublayer_offsets.get(source_layer_path, None)
if sublayer_offsets:
for i in range(len(sublayer_offsets)):
target_layer.subLayerOffsets[i] = sublayer_offsets[i]
return await aio_save_layer(target_layer)
async def __open_and_analyze_layer(self, source_path, target_path):
if self._material_only:
target_layer = await aio_open_layer(source_path)
else:
# OM-52207: copy it firstly to keep tags for omniverse path.
success = await OmniClientWrapper.copy(source_path, target_path, True)
if not success:
return False
try:
target_layer = await self.open_or_create_layer(target_path, False)
except Tf.ErrorException:
# WA for OM-52094: usda in server may be saved as usdc format,
# which cannot be opened with USD library locally.
# The solution here is to rename it as .usd.
target_layer = None
root, _ = os.path.splitext(target_path)
renamed_usd = root + ".usd"
success = await OmniClientWrapper.copy(target_path, renamed_usd)
if success:
await OmniClientWrapper.delete(target_path)
target_layer = await self.open_or_create_layer(renamed_usd, False)
self._source_target_path_mapping[source_path] = renamed_usd
if not target_layer:
return False
self._layer_store[source_path] = target_layer
if target_layer.subLayerOffsets:
self._sublayer_offsets[source_path] = target_layer.subLayerOffsets.copy()
carb.log_info(f"Collecting dependencies for usd {source_path}...")
all_usd_paths, all_mdl_paths, all_other_paths = await self.__get_external_references(source_path, target_layer)
for path in all_usd_paths:
if self._cancelled:
break
await self.__add_read_task(path)
if self._usd_only:
self._remove_all_materials_and_bindings(target_layer.identifier)
else:
for path in all_mdl_paths:
if self._cancelled:
break
await self.__add_read_task(path)
self._other_asset_paths.update(all_other_paths)
return True
async def __populate_udim_textures(self, udim_texture_path):
src_dir = os.path.dirname(udim_texture_path)
if not src_dir.endswith("/"):
src_dir = src_dir + "/"
result, entries = await omni.client.list_async(src_dir)
if result != omni.client.Result.OK:
self._raise_or_log(
udim_texture_path, f"Failed to list UDIM textures {udim_texture_path}, error code: {result}"
)
texture_paths = []
for entry in entries:
texture_path = Utils.compute_absolute_path(src_dir, entry.relative_path)
if Utils.is_udim_wildcard_texture(texture_path, udim_texture_path):
texture_paths.append(texture_path)
return texture_paths
async def __open_and_analyze_mdl(self, path, target_path):
# OM-52207: copy it firstly to keep tags for omniverse path.
if Utils.is_omniverse_path(path):
success = await OmniClientWrapper.copy(path, target_path, True)
if not success:
return False
content = await OmniClientWrapper.read(path)
if not content:
return False
mdl_parser = MDLParser(path, content)
self._mdl_parsers[path] = mdl_parser
carb.log_info(f"Collecting dependencies for mdl {path}...")
raw_to_absolute_texture_paths, imports = await mdl_parser.parse()
mapping_kwargs = {}
if self._flat_collection and self._texture_option is FlatCollectionTextureOptions.BY_MDL:
mapping_kwargs["parent_asset"] = path
for absolute_texture_path in raw_to_absolute_texture_paths.values():
if not self.__mapping_source_path(absolute_texture_path, **mapping_kwargs):
continue
if Utils.is_udim_texture(absolute_texture_path):
all_asset_paths = await self.__populate_udim_textures(absolute_texture_path)
for path in all_asset_paths:
self.__mapping_source_path(path, **mapping_kwargs)
for mdl_import in imports:
if self._cancelled:
break
absolute_import_path = mdl_import.package_path
if not await OmniClientWrapper.exists(absolute_import_path):
continue
self.__mapping_source_path(absolute_import_path)
await self.__add_read_task(absolute_import_path)
return True
async def __add_read_task(self, path):
if path in self._all_read_paths:
return
self._all_read_paths.add(path)
if path in self._layer_store or path in self._mdl_parsers:
return
carb.log_info(f"Adding read task to {path}")
is_usd_type = omni.usd.is_usd_writable_filetype(path)
is_mdl_path = Utils.is_material(path)
target_path = self._source_target_path_mapping.get(path)
if is_usd_type:
task = asyncio.ensure_future(self.__open_and_analyze_layer(path, target_path))
elif is_mdl_path and not self._usd_only:
task = asyncio.ensure_future(self.__open_and_analyze_mdl(path, target_path))
else:
return
task.task_type = CollectorTaskType.READ_TASK
task.source = path
task.target = None
self._current_tasks.add(task)
if len(self._current_tasks) >= self.MAX_CONCURRENT_TASKS:
await self.wait_all_unfinished_tasks()
def __cancel_all_tasks(self):
try:
self._progress_callback = None
for task in self._current_tasks:
task.cancel()
except Exception:
pass
finally:
self._current_tasks.clear()
async def wait_all_unfinished_tasks(self, all_completed=False):
if len(self._current_tasks) == 0:
return True
carb.log_info(f"Waiting for {len(self._current_tasks)} tasks...")
while len(self._current_tasks) > 0:
if self._cancelled:
self.__cancel_all_tasks()
return False
try:
done, _ = await asyncio.wait(self._current_tasks, return_when=asyncio.FIRST_COMPLETED)
failed_tasks = set()
for task in done:
if task not in self._current_tasks:
continue
if task.task_type != CollectorTaskType.READ_TASK:
self.__report_one_progress()
result = task.result()
if not result:
failed_tasks.add(task)
if task.task_type == CollectorTaskType.COPY_TASK:
self._raise_or_log(task.source, f"Failed to move from {task.source} to {task.target}.")
elif task.task_type == CollectorTaskType.WRITE_TASK:
self._raise_or_log(task.target, f"Failed to write {task.target}.")
elif task.task_type == CollectorTaskType.READ_TASK:
self._raise_or_log(task.source, f"Failed to read {task.source} as it's not existed.")
elif task.task_type == CollectorTaskType.RESOLVE_TASK:
self._raise_or_log(task.source, f"Failed to resolve layer {task.source}.")
self._current_tasks.discard(task)
except CollectorException as e:
raise e
except Exception:
traceback.print_exc()
if not all_completed:
break
await asyncio.sleep(0.1)
carb.log_info(f"Waiting for unfinished done, left {len(self._current_tasks)} tasks...")
return True
def is_finished(self):
return self._finished
def cancel(self):
self._cancelled = True
self.__cancel_all_tasks()
if self._finished_callback:
self._finished_callback()
def _make_sure_unique_path(self, path):
# Generates unique path name
if Utils.is_udim_texture(path):
return path
path = Utils.normalize_path(path)
while True:
index = self._unique_path_name.get(path, -1)
if index == -1:
self._unique_path_name[path] = 0
break
else:
index += 1
self._unique_path_name[path] = index
file_path, ext = os.path.splitext(path)
path = file_path + "_" + str(index) + ext
self._unique_path_name[path] = 0
return path
def _raise_or_log(self, path, error, force_raise=False):
is_usd_type = omni.usd.is_usd_writable_filetype(path)
has_usd_failure_option = self._failure_options & CollectorFailureOptions.EXTERNAL_USD_REFERENCES
has_other_failure_option = self._failure_options & CollectorFailureOptions.OTHER_EXTERNAL_REFERENCES
if force_raise or (is_usd_type and has_usd_failure_option) or (not is_usd_type and has_other_failure_option):
raise CollectorException(error)
else:
carb.log_warn(error)
async def collect(self, progress_callback, finish_callback):
def __reset():
self._layer_store = {}
self._mdl_parsers = {}
self._sublayer_offsets = {}
self._other_asset_paths = set()
self._unique_path_name.clear()
self._source_target_path_mapping = {}
self._current_progress = 0
self._total_steps = 0
self._progress_callback = None
self._finished_callback = None
self._all_read_paths.clear()
try:
__reset()
self._finished = False
self._finished_callback = finish_callback
self._progress_callback = progress_callback
await self._collect_internal()
finally:
self._finished = True
if finish_callback:
finish_callback()
__reset()
def __report_one_progress(self):
self._current_progress += 1
if self._current_progress >= self._total_steps:
self._current_progress = self._total_steps
if self._progress_callback:
self._progress_callback(self._current_progress, self._total_steps)
async def _collect_internal(self):
carb.log_info(f"Collecting stage {self._usd_path} to {self._collect_dir}...")
total = await self._get_total_steps()
if total == 0:
raise CollectorException(f"Failed to collect {self._usd_path} as it cannot be opened.")
elif total is None:
carb.log_info(f"Collecting stage {self._usd_path} to {self._collect_dir} is cancelled.")
return
# Add one more step to wait for tasks to be done.
self._total_steps = total + 1
carb.log_info(f"Starting to collect: total steps {self._total_steps} found...")
if not self._material_only:
for source_layer_path, target_layer in self._layer_store.items():
carb.log_info(f"Modifying external references for {target_layer.identifier}...")
if self._cancelled:
break
await self.__add_layer_resolve_task(source_layer_path, target_layer)
if not self._usd_only:
for mdl_absolute_path, mdl_parser in self._mdl_parsers.items():
if self._cancelled:
break
carb.log_info(f"Collecting mdl {mdl_absolute_path}...")
# Per MDL.
processed_texture_path = set([])
mdl_target_path = self._source_target_path_mapping.get(mdl_absolute_path)
mdl_content = mdl_parser.content
raw_to_absolute_texture_paths, mdl_imports = await mdl_parser.parse()
for raw_texture_path, absolute_texture_path in raw_to_absolute_texture_paths.items():
if self._cancelled:
break
if absolute_texture_path in processed_texture_path:
continue
processed_texture_path.add(absolute_texture_path)
texture_target_path = self._source_target_path_mapping.get(absolute_texture_path)
relative_path = Utils.make_relative_path(mdl_target_path, texture_target_path)
mdl_content = await aio_replace_all(
mdl_content, f'texture_2d("{raw_texture_path}', f'texture_2d("{relative_path}'
)
mdl_content = await aio_replace_all(
mdl_content, f'texture_3d("{raw_texture_path}', f'texture_3d("{relative_path}'
)
mdl_content = await aio_replace_all(
mdl_content, f'texture_cube("{raw_texture_path}', f'texture_cube("{relative_path}'
)
mdl_content = await aio_replace_all(
mdl_content, f'texture_ptex("{raw_texture_path}', f'texture_ptex("{relative_path}'
)
carb.log_info(f"Moving texture file {absolute_texture_path} to {texture_target_path}")
await self.add_copy_task(absolute_texture_path, texture_target_path, self._skip_existing)
# handl mdls that's imported
for mdl_import in mdl_imports:
if self._cancelled:
break
import_target_path = self._source_target_path_mapping.get(mdl_import.package_path)
# It's not mapped so it's not existed.
if not import_target_path:
continue
relative_path = Utils.make_relative_path(mdl_target_path, import_target_path)
import_clause = mdl_import.import_clause
if relative_path.endswith(".mdl"):
relative_path = relative_path[:-4]
while relative_path.startswith("./"):
relative_path = relative_path[2:]
relative_path = relative_path.replace("/", "::")
if mdl_import.module_preset:
# OM-7604
has_prefix = False
while relative_path.startswith("..::"):
has_prefix = True
relative_path = relative_path[4:]
if has_prefix and relative_path:
relative_path = f"::{relative_path}"
import_clause = import_clause.replace(mdl_import.import_package, relative_path)
mdl_content = await aio_replace_all(mdl_content, mdl_import.import_clause, import_clause)
if self._flat_collection:
import_package = mdl_import.import_package
while import_package.startswith(".::") or import_package.startswith("..::"):
if import_package.startswith(".::"):
import_package = import_package[3:]
else:
import_package = import_package[4:]
# OM-37410: It's possible that function is referenced with full module path.
if import_package:
if not import_package.startswith("::"):
import_package = "::" + import_package
if not relative_path.startswith("::"):
relative_path = f"::{relative_path}"
mdl_content = await aio_replace_all(mdl_content, import_package, relative_path)
await self.add_write_task(mdl_target_path, mdl_content)
# Copy all external assets except USD and MDLs to target path
for absolute_asset_path in self._other_asset_paths:
if self._cancelled:
break
asset_target_path = self._source_target_path_mapping.get(absolute_asset_path)
carb.log_info(f"Moving asset file from {absolute_asset_path} to {asset_target_path}")
await self.add_copy_task(absolute_asset_path, asset_target_path, self._skip_existing)
if not await self.wait_all_unfinished_tasks(True):
carb.log_info("Collecting is cancelled.")
else:
carb.log_info("Collecting is finished.")
| 36,492 |
Python
| 40.469318 | 122 | 0.578291 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/omni_client_wrapper.py
|
import os
import traceback
import asyncio
import carb
import omni.client
import stat
def _encode_content(content):
if type(content) == str:
payload = bytes(content.encode("utf-8"))
elif type(content) != type(None):
payload = bytes(content)
else:
payload = bytes()
return payload
class OmniClientWrapper:
@staticmethod
async def exists(path):
try:
result, entry = await omni.client.stat_async(path)
return result == omni.client.Result.OK
except Exception:
return False
@staticmethod
def exists_sync(path):
try:
result, entry = omni.client.stat(path)
return result == omni.client.Result.OK
except Exception:
return False
@staticmethod
async def write(path: str, content):
carb.log_info(f"Writing {path}...")
try:
result = await omni.client.write_file_async(path, _encode_content(content))
if result != omni.client.Result.OK:
carb.log_warn(f"Cannot write {path}, error code: {result}.")
return False
except Exception as e:
carb.log_warn(f"Cannot write {path}: {str(e)}.")
return False
finally:
carb.log_info(f"Writing {path} done...")
return True
@staticmethod
async def delete(path: str):
carb.log_info(f"Removing {path}...")
try:
result = await omni.client.delete_async(path)
if result != omni.client.Result.OK:
carb.log_warn(f"Cannot remove {path}, error code: {result}.")
return False
except Exception:
carb.log_warn(f"Cannot delete {path}: {str(e)}.")
return False
return True
@staticmethod
async def set_write_permission(src_path: str):
# It can change ACIs for o
url = omni.client.break_url(src_path)
# Local path
try:
if url.is_raw:
st = os.stat(src_path)
os.chmod(src_path, st.st_mode | stat.S_IWRITE)
elif src_path.startswith("omniverse://"):
result, server_info = await omni.client.get_server_info_async(src_path)
if result != omni.client.Result.OK:
return False
user_acl = omni.client.AclEntry(
server_info.username,
omni.client.AccessFlags.READ | omni.client.AccessFlags.WRITE | omni.client.AccessFlags.ADMIN
)
result = await omni.client.set_acls_async(src_path, [user_acl])
return result == omni.client.Result.OK
except Exception as e:
carb.log_warn(f"Failed to set write permission for url {src_path}: {str(e)}.")
return False
@staticmethod
async def copy(src_path: str, dest_path: str, set_target_writable_if_read_only=False):
carb.log_info(f"Copying from {src_path} to {dest_path}...")
try:
result = await omni.client.copy_async(src_path, dest_path, omni.client.CopyBehavior.OVERWRITE)
if result != omni.client.Result.OK:
carb.log_warn(f"Cannot copy from {src_path} to {dest_path}, error code: {result}.")
return False
else:
if set_target_writable_if_read_only:
await OmniClientWrapper.set_write_permission(dest_path)
return True
except Exception as e:
carb.log_warn(f"Cannot copy {src_path} to {dest_path}: {str(e)}.")
return False
@staticmethod
async def read(src_path: str):
carb.log_info(f"Reading {src_path}...")
try:
result, version, content = await omni.client.read_file_async(src_path)
if result == omni.client.Result.OK:
return memoryview(content).tobytes()
else:
carb.log_warn(f"Cannot read {src_path}, error code: {result}.")
except Exception as e:
carb.log_warn(f"Cannot read {src_path}: {str(e)}.")
finally:
carb.log_info(f"Reading {src_path} done.")
return None
@staticmethod
async def create_folder(path):
carb.log_info(f"Creating dir {path}...")
result = await omni.client.create_folder_async(path)
return result == omni.client.Result.OK
| 4,455 |
Python
| 32.007407 | 112 | 0.562738 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/filebrowser/__init__.py
|
class FileBrowserSelectionType:
FILE_ONLY = 0
DIRECTORY_ONLY = 1
ALL = 2
class FileBrowserMode:
OPEN = 0
SAVE = 1
| 136 |
Python
| 12.699999 | 31 | 0.632353 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/filebrowser/app_filebrowser.py
|
import asyncio
import re
import omni.ui
import omni.client
from omni.kit.window.filepicker import FilePickerDialog
from omni.kit.widget.filebrowser import FileBrowserItem
from . import FileBrowserSelectionType, FileBrowserMode
class FileBrowserUI:
def __init__(
self, title: str, mode: FileBrowserMode,
selection_type: FileBrowserSelectionType,
filter_options, ok_button_title="Open"
):
self._file_picker = FilePickerApp(title, ok_button_title, selection_type, filter_options, mode)
def set_current_directory(self, dir):
self._file_picker.set_current_directory(dir)
def set_current_filename(self, filename):
self._file_picker.set_current_filename(filename)
def set_filebar_label_name(self, name):
self._file_picker.set_filebar_label_name(name)
def open(self, select_fn, cancel_fn):
self._file_picker.set_custom_fn(select_fn, cancel_fn)
self._file_picker.show_dialog()
def destroy(self):
if self._file_picker:
self._file_picker.destroy()
self._file_picker = None
class FilePickerApp:
"""
Standalone app to demonstrate the use of the FilePicker dialog.
Args:
title (str): Title of the window.
apply_button_name (str): Name of the confirm button.
selection_type (FileBrowserSelectionType): The file type that confirm event will respond to.
item_filter_options (list): Array of filter options. Element of array
is a tuple that first element of this tuple is the regex string for filtering,
and second element of this tuple is the descriptions, like ("*.*", "All Files").
By default, it will list all files.
"""
APP_SETTINGS_PREFIX = "/persistent/app/omniverse/savedServers"
def __init__(
self,
title: str,
apply_button_name: str,
selection_type: FileBrowserSelectionType = FileBrowserSelectionType.ALL,
item_filter_options: list = [("*.*", "All Files (*.*)")],
mode: FileBrowserMode = FileBrowserMode.OPEN
):
self._title = title
self._filepicker = None
self._mode = mode
self._selection_type = selection_type
self._custom_select_fn = None
self._custom_cancel_fn = None
self._apply_button_name = apply_button_name
self._filter_regexes = []
self._filter_descriptions = []
self._current_directory = None
for item in item_filter_options:
self._filter_regexes.append(re.compile(item[0], re.IGNORECASE))
self._filter_descriptions.append(item[1])
self._build_ui()
def destroy(self):
self._custom_cancel_fn = None
self._custom_select_fn = None
if self._filepicker:
self._filepicker.destroy()
def set_custom_fn(self, select_fn, cancel_fn):
self._custom_select_fn = select_fn
self._custom_cancel_fn = cancel_fn
def show_dialog(self):
self._filepicker.show(self._current_directory)
self._current_directory = None
def hide_dialog(self):
self._filepicker.hide()
def set_current_directory(self, dir: str):
self._current_directory = dir
if not self._current_directory.endswith("/"):
self._current_directory += "/"
def set_current_filename(self, filename: str):
self._filepicker.set_filename(filename)
def set_filebar_label_name(self, name):
self._filepicker.set_filebar_label_name(name)
def _build_ui(self):
on_click_open = lambda f, d: asyncio.ensure_future(self._on_click_open(f, d))
on_click_cancel = lambda f, d: asyncio.ensure_future(self._on_click_cancel(f, d))
# Create the dialog
self._filepicker = FilePickerDialog(
self._title,
allow_multi_selection=False,
apply_button_label=self._apply_button_name,
click_apply_handler=on_click_open,
click_cancel_handler=on_click_cancel,
item_filter_options=self._filter_descriptions,
item_filter_fn=lambda item: self._on_filter_item(item),
error_handler=lambda m: self._on_error(m),
)
# Start off hidden
self.hide_dialog()
def _on_filter_item(self, item: FileBrowserItem) -> bool:
if not item or item.is_folder:
return True
if self._selection_type == FileBrowserSelectionType.DIRECTORY_ONLY:
return False
if self._filepicker.current_filter_option >= len(self._filter_regexes):
return False
regex = self._filter_regexes[self._filepicker.current_filter_option]
if regex.match(item.path):
return True
else:
return False
def _on_error(self, msg: str):
"""
Demonstrates error handling. Instead of just printing to the shell, the App can
display the error message to a console window.
"""
print(msg)
async def _on_click_open(self, filename: str, dirname: str):
"""
The meat of the App is done in this callback when the user clicks 'Accept'. This is
a potentially costly operation so we implement it as an async operation. The inputs
are the filename and directory name. Together they form the fullpath to the selected
file.
"""
dirname = dirname.strip()
if dirname and not dirname.endswith("/"):
dirname += "/"
fullpath = f"{dirname}{filename}"
result, entry = omni.client.stat(fullpath)
existed = True
if result == omni.client.Result.OK and entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN:
is_folder = True
else:
existed = False
is_folder = False
# If it's open, it cannot open non-existed file.
if not existed and self._mode == FileBrowserMode.OPEN:
return
if existed or self._mode == FileBrowserMode.OPEN:
if (is_folder and self._selection_type == FileBrowserSelectionType.FILE_ONLY) or (
not is_folder and self._selection_type == FileBrowserSelectionType.DIRECTORY_ONLY
):
return
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_select_fn:
self._custom_select_fn(fullpath)
async def _on_click_cancel(self, filename: str, dirname: str):
"""
This function is called when the user clicks 'Cancel'.
"""
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_cancel_fn:
self._custom_cancel_fn()
| 6,735 |
Python
| 34.083333 | 103 | 0.619005 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/tests/test_collect.py
|
import os
import asyncio
import carb
import omni.kit.test
import omni.usd
import omni.client
import omni.kit.commands
from pathlib import Path
from omni.kit.tool.collect import get_instance
from omni.kit.tool.collect.collector import (
Collector,
CollectorException,
CollectorFailureOptions,
FlatCollectionTextureOptions,
)
from omni.kit.tool.collect.utils import Utils
from pxr import Usd
# NOTE: those tests belong to omni.kit.tool.collect extension.
class TestCollect(omni.kit.test.AsyncTestCase):
def list_folder(self, folder_path):
all_file_names = []
result, entry = omni.client.stat(folder_path)
if result == omni.client.Result.OK and entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN:
is_folder = True
else:
is_folder = False
if not is_folder:
all_file_names = [os.path.basename(folder_path)]
else:
folder_queue = [folder_path]
while len(folder_queue) > 0:
folder = folder_queue.pop(0)
(result, entries) = omni.client.list(folder)
if result != omni.client.Result.OK:
break
folders = set((e.relative_path for e in entries if e.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN))
for f in folders:
folder_queue.append(f"{folder}/{f}")
files = set((e.relative_path for e in entries if not e.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN))
for file in files:
all_file_names.append(os.path.basename(file))
return all_file_names
def get_test_dir(self):
token = carb.tokens.get_tokens_interface()
data_dir = token.resolve("${data}")
if not data_dir.endswith("/"):
data_dir += "/"
data_dir = Utils.normalize_path(data_dir)
return f"{data_dir}collect_tool_tests"
async def setUp(self):
pass
async def tearDown(self):
await omni.client.delete_async(self.get_test_dir())
async def __test_internal(
self,
stage_name,
root_usd,
usd_only,
material_only,
flat_collection,
texture_option=FlatCollectionTextureOptions.FLAT,
):
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
extension_path = Path(extension_path)
test_data_path = extension_path.joinpath("data")
test_stage_dir = str(test_data_path.joinpath("test_stages").joinpath(stage_name))
test_root_usd = test_stage_dir + "/" + root_usd
collected_stage_dir = self.get_test_dir() + f"/collected_{stage_name}"
collector = Collector(
test_root_usd, collected_stage_dir, usd_only, flat_collection, material_only, texture_option=texture_option
)
await collector.collect(None, None)
before = self.list_folder(test_stage_dir)
after = self.list_folder(collected_stage_dir)
self.assertTrue(len(after) > 0)
if usd_only:
before_filtered = []
for f in before:
if omni.usd.is_usd_writable_filetype(f):
before_filtered.append(f)
before = before_filtered
if material_only:
before_filtered = []
for f in before:
if not omni.usd.is_usd_writable_filetype(f):
before_filtered.append(f)
before = before_filtered
self.assertEqual(set(before), set(after))
async def test_collect_with_usd_and_material(self):
await self.__test_internal("normal", "FullScene.usd", False, False, False)
async def test_collect_with_udim_textures(self):
await self.__test_internal("udim", "SM_Hood_A1_1.usd", False, False, False)
async def test_collect_without_material(self):
await self.__test_internal("normal", "FullScene.usd", False, True, False)
async def test_collect_without_usd(self):
await self.__test_internal("normal", "FullScene.usd", True, False, False)
async def test_flatten_collection(self):
await self.__test_internal("normal", "FullScene.usd", False, False, True)
await self.__test_internal("layer_offsets", "root.usd", False, False, True)
async def test_flatten_collection_texture_options(self):
stage_name = "texture_options"
texture_dir = self.get_test_dir() + f"/collected_{stage_name}/SubUSDs/textures/"
mdl_name = "Contour1_Surface_0"
mdl_texture_name = "Contour1_Surface_1.bmp"
usd_preview_texture_name = "another_texture.bmp"
# test group textures by MDL
await self.__test_internal(
stage_name, "test_scene.usd", False, False, True, texture_option=FlatCollectionTextureOptions.BY_MDL
)
# mdl texture should be under the mdl named folder, while the usd preview texture should be directly under
# textures dir
self.assertTrue(os.path.exists(os.path.join(texture_dir, mdl_name, mdl_texture_name)))
self.assertTrue(os.path.exists(os.path.join(texture_dir, usd_preview_texture_name)))
await omni.client.delete_async(self.get_test_dir())
# test group textures by USD
await self.__test_internal(
stage_name, "test_scene.usd", False, False, True, texture_option=FlatCollectionTextureOptions.BY_USD
)
# usd preview texture should be under the usd asset named folder, while the mdl texture should be directly under
# textures dir
self.assertTrue(os.path.exists(os.path.join(texture_dir, "assetB", usd_preview_texture_name)))
self.assertTrue(os.path.exists(os.path.join(texture_dir, mdl_texture_name)))
await omni.client.delete_async(self.get_test_dir())
# test flat
await self.__test_internal(
stage_name, "test_scene.usd", False, False, True, texture_option=FlatCollectionTextureOptions.FLAT
)
# all textures should be directly under textures dir
self.assertEqual(set([mdl_texture_name, usd_preview_texture_name]), set(os.listdir(texture_dir)))
async def test_layer_offsets_collect(self):
current_path = Path(__file__).parent
test_data_path = current_path.parent.parent.parent.parent.parent.joinpath("data")
test_stage_dir = str(test_data_path.joinpath("test_stages").joinpath("layer_offsets"))
test_root_usd = test_stage_dir + "/root.usd"
collected_stage_dir = self.get_test_dir() + f"/collected_layer_offfsets"
collector = Collector(test_root_usd, collected_stage_dir, False, False, False)
await collector.collect(None, None)
before = self.list_folder(test_stage_dir)
after = self.list_folder(collected_stage_dir)
self.assertEqual(set(before), set(after))
after_stage_usd = collected_stage_dir + "/root.usd"
before_stage = Usd.Stage.Open(test_root_usd)
after_stage = Usd.Stage.Open(after_stage_usd)
before_root = before_stage.GetRootLayer()
after_root = after_stage.GetRootLayer()
before_sublayers = before_root.subLayerPaths
after_sublayers = after_root.subLayerPaths
self.assertTrue(len(before_sublayers) > 0)
self.assertEqual(len(before_sublayers), len(after_sublayers))
self.assertEqual(len(before_sublayers), len(after_sublayers))
for i in range(len(before_sublayers)):
before_sublayer = before_root.ComputeAbsolutePath(before_sublayers[i])
after_sublayer = after_root.ComputeAbsolutePath(after_sublayers[i])
self.assertNotEqual(before_sublayer, after_sublayer)
self.assertEqual(before_root.subLayerOffsets, after_root.subLayerOffsets)
async def test_collect_failure_with_exception(self):
with self.assertRaises(CollectorException):
collector = Collector("invalid_source.usd", self.get_test_dir(), False, False, False)
await collector.collect(None, None)
with self.assertRaises(CollectorException):
current_path = Path(__file__).parent
test_data_path = current_path.parent.parent.parent.parent.parent.joinpath("data")
test_stage_path = str(test_data_path.joinpath("test_stages").joinpath("normal/FullScene.usd"))
collector = Collector(test_stage_path, "omniverse://invalid_path", False, False, False)
await collector.collect(None, None)
usd_error_option = CollectorFailureOptions.EXTERNAL_USD_REFERENCES
other_error_option = CollectorFailureOptions.OTHER_EXTERNAL_REFERENCES
all_option = CollectorFailureOptions.EXTERNAL_USD_REFERENCES | CollectorFailureOptions.OTHER_EXTERNAL_REFERENCES
for option in [usd_error_option, other_error_option, all_option]:
with self.assertRaises(CollectorException):
current_path = Path(__file__).parent
test_data_path = current_path.parent.parent.parent.parent.parent.joinpath("data")
test_stage_path = str(test_data_path.joinpath("test_stages/normal").joinpath("FullScene.usd"))
collected_stage_dir = self.get_test_dir() + "/collected_normal"
collector = Collector(test_stage_path, collected_stage_dir, False, False, False, failure_options=option)
await collector.collect(None, None)
async def test_utils(self):
self.assertTrue(Utils.is_udim_texture("test.<UDIM>.png"))
self.assertTrue(Utils.is_udim_texture("test_<UDIM>_suffix.png"))
self.assertTrue(Utils.is_udim_texture("test.%3cUDIM%3e.png"))
self.assertFalse(Utils.is_udim_texture(""))
self.assertFalse(Utils.is_udim_texture("random"))
self.assertTrue(Utils.is_udim_wildcard_texture("test_0001_suffix.png", "test_<UDIM>_suffix.png"))
self.assertFalse(Utils.is_udim_wildcard_texture("test_0001_another_suffix.png", "test_<UDIM>_suffix.png"))
self.assertTrue(
Utils.is_udim_wildcard_texture(
"omniverse://fake-server/base_path/test_0001_suffix.png",
"omniverse://fake-server/base_path/test_<UDIM>_suffix.png",
)
)
self.assertFalse(
Utils.is_udim_wildcard_texture(
"omniverse://fake-server/base_path/test_0001_another_suffix.png",
"omniverse://fake-server/base_path/test_<UDIM>_suffix.png",
)
)
async def test_path_calculation(self):
# Tests for https://nvidia-omniverse.atlassian.net/browse/OM-34746
current_path = Path(__file__).parent
test_data_path = current_path.parent.parent.parent.parent.parent.joinpath("data")
test_stage_path = str(test_data_path.joinpath("test_stages").joinpath("normal/FullScene.usd"))
collector = Collector(test_stage_path, self.get_test_dir(), False, False, False)
path = collector._calculate_target_path("http://test_server/testfile.png")
self.assertEqual(path, self.get_test_dir() + "/test_server/testfile.png")
path = collector._calculate_target_path(str(test_data_path) + "/deep_folder/testfile.png")
self.assertEqual(path, self.get_test_dir() + "/deep_folder/testfile.png")
path = collector._calculate_target_path("omniverse://test_server/testfile.png")
self.assertEqual(path, self.get_test_dir() + "/test_server/testfile.png")
# Flat collect
collector._flat_collection = True
collector._material_only = False
path = collector._calculate_target_path("omniverse://test_server/testfile.png")
self.assertEqual(path, self.get_test_dir() + "/SubUSDs/textures/testfile.png")
path = collector._calculate_target_path("http://test_server/testfile.png")
self.assertEqual(path, self.get_test_dir() + "/SubUSDs/textures/testfile.png")
path = collector._calculate_target_path("http://test_server/testfile.usd")
self.assertEqual(path, self.get_test_dir() + "/SubUSDs/testfile.usd")
# Materials only with flat collect
collector._flat_collection = True
collector._material_only = True
path = collector._calculate_target_path("omniverse://test_server/testfile.png")
self.assertEqual(path, self.get_test_dir() + "/textures/testfile.png")
path = collector._calculate_target_path("http://test_server/testfile.png")
self.assertEqual(path, self.get_test_dir() + "/textures/testfile.png")
# Master USD with flat collect
collector._flat_collection = True
collector._material_only = False
path = collector._calculate_target_path(test_stage_path)
self.assertEqual(path, self.get_test_dir() + "/FullScene.usd")
async def __wait(self, frames=2):
for _ in range(frames):
await omni.kit.app.get_app().next_update_async()
async def __test_ui_internal(self, stage_name, root_usd, usd_only, material_only, flat_collection):
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
extension_path = Path(extension_path)
test_data_path = extension_path.joinpath("data")
test_stage_dir = str(test_data_path.joinpath("test_stages").joinpath(stage_name))
test_root_usd = test_stage_dir + "/" + root_usd
collected_stage_dir = self.get_test_dir() + f"/collected_{stage_name}"
done = False
def on_finish():
nonlocal done
done = True
collect_extension = get_instance()
collect_extension.collect(test_root_usd, on_finish)
await self.__wait()
from omni.kit import ui_test
collect_window = ui_test.find("Collection Options")
await collect_window.focus()
usd_only_checkbox = collect_window.find("**/CheckBox[*].identifier=='usd_only_checkbox'")
material_only_checkbox = collect_window.find("**/CheckBox[*].identifier=='material_only_checkbox'")
flat_collection_checkbox = collect_window.find("**/CheckBox[*].identifier=='flat_collection_checkbox'")
folder_button = collect_window.find("**/Button[*].identifier=='folder_button'")
path_field = collect_window.find("**/StringField[*].identifier=='collect_path'")
start_button = collect_window.find("**/Button[*].text=='Start'")
cancel_button = collect_window.find("**/Button[*].text=='Cancel'")
option_combo = collect_window.find("**/ComboBox[*].identifier=='texture_option_combo'")
self.assertTrue(usd_only_checkbox)
self.assertTrue(material_only_checkbox)
self.assertTrue(flat_collection_checkbox)
self.assertTrue(folder_button)
self.assertTrue(path_field)
self.assertTrue(start_button)
self.assertTrue(cancel_button)
self.assertTrue(option_combo)
usd_only_checkbox.model.set_value(False)
material_only_checkbox.model.set_value(False)
flat_collection_checkbox.model.set_value(False)
if usd_only:
await usd_only_checkbox.click()
if material_only:
await material_only_checkbox.click()
if flat_collection:
self.assertFalse(option_combo.widget.visible)
await flat_collection_checkbox.click()
# should show texture options combo here
self.assertTrue(option_combo.widget.visible)
await folder_button.click()
file_picker = ui_test.find("Select Collect Destination")
self.assertTrue(file_picker)
await file_picker.focus()
open_button = file_picker.find("**/Button[*].text=='Open'")
cancel_button = file_picker.find("**/Button[*].text=='Cancel'")
self.assertTrue(open_button)
self.assertTrue(cancel_button)
await cancel_button.click()
path_field.model.set_value(collected_stage_dir)
await start_button.click()
await self.__wait()
progress_window = ui_test.find("Collecting")
self.assertTrue(progress_window)
while not done:
await self.__wait()
self.assertFalse(progress_window.window.visible)
before = self.list_folder(test_stage_dir)
after = self.list_folder(collected_stage_dir)
self.assertTrue(len(after) > 0)
if usd_only:
before_filtered = []
for f in before:
if omni.usd.is_usd_writable_filetype(f):
before_filtered.append(f)
before = before_filtered
if material_only:
before_filtered = []
for f in before:
if not omni.usd.is_usd_writable_filetype(f):
before_filtered.append(f)
before = before_filtered
self.assertEqual(set(before), set(after))
self.assertTrue(done)
async def test_ui_collect_with_usd_and_material(self):
await self.__test_ui_internal("normal", "FullScene.usd", False, False, False)
async def test_ui_collect_without_material(self):
await self.__test_ui_internal("normal", "FullScene.usd", False, True, False)
async def test_ui_collect_without_usd(self):
await self.__test_ui_internal("normal", "FullScene.usd", True, False, False)
async def test_om_55150(self):
await self.__test_ui_internal("OM_55150", "collect_donut.usd", False, False, False)
async def test_ui_flatten_collection(self):
await self.__test_ui_internal("normal", "FullScene.usd", False, False, True)
async def test_file_menu(self):
await omni.usd.get_context().new_stage_async()
from omni.kit import ui_test
await ui_test.menu_click("File/Collect As...")
# It cannot collect anonymous stage
collect_window = ui_test.find("Collection Options")
self.assertFalse(collect_window)
extension_path = omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)
extension_path = Path(extension_path)
test_data_path = extension_path.joinpath("data")
test_stage_dir = str(test_data_path.joinpath("test_stages").joinpath("udim"))
test_root_usd = test_stage_dir + "/SM_Hood_A1_1.usd"
await omni.usd.get_context().open_stage_async(test_root_usd)
await ui_test.menu_click("File/Collect As...")
# It cannot collect anonymous stage
collect_window = ui_test.find("Collection Options")
self.assertFalse(collect_window)
| 18,559 |
Python
| 43.401914 | 120 | 0.640552 |
omniverse-code/kit/exts/omni.kit.tool.collect/omni/kit/tool/collect/tests/__init__.py
|
from .test_collect import *
| 28 |
Python
| 13.499993 | 27 | 0.75 |
omniverse-code/kit/exts/omni.kit.tool.collect/docs/CHANGELOG.md
|
# Changelog
## [2.1.20] - 2022-11-10
### Added
- Add texture grouping options for flat collection mode, textures can be grouped by MDL, USD or flat.
## [2.1.19] - 2022-11-07
### Changed
- Reduce size of test data.
- Improve UI.
- Make omni.kit.window.content_browser as optional.
- Fix MDL parser that cannot handle spaces in texture define.
## [2.1.18] - 2022-09-05
### Changed
- Fix issue that won't hide progress bar.
## [2.1.17] - 2022-08-27
### Changed
- Move collect tool into Kit core.
- More improvement to perf.
- Hook collect tool to file menu.
## [2.1.16] - 2022-08-26
### Changed
- Fix file naming conflicts for flat collection.
- More improvement about logging and perf.
## [2.1.15] - 2022-08-23
### Changed
- More test coverage.
## [2.1.14] - 2022-08-18
### Changed
- Fix refactoring issues.
## [2.1.13] - 2022-08-12
### Changed
- Refactoring collect tool to improve perf.
- Fix tags collecting.
## [2.1.12] - 2022-07-28
### Changed
- Fix issues to collect read-only USD files.
## [2.1.11] - 2022-05-26
### Changed
- Workaround to solve usda collect issue by renaming extension to match its content format.
## [2.1.10] - 2022-05-20
### Added
- Fix collect issue that will miss tags for USD files.
## [2.1.9] - 2022-05-12
### Added
- add flag to elide copy if files that already in destination location.
## [2.1.8] - 2022-04-28
### Changed
- Revert maximum tasks to 8 to avoid influence interaction of UI.
## [2.1.7] - 2022-04-28
### Changed
- Add error options to customize error reporting.
## [2.1.6] - 2022-04-06
### Changed
- Match MDL resolve rule as new-MDL-Schema in USD.
## [2.1.5] - 2022-03-07
### Changed
- Fix missing changes from Kit release/103.1.
## [2.1.4] - 2022-03-07
### Changed
- Catch possible exceptions threw by UsdUtils.ExtractExternalReferences and UsdUtils.ModifyAssetPaths.
## [2.1.3] - 2022-02-21
### Changed
- Move collect tool to kit-tools repo.
## [2.1.2] - 2022-02-09
### Changed
- Fix an issue that UDIM textures are missing to be collected.
## [2.1.1] - 2022-01-12
### Changed
- Fix path decode issue for collecting projects from ov to ov.
## [2.1.0] - 2021-12-16
### Changed
- Fix path resolve that's with/without relative path prefix, like './' or '../'
## [2.0.8] - 2021-09-27
### Changed
- Fix texture collecting for cube/ptex textures
- Fix mdl module replace.
## [2.0.7] - 2021-09-16
### Changed
- Improve UX of file picker to show folder name for folder picker.
## [2.0.6] - 2021-09-10
### Fixes
- Improve flat collect to resolve material dependencies.
## [2.0.5] - 2021-09-09
### Added
- Add API to collect.
## [2.0.4] - 2021-08-25
### Fixes
- Fix UDIM textures collect.
## [2.0.3] - 2021-07-28
### Changed
- More tests.
## [2.0.2] - 2021-07-21
### Fixed
- Fix collection to assets from http source.
## [2.0.1] - 2021-02-06
### Changed
- Initialize change log.
- Remove old editor and content window dependencies.
| 2,897 |
Markdown
| 21.818897 | 102 | 0.667932 |
omniverse-code/kit/exts/omni.kit.tool.collect/docs/README.md
|
# Project Collector [omni.kit.tool.collect]
This extension provides UI interfaces to collect USD project by resolving, re-pathing and gathering all dependencies, so project can be movable and sharable conveniently.
## UI Options Explained
`USD Only`: If this option is enabled, it will only collect USD files and other other dependencies are ignored (like material files and textures.)
`Material Only`: If this options is enabled, it will only collect all material related dependencies including textures, and USD files will be ignored.
`Flat Collection`: By default, it will collect USD project by keeping the directory structure. If this option is enabled, the directory structure will not be kept and all dependencies will be put into specified folders.
`Flat Collection Texture Options`: When collecting in Flat mode, users can specify the grouping for texture files via this option; Currently there are 3 available options:
| Options | Description |
| ------- | ----------- |
| Group by MDL | Textures will be grouped by their parent MDL file name. |
| Group by USD | Textures will be grouped by their parent USD file name. |
| Flat | All textures will be collected under the same hierarchy under "textures" folder. Note that there might be potential danger of textures overwriting each other, if they have the same names but belong to different assets/mdls. |
## Limitations
There is no USDZ support currently until Kit resolves MDL loading issue inside USDZ file.
| 1,478 |
Markdown
| 72.949996 | 234 | 0.778755 |
omniverse-code/kit/exts/omni.kit.tool.collect/docs/index.rst
|
omni.kit.tool.collector
#######################
Python extension to collect all dependencies of an USD.
| 105 |
reStructuredText
| 20.199996 | 55 | 0.628571 |
omniverse-code/kit/exts/omni.graph.instancing/config/extension.toml
|
[package]
version = "1.3.0"
title = "OmniGraph Instancing"
authors = ["NVIDIA"]
repository = ""
readme = "docs/README.md"
changelog = "docs/CHANGELOG.md"
description = "OmniGraph instance graph processing per USD Prim"
category = "Graph"
preview_image = "data/preview.png"
icon = "data/icon.svg"
[dependencies]
"omni.graph.core" = {}
[[python.module]]
name = "omni.graph.instancing"
[[test]]
waiver = "Tests are in omni.graph.test"
# RTX regression OM-51983
timeout = 600
unreliable = true # OM-51982
args = [
"--/app/extensions/registryEnabled=1" # needs to be fixed and removed: OM-49579
]
| 599 |
TOML
| 21.222221 | 83 | 0.702838 |
omniverse-code/kit/exts/omni.graph.instancing/omni/graph/instancing/__init__.py
|
import carb
carb.log_warn("omni.graph.instancing has been deprecated. All functionality has been moved to omni.graph.core and omni.graph.ui.")
| 144 |
Python
| 35.249991 | 130 | 0.791667 |
omniverse-code/kit/exts/omni.graph.instancing/docs/CHANGELOG.md
|
# Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [Unreleased]
## [1.3.0] - 2022-08-04
### Changed
- Marked extension for deprecated
## [1.2.4] - 2022-06-17
### Removed
- Moved ApplyOmniGraph and RemoveOmniGraph api commands to omni.graph.core
- Moved ui elements to omni.graph.ui
## [1.2.3] - 2022-05-24
### Fixed
- Graph instances in references no longer require a stage reload to evaluate
## [1.2.2] - 2022-05-23
### Removed
- Explicit dependency on omni.kit.window.viewport
## [1.2.1] - 2022-04-27
### Fixed
- Fixed error thrown when extension is loaded.
### Changed
- Removed dependency on tools, nodes and ui OmniGraph extensions
## [1.2.0] - 2022-04-19
### Removed
- ReadGraphVariable, WriteGraphVariable, GraphTarget nodes.
- Instances are no longer run in this extension
- OmniGraph no longer modifies compute graph pipeline automatically
## [1.1.2] - 2022-04-13
### Changed
- Warning will appear when a graph with incompatible nodes is set as an instance
## [1.1.1] - 2022-04-12
### Fixed
- Fixed errors thrown when variables nodes are multi-selected
## [1.1.0] - 2022-03-30
### Changed
- WriteGraphVariable value output port
## [1.0.3] - 2022-03-23
### Fixed
- Variable types are now synchronized between graph and instance
- ReadGraphVariable and WriteGraphVariable listen for create and remove variable events
## [1.0.2] - 2022-02-14
### Fixed
- fixed unregistered notice handler causing crash
## [1.0.1] - 2022-02-14
### Fixed
- add additional extension enabled check for omni.graph.ui not enabled error
## [1.0.0] - 2022-01-17
### Modified
- Initial release.
| 1,795 |
Markdown
| 26.630769 | 87 | 0.718106 |
omniverse-code/kit/exts/omni.graph.instancing/docs/README.md
|
# OmniGraph Instancing [omni.graph.instancing]
This extension is no longer required. Variable and Instancing OmniGraph functionality previously provided by this extension is available through the omni.graph.core and omni.graph.ui extensions.
| 245 |
Markdown
| 39.999993 | 194 | 0.828571 |
omniverse-code/kit/exts/omni.graph.instancing/docs/index.rst
|
.. _ogn_omni_graph_instancing:
OmniGraph Instancing
####################
.. tabularcolumns:: |L|R|
.. csv-table::
:width: 100%
**Extension**: omni.graph.instancing,**Documentation Generated**: |today|
.. toctree::
:maxdepth: 1
CHANGELOG
What Is It?
===========
Instancing provides a mechanism to apply a single graph to multiple `UsdPrim` objects. Applying the
`OmniGraph` component onto a `UsdPrim` will cause the graph to execute with the variable values stored on the
`OmniGraph` component. Multiple Prims referencing the same graph will cause the graph to execute once for each Prim.
The `GraphTarget` node exposes the path of the `UsdPrim` instance to the graph, allowing each execution to uniquely
read or modify the primitive that initiated the execution.
For more comprehensive documentation explaining the use of OmniGraph features in detail see
:ref:`ogn_user_guide`
Limitations
===========
At present, each execution of the graph occurs sequentially and nodes in the graph share state across all instances.
Nodes that use event callbacks, or use internal state may not behave as anticipated when multiple instances exists.
For example, using the `OnKeyboardInput` action graph node will only trigger the event on the first instance executed.
Instead, it is recommended to use the ReadKeyboardInput node instead. Another example is the `Counter` node - it will
increment for each instance executed.
The following is a noncomprehensive list of nodes that may not be suitable for instanced graphs
* omni.graph.action.OgnCounter
* omni.graph.action.OgnDelay
* omni.graph.action.OgnForEach
* omni.graph.action.OgnFlipFlop
* omni.graph.action.OgnForEach
* omni.graph.action.OgnGate
* omni.graph.action.OgnMultiGate
* omni.graph.action.OgnOnCustomEvent
* omni.graph.action.OgnOnGamepadInput
* omni.graph.action.OgnOnImpulseEvent
* omni.graph.action.OgnOnKeyboardInput
* omni.graph.action.OgnOnMouseInput
* omni.graph.action.OgnOnObjectChange
* omni.graph.action.OgnOnStageEvent
* omni.graph.action.OgnSendCustomEvent
* omni.graph.action.OgnSequence
* omni.graph.action.OgnSyncGate
| 2,122 |
reStructuredText
| 34.98305 | 119 | 0.775683 |
omniverse-code/kit/exts/omni.rtx.ovtextureconverter/config/extension.toml
|
[core]
[package]
title = "OV Texture converter"
category = "Internal"
version = "1.0.0"
[dependencies]
"carb.windowing.plugins" = {}
"omni.assets.plugins" = {}
"omni.client" = {} # needed for carb.datasource-omniclient.plugin
"omni.gpu_foundation" = {}
[[python.module]]
name = "omni.rtx.ovtextureconverter"
[[native.plugin]]
path = "bin/*.plugin"
[settings]
[[test]]
args = [
]
| 384 |
TOML
| 15.041666 | 65 | 0.669271 |
omniverse-code/kit/exts/omni.rtx.ovtextureconverter/omni/rtx/ovtextureconverter/__init__.py
|
from ._ovtextureconverter import *
from .scripts import *
| 58 |
Python
| 18.66666 | 34 | 0.775862 |
omniverse-code/kit/exts/omni.rtx.ovtextureconverter/omni/rtx/ovtextureconverter/_ovtextureconverter.pyi
|
from __future__ import annotations
import omni.rtx.ovtextureconverter._ovtextureconverter
import typing
__all__ = [
"IOVTextureConverter",
"ResultList",
"acquire_ovtextureconverter_interface"
]
class IOVTextureConverter():
def compressFile(self, arg0: str, arg1: str, arg2: str) -> list: ...
def compressFileOnly(self, arg0: str) -> bool: ...
def compressJob(self, arg0: str) -> list: ...
pass
class ResultList():
pass
def acquire_ovtextureconverter_interface(*args, **kwargs) -> typing.Any:
pass
| 536 |
unknown
| 24.571427 | 72 | 0.686567 |
omniverse-code/kit/exts/omni.rtx.ovtextureconverter/omni/rtx/ovtextureconverter/scripts/commands.py
|
## Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import carb
import omni.kit.commands
import omni.rtx.ovtextureconverter
class IssueTextureCompressionRequest(omni.kit.commands.Command):
def __init__(
self,
**kwargs,
):
# pull out the stage name to process from the entry
# check for a couple different forms
self._path = None
for key in ["path", "texture_path"]:
if key in kwargs:
self._path = kwargs[key]
break
# standardize the path separator character
self._path = self._path.replace("\\", "/") if self._path else None
self._convert_iface = omni.rtx.ovtextureconverter.acquire_ovtextureconverter_interface()
def do(self):
if not self._path:
carb.log_warn("'path' not valid")
return False
carb.log_info("Processing Texture: " + self._path)
# This inserts an async request, but we can't yet "await" it.
# TODO: May need to sleep after this?
return self._convert_iface.compressFileOnly(str(self._path))
omni.kit.commands.register_all_commands_in_module(__name__)
| 1,558 |
Python
| 34.431817 | 96 | 0.661746 |
omniverse-code/kit/exts/omni.rtx.ovtextureconverter/omni/rtx/ovtextureconverter/scripts/__init__.py
|
from .commands import *
| 23 |
Python
| 22.999977 | 23 | 0.782609 |
omniverse-code/kit/exts/omni.rtx.ovtextureconverter/omni/rtx/ovtextureconverter/tests/test_ovtextureconverter.py
|
## Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.app
from omni.kit.test import AsyncTestCase
import omni.rtx.ovtextureconverter
class TestConverter(AsyncTestCase):
async def setUp(self):
self._convert_iface = omni.rtx.ovtextureconverter.acquire_ovtextureconverter_interface()
async def tearDown(self):
pass
async def test_001_compress(self):
print("Disabled because somehow on linux the gpufoundation shaders cannot be found 1/2.")
#results = self._convert_iface.compressFile("./resources/test/dot.png", "./resources/test", "BlaBlaBla")
#for x in results:
# print(x)
| 1,039 |
Python
| 36.142856 | 112 | 0.739172 |
omniverse-code/kit/exts/omni.rtx.ovtextureconverter/omni/rtx/ovtextureconverter/tests/__init__.py
|
from .test_commands import *
| 29 |
Python
| 13.999993 | 28 | 0.758621 |
omniverse-code/kit/exts/omni.rtx.ovtextureconverter/omni/rtx/ovtextureconverter/tests/test_commands.py
|
## Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import carb.settings
import omni.kit.app
from omni.kit.test import AsyncTestCase
import omni.rtx.ovtextureconverter.scripts.commands as commands
import asyncio
import os
import os.path
import pathlib
import shutil
TEST_DATA_DIR = str(pathlib.Path(__file__).parent.joinpath("data"))
TEST_OUTPUT_DIR = omni.kit.test.get_test_output_path()
class TestCommands(AsyncTestCase):
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_IssueTextureCompressionRequest(self):
"""
Test Command to create texture caches with new UJITSO build system
"""
source_texture = pathlib.Path(TEST_DATA_DIR, "dot.png")
tex_cache_dir = pathlib.Path(TEST_OUTPUT_DIR, "ujitso_texcache")
settings = carb.settings.get_settings()
self.assertTrue(settings.get_as_bool("/rtx-transient/resourcemanager/UJITSO/enabled"))
# Set the destination for texture caching
settings.set_string("/rtx-transient/resourcemanager/remoteTextureCachePath", str(tex_cache_dir))
# Clear the local texture cache path to allow repeated tests, otherwise only works first time.
settings.set_string("/rtx-transient/resourcemanager/localTextureCachePath", "")
# Disable omnihub
settings.set_bool("/rtx-transient/resourcemanager/useOmniHubCache", False)
settings.set_bool("/rtx-transient/resourcemanager/useMDBCache", False)
# Remove results from any previous run
if os.path.exists(tex_cache_dir):
shutil.rmtree(tex_cache_dir)
cmd = commands.IssueTextureCompressionRequest(path=str(source_texture))
self.assertTrue(cmd.do())
# NOTE: the datastore that handles the upload currently has no way to wait for all uploads to complete.
print("Waiting for UJITSO texture uploads...")
await asyncio.sleep(5)
self.assertTrue(os.path.exists(tex_cache_dir))
files = os.listdir(tex_cache_dir)
self.assertTrue(len(files) > 0)
| 2,454 |
Python
| 36.76923 | 111 | 0.714344 |
omniverse-code/kit/exts/omni.activity.profiler/omni/activity/profiler/tests/test_activity_profiler.py
|
## Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.activity.profiler
import carb.profiler
class TestActivityProfiler(omni.kit.test.AsyncTestCase):
async def setUp(self):
self._activity_profiler = omni.activity.profiler.get_activity_profiler()
self._carb_profiler = carb.profiler.acquire_profiler_interface(plugin_name="omni.activity.profiler.plugin")
async def tearDown(self):
self._carb_profiler = None
self._activity_profiler = None
async def test_activity_profiler_masks(self):
# Verify the initial value of the activity profiler capture mask.
self.assertEqual(self._carb_profiler.get_capture_mask(), 0)
# Set the base activity profiler capture mask directly through the carb profiler API.
self._carb_profiler.set_capture_mask(omni.activity.profiler.CAPTURE_MASK_STARTUP)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_STARTUP)
# Enable an activity profiler capture mask through the activity profiler API.
uid1 = self._activity_profiler.enable_capture_mask(omni.activity.profiler.CAPTURE_MASK_LATENCY)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_STARTUP |
omni.activity.profiler.CAPTURE_MASK_LATENCY)
# Enable another activity profiler capture mask through the activity profiler API.
uid2 = self._activity_profiler.enable_capture_mask(omni.activity.profiler.CAPTURE_MASK_SCENE_LOADING)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_STARTUP |
omni.activity.profiler.CAPTURE_MASK_LATENCY |
omni.activity.profiler.CAPTURE_MASK_SCENE_LOADING)
# Enable an activity profiler capture mask for the second time through the activity profiler API.
uid3 = self._activity_profiler.enable_capture_mask(omni.activity.profiler.CAPTURE_MASK_LATENCY)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_STARTUP |
omni.activity.profiler.CAPTURE_MASK_LATENCY |
omni.activity.profiler.CAPTURE_MASK_SCENE_LOADING)
# Disable the activity profiler capture mask that was set a second time through the activity profiler API.
self._activity_profiler.disable_capture_mask(uid3)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_STARTUP |
omni.activity.profiler.CAPTURE_MASK_LATENCY |
omni.activity.profiler.CAPTURE_MASK_SCENE_LOADING)
# Disable the first activity profiler capture mask that was set through the activity profiler API.
self._activity_profiler.disable_capture_mask(uid1)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_STARTUP |
omni.activity.profiler.CAPTURE_MASK_SCENE_LOADING)
# Enable the same base activity profiler capture mask through the activity profiler API.
uid4 = self._activity_profiler.enable_capture_mask(omni.activity.profiler.CAPTURE_MASK_STARTUP)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_STARTUP |
omni.activity.profiler.CAPTURE_MASK_SCENE_LOADING)
# Disable the same base activity profiler capture mask that was set through the activity profiler API.
self._activity_profiler.disable_capture_mask(uid4)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_STARTUP |
omni.activity.profiler.CAPTURE_MASK_SCENE_LOADING)
# Set the base activity profiler capture mask directly through the carb profiler API.
self._carb_profiler.set_capture_mask(0)
self.assertEqual(self._carb_profiler.get_capture_mask(), omni.activity.profiler.CAPTURE_MASK_SCENE_LOADING)
# Disable the second activity profiler capture mask that was set through the activity profiler API.
self._activity_profiler.disable_capture_mask(uid2)
self.assertEqual(self._carb_profiler.get_capture_mask(), 0)
# Set the base activity profiler capture mask to something that is not an activity mask.
self._activity_profiler.disable_capture_mask(1)
self.assertEqual(self._carb_profiler.get_capture_mask(), 0)
# Enable an activity profiler capture mask that is not an activity mask.
uid5 = self._activity_profiler.enable_capture_mask(1)
self.assertEqual(self._carb_profiler.get_capture_mask(), 0)
# Disable the activity profiler capture mask that is not an activity mask.
self._activity_profiler.disable_capture_mask(uid5)
self.assertEqual(self._carb_profiler.get_capture_mask(), 0)
| 5,761 |
Python
| 63.022222 | 115 | 0.664121 |
omniverse-code/kit/exts/omni.kit.widget.browser_bar/config/extension.toml
|
[package]
title = "Kit Browser Bar Widget"
version = "2.0.5"
category = "Internal"
description = "Treeview browser bar as embeddable widget"
authors = ["NVIDIA"]
slackids = ["UQY4RMR3N"]
repository = ""
keywords = ["kit", "ui"]
changelog = "docs/CHANGELOG.md"
preview_image = "data/preview.png"
[dependencies]
"omni.ui" = {}
"omni.kit.widget.path_field" = {}
[[python.module]]
name = "omni.kit.widget.browser_bar"
[[test]]
args = [
"--/app/window/dpiScaleOverride=1.0",
"--/app/window/scaleToMonitor=false",
"--no-window"
]
dependencies = [
"omni.kit.renderer.core"
]
| 584 |
TOML
| 19.172413 | 57 | 0.664384 |
omniverse-code/kit/exts/omni.kit.widget.browser_bar/omni/kit/widget/browser_bar/style.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import omni.ui as ui
from pathlib import Path
CURRENT_PATH = Path(__file__).parent
ICON_PATH = CURRENT_PATH.parent.parent.parent.parent.joinpath("icons")
UI_STYLES = {}
UI_STYLES["NvidiaLight"] = {
"Rectangle": {"background_color": 0xFF535354},
"Button": {"background_color": 0xFFE0E0E0, "margin": 4, "padding": 0, "border_width": 0},
"Button:hovered": {"background_color": 0xFFACACAF},
"Button:selected": {"background_color": 0xFFACACAF},
"Button:disabled": {"background_color": 0xFFE0E0E0},
"Button.Image": {"color": 0xFF6E6E6E},
"Button.Image:disabled": {"color": 0x0},
"ComboBox": {"background_color": 0xFF535354, "selected_color": 0xFFACACAF, "color": 0xFFD6D6D6},
"ComboBox:hovered": {"background_color": 0xFFACACAF},
"ComboBox:selected": {"background_color": 0xFFACACAF},
}
UI_STYLES["NvidiaDark"] = {
"Rectangle": {"background_color": 0xFF23211F},
"Button": {"background_color": 0x0, "margin": 4, "padding": 0},
"Button:disabled": {"background_color": 0x0},
"Button.Image": {"color": 0xFFFFFFFF},
"Button.Image:disabled": {"color": 0xFF888888},
"ComboBox": {
"background_color": 0xFF23211F,
"selected_color": 0x0,
"color": 0xFF4A4A4A,
"border_radius": 0,
"margin": 0,
"padding": 4,
"secondary_color": 0xFF23211F,
},
"ComboBox.Active": {
"background_color": 0xFF23211F,
"selected_color": 0xFF3A3A3A,
"color": 0xFF9E9E9E,
"border_radius": 0,
"margin": 0,
"padding": 4,
"secondary_selected_color": 0xFF9E9E9E,
"secondary_color": 0xFF23211F,
},
"ComboBox.Active:hovered": {"color": 0xFF4A4A4A, "secondary_color": 0x0,},
"ComboBox.Active:pressed": {"color": 0xFF4A4A4A, "secondary_color": 0x0,},
"ComboBox.Bg": {
"background_color": 0x0,
"margin": 0,
"padding": 2,
},
"ComboBox.Bg.Active": {
"background_color": 0x0,
"margin": 0,
"padding": 2,
},
"ComboBox.Bg.Active:hovered": {
"background_color": 0xFF6E6E6E,
},
"ComboBox.Bg.Active:pressed": {
"background_color": 0xFF6E6E6E,
},
}
| 2,623 |
Python
| 34.459459 | 100 | 0.633626 |
omniverse-code/kit/exts/omni.kit.widget.browser_bar/omni/kit/widget/browser_bar/__init__.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
"""
The :obj:`PathField` widget supes up tree navigation via keyboard entry. This widget extends that
experience further by queuing up the user's navigation history. As in any modern day browser, the
user can then directly jump to any previously visited path.
Example:
.. code-block:: python
browser_bar = BrowserBar(
visited_history_size=20,
branching_options_provider=branching_options_provider,
apply_path_handler=apply_path_handler,
)
"""
from .widget import BrowserBar
| 944 |
Python
| 35.346152 | 98 | 0.768008 |
omniverse-code/kit/exts/omni.kit.widget.browser_bar/omni/kit/widget/browser_bar/model.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import sys, os
import omni.ui as ui
class StringQueueItem(ui.AbstractItem):
def __init__(self, value: str):
super().__init__()
self._model = ui.SimpleStringModel(value)
@property
def model(self):
return self._model
@property
def value(self):
return self._model.get_value_as_string()
class StringQueueModel(ui.AbstractItemModel):
def __init__(self, max_items: int = 4, value_changed_fn=None):
super().__init__()
self._value_changed_fn = value_changed_fn
self._max_items = max_items
self._items = []
self._selected_index = ui.SimpleIntModel(0)
# TODO: There's a bug that if the item selected doesn't have a different
# index, then it doesn't trigger this callback. It's better to trigger on
# mouse pressed but we don't have this option.
self._selected_index.add_value_changed_fn(self._on_selection_changed)
def __getitem__(self, idx: int) -> StringQueueItem:
if idx < len(self._items):
return self._items[idx]
return None
@property
def selected_index(self) -> int:
return self._selected_index.get_value_as_int()
@selected_index.setter
def selected_index(self, index: int):
self._selected_index.set_value(index)
def get_selected_item(self) -> StringQueueItem:
index = self._selected_index.get_value_as_int()
if index >= 0 and index < len(self._items):
return self._items[index]
return None
def get_item_children(self, item) -> [StringQueueItem]:
if item is None:
return self._items
return []
def get_item_value_model(self, item, column_id) -> ui.AbstractValueModel:
if item is None:
return self._selected_index
return item.model
def find_item(self, value: str) -> StringQueueItem:
for item in self._items:
if item.value == value:
return item
return None
def size(self) -> int:
return len(self._items)
def peek(self) -> StringQueueItem:
if self._items:
return self._items[0]
return None
def enqueue(self, value: str):
if not value:
return
found = self.find_item(value)
if not found:
item = StringQueueItem(value)
self._items.insert(0, item)
while len(self._items) > self._max_items:
self.dequeue()
self.selected_index = 0
self._item_changed(None)
def dequeue(self):
if self._items:
self._items.pop(-1)
self.selected_index = min(self.selected_index, self.size()-1)
self._item_changed(None)
def _on_selection_changed(self, model: ui.AbstractValueModel):
if self._value_changed_fn:
self._value_changed_fn(model)
self._item_changed(None)
def destroy(self):
self._items = None
self._selected_index = None
class VisitedHistory():
def __init__(self, max_items: int = 100):
self._max_items = max_items
self._items = []
self._selected_index = 0
# the activation state for the visited history; when we are jumping between history entries, the visited history
# should not change; for example, when we click the prev/next button, the path field would update to that entry
# but those should not be counted in visited history.
self._active = True
def __getitem__(self, idx: int) -> str:
if idx < len(self._items):
return self._items[idx]
return None
def activate(self):
self._active = True
def deactivate(self):
self._active = False
@property
def selected_index(self) -> int:
return self._selected_index
@selected_index.setter
def selected_index(self, index: int):
self._selected_index = index
def get_selected_item(self) -> str:
index = self._selected_index
if index >= 0 and index < len(self._items):
return self._items[index]
return None
def size(self) -> int:
return len(self._items)
def insert(self, value: str):
if self._active is False:
return
if not value:
return
# avoid adding the same entry twice
# this could happen when actions on top sets the browser bar path to the same path twice
if self.size() > 0 and self._items[0] == value:
return
self._items.insert(0, value)
while self.size() > self._max_items:
self.pop()
self.selected_index = 0
def pop(self):
if self._items:
self._items.pop()
self.selected_index = min(self.selected_index, self.size()-1)
def destroy(self):
self._items.clear()
| 5,320 |
Python
| 30.485207 | 120 | 0.603008 |
omniverse-code/kit/exts/omni.kit.widget.browser_bar/omni/kit/widget/browser_bar/widget.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import sys, os
import omni.ui as ui
from omni.kit.widget.path_field import PathField
from .model import StringQueueModel, VisitedHistory
from .style import UI_STYLES, ICON_PATH
class BrowserBar:
"""
The Browser Bar extends the :obj:`PathField` UI widget for navigating tree views via the
keyboard. Namely, it adds navigation history. As in any modern day browser, this allows the
user to diectly jump to any previously visited path.
Args:
None
Keyword Args:
visited_history_size (int): Maximum number of previously visited paths to queue up. Default 10.
apply_path_handler (Callable): This function is called when the user updates the path and is
expected to update the caller app accordingly. The user can update the path in one of 3
ways: 1. by hitting Enter on the input field, 2. selecting a path from the dropdown,
or 3. by clicking on the "prev" or "next" buttons. Function signature:
void apply_path_handler(path: str)
branching_options_handler (Callable): This function is required to provide a list of possible
branches whenever prompted with a path. For example, if path = "C:", then the list of values
produced might be ["Program Files", "temp", ..., "Users"]. Function signature:
list(str) branching_options_handler(path: str, callback: func)
modal (bool): Used for modal window. Default False.
"""
def __init__(self, **kwargs):
self._path_field = None
self._next_button = None
self._prev_button = None
self._visited_menu = None
self._visited_queue = None
self._visited_history = None
self._visited_menu_bg = None
import carb.settings
theme = carb.settings.get_settings().get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
self._style = UI_STYLES[theme]
self._icon_path = f"{ICON_PATH}/{theme}"
self._visited_max_size = kwargs.get("visited_history_size", 10)
self._visited_history_max_size = kwargs.get("visited_history_max_size", 100)
self._apply_path_handler = kwargs.get("apply_path_handler", None)
self._branching_options_handler = kwargs.get("branching_options_handler", None)
# OM-49484: Add subscription to begin edit and apply callback, for example we could add callback to cancel
# initial navigation upon user edit
self._begin_edit_handler = kwargs.get("begin_edit_handler", None)
self._branching_options_provider = kwargs.get("branching_options_provider", None) # OBSOLETE
self._prefix_separator = kwargs.get("prefix_separator", None)
self._modal = kwargs.get("modal", False)
self._build_ui()
@property
def path(self) -> str:
"""str: Returns the current path as entered in the field box."""
if self._path_field:
return self._path_field.path
return None
def set_path(self, path: str):
"""
Sets the path and adds it to the history queue.
Args:
path (str): The full path name.
"""
if not path:
return
if self._path_field:
self._path_field.set_path(path)
self._update_visited(path)
def _build_ui(self):
import carb.settings
font_size = carb.settings.get_settings().get("/app/font/size") or 0
with ui.HStack(height=0, style=self._style):
self._prev_button = ui.Button(
image_url=f"{self._icon_path}/angle_left.svg",
image_height=16,
width=24,
clicked_fn=self._on_prev_button_pressed,
enabled=False,
)
self._next_button = ui.Button(
image_url=f"{self._icon_path}/angle_right.svg",
image_height=16,
width=24,
clicked_fn=self._on_next_button_pressed,
enabled=False,
)
with ui.ZStack():
ui.Rectangle()
# OM-66124: Update look for browser bar, use full width combobox and hide beneath Pathfield;
# FIXME: this is because currently we cannot control the menu width for arrow_only combo box;
with ui.ZStack():
# OM-66124: manually add combo box drop down background, since it is hard to control combo box height
# FIXME: Ideally should fix in ui.ComboBox directly
combo_dropdown_size = font_size + 8
with ui.HStack():
ui.Spacer()
with ui.VStack(width=combo_dropdown_size):
ui.Spacer()
self._visited_menu_bg = ui.Rectangle(height=22, style=self._style, style_type_name_override="ComboBox.Bg")
ui.Spacer()
with ui.HStack():
self._path_field = PathField(
apply_path_handler=self._apply_path_handler,
branching_options_handler=self._branching_options_handler,
prefix_separator=self._prefix_separator,
modal=self._modal,
begin_edit_handler=self._begin_edit_handler,
)
ui.Spacer(width=combo_dropdown_size)
self._build_visited_menu()
def _build_visited_menu(self):
self._visited_queue = StringQueueModel(
max_items=self._visited_max_size, value_changed_fn=self._on_menu_item_selected
)
self._visited_history = VisitedHistory(max_items=self._visited_history_max_size)
self._visited_menu = ui.ComboBox(self._visited_queue, arrow_only=False, style=self._style)
# Note: This callback is needed to trigger a refresh
self._visited_menu.model.add_item_changed_fn(lambda model, item: None)
def _update_visited(self, path: str):
if self._visited_queue:
self._visited_queue.enqueue(path)
self._visited_menu.style_type_name_override = "ComboBox.Active"
self._visited_menu_bg.style_type_name_override = "ComboBox.Bg.Active"
# update visited history
self._visited_history.insert(path)
self._update_nav_buttons()
self._visited_history.activate()
def _on_prev_button_pressed(self):
self._visited_history.deactivate()
selected_index = self._visited_history.selected_index
if selected_index >= self._visited_history.size() - 1:
return
else:
self._visited_history.selected_index = selected_index + 1
if self._path_field:
self._path_field.set_path(self._visited_history.get_selected_item())
if self._apply_path_handler:
self._apply_path_handler(self._visited_history.get_selected_item())
self._update_nav_buttons()
def _on_next_button_pressed(self):
self._visited_history.deactivate()
selected_index = self._visited_history.selected_index
if selected_index <= 0:
return
else:
self._visited_history.selected_index = selected_index - 1
if self._path_field:
self._path_field.set_path(self._visited_history.get_selected_item())
if self._apply_path_handler:
self._apply_path_handler(self._visited_history.get_selected_item())
self._update_nav_buttons()
def _update_nav_buttons(self):
if self._visited_history.selected_index > 0:
self._next_button.enabled = True
else:
self._next_button.enabled = False
if self._visited_history.selected_index < self._visited_history.size() - 1:
self._prev_button.enabled = True
else:
self._prev_button.enabled = False
def _on_menu_item_selected(self, model: ui.SimpleIntModel):
if not model:
return
menu_item = self._visited_queue[model.get_value_as_int()]
if menu_item:
if self._path_field:
self._path_field.set_path(menu_item.value)
if self._apply_path_handler:
self._apply_path_handler(menu_item.value)
def destroy(self):
if self._path_field:
self._path_field.destroy()
self._path_field = None
self._next_button = None
self._prev_button = None
self._visited_menu = None
self._visited_queue = None
if self._visited_history:
self._visited_history.destroy()
self._visited_menu_bg = None
self._style = None
self._apply_path_handler = None
self._branching_options_handler = None
self._begin_edit_handler = None
self._branching_options_provider = None
| 9,403 |
Python
| 42.537037 | 134 | 0.59917 |
omniverse-code/kit/exts/omni.kit.widget.browser_bar/omni/kit/widget/browser_bar/tests/test_widget.py
|
## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
from omni.ui.tests.test_base import OmniUiTest
from unittest.mock import Mock, call
from ..widget import BrowserBar
class TestBrowserBar(OmniUiTest):
"""Testing PathField.set_path"""
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_nav_buttons(self):
"""Testing navigation buttons"""
window = await self.create_test_window()
mock_path_handler = Mock()
with window.frame:
under_test = BrowserBar(apply_path_handler=mock_path_handler)
for path in ["one", "two", "three", "two", "three"]:
under_test.set_path(path)
self.assertEqual(under_test.path, "three/")
self.assertEqual(under_test._visited_history.size(), 5)
self.assertEqual(under_test._visited_queue.size(), 3)
under_test._prev_button.call_clicked_fn()
self.assertEqual(under_test.path, "two/")
under_test._prev_button.call_clicked_fn()
self.assertEqual(under_test.path, "three/")
under_test._prev_button.call_clicked_fn()
under_test._prev_button.call_clicked_fn()
self.assertEqual(under_test.path, "one/")
self.assertFalse(under_test._prev_button.enabled)
for _ in range(4):
under_test._next_button.call_clicked_fn()
self.assertEqual(under_test.path, "three/")
self.assertFalse(under_test._next_button.enabled)
self.assertEqual(
mock_path_handler.call_args_list,
[call('two'), call('three'), call('two'), call('one'), call('two'), call('three'), call('two'), call('three')]
)
async def test_nav_menu(self):
"""Testing navigation menu"""
window = await self.create_test_window()
mock_path_handler = Mock()
with window.frame:
under_test = BrowserBar(apply_path_handler=mock_path_handler)
for path in ["one", "two", "three"]:
under_test.set_path(path)
self.assertEqual(under_test.path, "three/")
model = under_test._visited_menu.model
self.assertEqual(model, under_test._visited_queue)
model.selected_index = 2
self.assertEqual(under_test.path, "one/")
# selecting one of navigation menu browse to that path, and will appear as the most recent visited history
self.assertFalse(under_test._next_button.enabled)
under_test.set_path("four")
self.assertEqual(model.selected_index, 0)
self.assertEqual(under_test.path, "four/")
| 2,988 |
Python
| 35.901234 | 122 | 0.649264 |
omniverse-code/kit/exts/omni.kit.widget.browser_bar/docs/CHANGELOG.md
|
# Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [2.0.5] - 2022-12-19
### Changes
- Update browser bar combo box style, add custom rectangle background to match UX.
## [2.0.4] - 2022-11-09
### Changes
- Fix to toml file
## [2.0.3] - 2022-03-09
### Changes
- Fixed navigation bugs. Added unittests.
## [2.0.2] - 2021-06-07
### Changes
- More thorough destruction of class instances upon shutdown.
## [2.0.1] - 2021-02-10
### Changes
- Updated StyleUI handling
## [2.0.0] - 2020-01-03
### Updated
- Refactored for async directory listing to improve overall stability in case of network delays.
### Added
- Keyword Arg: 'branching_options_handler'
### Deleted
- Keyword Arg: 'branching_options_provider'
## [0.1.4] - 2020-09-18
### Added
- Initial commit to master.
| 818 |
Markdown
| 22.399999 | 96 | 0.680929 |
omniverse-code/kit/exts/omni.kit.widget.cache_indicator/omni/kit/widget/cache_indicator/cache_state_menu.py
|
import asyncio
import aiohttp
import carb
import os
import toml
import time
import omni.client
import webbrowser
from omni.kit.menu.utils import MenuItemDescription, MenuAlignment
from omni import ui
from typing import Union
from .style import Styles
class CacheStateDelegate(ui.MenuDelegate):
def __init__(self, cache_enabled, hub_enabled, **kwargs):
super().__init__(**kwargs)
self._hub_enabled = hub_enabled
self._cache_enabled = cache_enabled
self._cache_widget = None
def destroy(self):
self._cache_widget = None
def build_item(self, item: ui.MenuHelper):
with ui.HStack(width=0, style={"margin" : 0}):
self._cache_widget = ui.HStack(content_clipping=1, width=0, style=Styles.CACHE_STATE_ITEM_STYLE)
ui.Spacer(width=10)
self.update_cache_state(self._cache_enabled, self._hub_enabled)
def get_menu_alignment(self):
return MenuAlignment.RIGHT
def update_menu_item(self, menu_item: Union[ui.Menu, ui.MenuItem], menu_refresh: bool):
if isinstance(menu_item, ui.MenuItem):
menu_item.visible = False
def update_cache_state(self, cache_enabled, hub_enabled):
self._hub_enabled = hub_enabled
self._cache_enabled = cache_enabled
if not self._cache_widget:
return
margin = 2
self._cache_widget.clear()
with self._cache_widget:
ui.Label("CACHE: ")
if hub_enabled:
ui.Label("HUB", style={"color": 0xff00b86b})
elif cache_enabled:
ui.Label("ON", style={"color": 0xff00b86b})
else:
with ui.VStack():
ui.Spacer(height=margin)
with ui.ZStack(width=0):
with ui.HStack(width=20):
ui.Spacer()
ui.Label("OFF", name="offline", width=0)
ui.Spacer(width=margin)
with ui.VStack(width=0):
ui.Spacer()
ui.Image(width=14, height=14, name="doc")
ui.Spacer()
ui.Spacer()
button = ui.InvisibleButton(width=20)
button.set_clicked_fn(lambda: webbrowser.open('https://docs.omniverse.nvidia.com/nucleus/cache_troubleshoot.html', new=2))
ui.Spacer(height=margin)
class CacheStateMenu:
def __init__(self):
self._live_menu_name = "Cache State Widget"
self._menu_list = [MenuItemDescription(name="placeholder", show_fn=lambda: False)]
global_config_path = carb.tokens.get_tokens_interface().resolve("${omni_global_config}")
self._omniverse_config_path = os.path.join(global_config_path, "omniverse.toml").replace("\\", "/")
self._all_cache_apis = []
self._hub_enabled = False
self._cache_enabled = False
self._last_time_check = 0
self._ping_cache_future = None
self._update_subscription = None
def _load_cache_config(self):
if os.path.exists(self._omniverse_config_path):
try:
contents = toml.load(self._omniverse_config_path)
except Exception as e:
carb.log_error(f"Unable to parse {self._omniverse_config_path}. File corrupted?")
contents = None
if contents:
self._all_cache_apis = self._load_all_cache_server_apis(contents)
if self._all_cache_apis:
self._cache_enabled = True
self._update_subscription = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(
self._on_update, name="omni.kit.widget.live update"
)
else:
carb.log_warn("Unable to detect Omniverse Cache Server. Consider installing it for better IO performance.")
self._cache_enabled = False
else:
carb.log_warn(f"Unable to detect Omniverse Cache Server. File {self._omniverse_config_path} is not found."
f" Consider installing it for better IO performance.")
def _get_hub_version_cb(self, result, version):
if result == omni.client.Result.OK:
self._hub_enabled = True
else:
self._hub_enabled = False
self._load_cache_config()
if self._cache_state_delegate:
self._cache_state_delegate.update_cache_state(self._cache_enabled, self._hub_enabled)
def _initialize(self):
self._get_hub_version_request = omni.client.get_hub_version_with_callback(self._get_hub_version_cb)
def register_menu_widgets(self):
self._initialize()
self._cache_state_delegate = CacheStateDelegate(self._cache_enabled, self._hub_enabled)
omni.kit.menu.utils.add_menu_items(self._menu_list, name=self._live_menu_name, delegate=self._cache_state_delegate)
def unregister_menu_widgets(self):
omni.kit.menu.utils.remove_menu_items(self._menu_list, self._live_menu_name)
if self._cache_state_delegate:
self._cache_state_delegate.destroy()
self._cache_state_delegate = None
self._menu_list = None
self._update_subscription = None
self._all_cache_apis = []
try:
if self._ping_cache_future and not self._ping_cache_future.done():
self._ping_cache_future.cancel()
self._ping_cache_future = None
except Exception:
self._ping_cache_future = None
def _on_update(self, dt):
if not self._cache_state_delegate or not self._all_cache_apis:
return
if not self._ping_cache_future or self._ping_cache_future.done():
now = time.time()
duration = now - self._last_time_check
# 30s
if duration < 30:
return
self._last_time_check = now
async def _ping_cache():
async with aiohttp.ClientSession() as session:
cache_enabled = None
for cache_api in self._all_cache_apis:
try:
async with session.head(cache_api):
''' If we're here the service port is alive '''
cache_enabled = True
except Exception as e:
cache_enabled = False
break
if cache_enabled is not None and self._cache_enabled != cache_enabled:
self._cache_enabled = cache_enabled
if self._cache_state_delegate:
self._cache_state_delegate.update_cache_state(self._cache_enabled, self._hub_enabled)
self._ping_cache_future = asyncio.ensure_future(_ping_cache())
def _load_all_cache_server_apis(self, config_contents):
mapping = os.environ.get("OMNI_CONN_CACHE", None)
if mapping:
mapping = f"*#{mapping},f"
else:
mapping = os.environ.get("OMNI_CONN_REDIRECTION_DICT", None)
if not mapping:
mapping = os.environ.get("OM_REDIRECTION_DICT", None)
if not mapping:
connection_library_dict = config_contents.get("connection_library", None)
if connection_library_dict:
mapping = connection_library_dict.get("proxy_dict", None)
all_proxy_apis = set([])
if mapping:
mapping = mapping.lstrip("\"")
mapping = mapping.rstrip("\"")
mapping = mapping.lstrip("'")
mapping = mapping.rstrip("'")
redirections = mapping.split(";")
for redirection in redirections:
parts = redirection.split("#")
if not parts or len(parts) < 2:
continue
source, target = parts[0], parts[1]
targets = target.split(",")
if not targets:
continue
if len(targets) > 1:
proxy_address = targets[0]
else:
proxy_address = target
if not proxy_address.startswith("http://") and not proxy_address.startswith("https://"):
proxy_address_api = f"http://{proxy_address}/ping"
else:
if proxy_address.endswith("/"):
proxy_address_api = f"{proxy_address}ping"
else:
proxy_address_api = f"{proxy_address}/ping"
all_proxy_apis.add(proxy_address_api)
return all_proxy_apis
| 8,866 |
Python
| 38.584821 | 146 | 0.545906 |
omniverse-code/kit/exts/omni.kit.widget.cache_indicator/omni/kit/widget/cache_indicator/style.py
|
from .icons import Icons
class Styles:
CACHE_STATE_ITEM_STYLE = None
LIVE_STATE_ITEM_STYLE = None
@staticmethod
def on_startup():
# It needs to delay initialization of style as icons need to be initialized firstly.
Styles.CACHE_STATE_ITEM_STYLE = {
"Image::doc": {"image_url": Icons.get("docs"), "color": 0xB04B4BFF},
"Label::offline": {"color": 0xB04B4BFF},
"Rectangle::offline": {"border_radius": 2.0},
"Rectangle::offline": {"background_color": 0xff808080},
"Rectangle::offline:hovered": {"background_color": 0xFF9E9E9E},
}
| 630 |
Python
| 34.055554 | 92 | 0.606349 |
omniverse-code/kit/exts/omni.kit.widget.cache_indicator/omni/kit/widget/cache_indicator/extension.py
|
# Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import omni.ext
import omni.kit.app
from .cache_state_menu import CacheStateMenu
from .icons import Icons
from .style import Styles
class OmniCacheIndicatorWidgetExtension(omni.ext.IExt):
def on_startup(self, ext_id):
extension_path = omni.kit.app.get_app_interface().get_extension_manager().get_extension_path(ext_id)
Icons.on_startup(extension_path)
Styles.on_startup()
self._cache_state_menu = CacheStateMenu()
self._cache_state_menu.register_menu_widgets()
def on_shutdown(self):
self._cache_state_menu.unregister_menu_widgets()
Icons.on_shutdown()
| 1,056 |
Python
| 34.233332 | 108 | 0.746212 |
omniverse-code/kit/exts/omni.kit.widget.cache_indicator/omni/kit/widget/cache_indicator/__init__.py
|
from .extension import OmniCacheIndicatorWidgetExtension
| 56 |
Python
| 55.999944 | 56 | 0.928571 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.