public TestTextureSceneView(SceneViewController sceneViewController)
: base("UnitTestPlugin.GUI.TestTextureSceneView.TestTextureSceneView.layout")
{
this.sceneViewController = sceneViewController;
Button addButton = (Button)window.findWidget("AddButton");
addButton.MouseButtonClick += addButton_MouseButtonClick;
Button removeButton = (Button)window.findWidget("RemoveButton");
removeButton.MouseButtonClick += removeButton_MouseButtonClick;
scrollView = (ScrollView)window.findWidget("ScrollView");
buttonGrid = new SingleSelectButtonGrid(scrollView);
window.WindowChangedCoord += window_WindowChangedCoord;
liveThumbHost = new ButtonGridLiveThumbnailController("TestRTT_", new IntSize2(200, 200), sceneViewController, buttonGrid, scrollView);
//numToUpdateEdit = (EditBox)window.findWidget("NumToUpdate");
//numToUpdateEdit.Caption = LiveThumbnailUpdater.NumImagesToUpdate.ToString();
//secondsToSleepEdit = (EditBox)window.findWidget("SecondsToSleep");
//secondsToSleepEdit.Caption = LiveThumbnailUpdater.SecondsToSleep.ToString();
//Button applyButton = (Button)window.findWidget("ApplyButton");
//applyButton.MouseButtonClick += applyButton_MouseButtonClick;
}
public CameraMovementModeTask(SceneViewController sceneViewController)
: base("Medical.CameraMovementMode", "Camera Mode", "", TaskMenuCategories.Explore)
{
this.ShowOnTaskbar = false;
selectionOperatorChooser = new CameraMovementModeChooser(sceneViewController);
sceneViewController.CameraMovementModeChanged += sceneViewController_CameraMovementModeChanged;
sceneViewController_CameraMovementModeChanged(sceneViewController.MovementMode);
}
public ImageRenderer(MedicalController controller, SceneViewController sceneViewController, IdleHandler idleHandler)
{
this.controller = controller;
this.sceneViewController = sceneViewController;
this.idleHandler = idleHandler;
TransparencyController.createTransparencyState(TransparencyStateName);
OgreResourceGroupManager.getInstance().createResourceGroup(RenderTextureResourceGroup);
}
public AnatomyContextWindowManager(SceneViewController sceneViewController, AnatomyController anatomyController, LayerController layerController, AnatomyFinder anatomyFinder, AnatomyTaskManager anatomyTaskManager)
{
this.sceneViewController = sceneViewController;
this.anatomyController = anatomyController;
this.anatomyController.SelectedAnatomy.SelectedAnatomyChanged += anatomyController_SelectedAnatomyChanged;
this.anatomyFinder = anatomyFinder;
this.layerController = layerController;
this.anatomyTaskManager = anatomyTaskManager;
liveThumbnailController = new LiveThumbnailController("ContextWindows_", new IntSize2(ThumbRenderSize, ThumbRenderSize), sceneViewController);
liveThumbnailController.MaxPoolSize = 1;
}
public CameraMovementModeChooser(SceneViewController sceneViewController)
: base("Medical.GUI.CameraMovementModeChooser.CameraMovementModeChooser.layout")
{
this.sceneViewController = sceneViewController;
sceneViewController.CameraMovementModeChanged += sceneViewController_CameraMovementModeChanged;
selectionOperators = new ButtonGroup <CameraMovementMode>();
setupSelectionButton(CameraMovementMode.Rotate, "RotateButton");
setupSelectionButton(CameraMovementMode.Pan, "PanButton");
setupSelectionButton(CameraMovementMode.Zoom, "ZoomButton");
selectionOperators.Selection = sceneViewController.MovementMode;
selectionOperators.SelectedButtonChanged += pickingModeGroup_SelectedButtonChanged;
}
public AdvancedCameraGui(SceneViewController sceneViewController)
: base("Developer.GUI.AdvancedCamera.AdvancedCameraGui.layout")
{
this.sceneViewController = sceneViewController;
sceneViewController.ActiveWindowChanged += SceneViewController_ActiveWindowChanged;
fovyEdit = new NumericEdit(window.findWidget("FovYEdit") as EditBox);
fovyEdit.MinValue = 5;
fovyEdit.MaxValue = 180;
fovyEdit.AllowFloat = true;
fovyEdit.Increment = 5;
fovyEdit.ValueChanged += FovyEdit_ValueChanged;
SceneViewController_ActiveWindowChanged(sceneViewController.ActiveWindow);
}
public MyGUITextDisplayFactory(SceneViewController sceneViewController)
{
this.sceneViewController = sceneViewController;
//Timeline Text Font
defaultFont = "TimelineText";
MyGUIDynamicFontManager timelineText = new MyGUIDynamicFontManager();
timelineText.addFont("TimelineText.10", 10);
timelineText.addFont("TimelineText.25", 25);
timelineText.addFont("TimelineText.50", 50);
timelineText.addFont("TimelineText.100", 100);
fonts.Add(defaultFont, timelineText);
}
public SimObjectMover(String name, RendererPlugin rendererPlugin, EventManager eventManager, SceneViewController sceneViewController)
{
this.sceneViewController = sceneViewController;
this.rendererPlugin = rendererPlugin;
this.name = name;
this.events = eventManager[GuiFrameworkEditorInterface.ToolsEventLayers];
events.OnUpdate += events_OnUpdate;
ToolSizeIncrement = 1.0f;
ToolSizeMinimum = 1.0f;
IncreaseToolSize.FirstFrameUpEvent += IncreaseToolSize_FirstFrameUpEvent;
DecreaseToolSize.FirstFrameUpEvent += DecreaseToolSize_FirstFrameUpEvent;
}
public MeasurementGrid(String name, SceneViewController sceneViewController)
{
gridResources = PluginManager.Instance.createLiveResourceManager("Grid");
var rendererResources = gridResources.getSubsystemResource("Ogre");
var materials = rendererResources.addResourceGroup("Materials");
materials.addResource(String.Format("{0}||Medical.Controller.Grid.", GetType().AssemblyQualifiedName), "EmbeddedResource", true);
gridResources.initializeResources();
this.name = name;
this.sceneViewController = sceneViewController;
sceneViewController.WindowCreated += new SceneViewWindowEvent(sceneViewController_WindowCreated);
sceneViewController.WindowDestroyed += new SceneViewWindowEvent(sceneViewController_WindowDestroyed);
}
public PoseController(StandaloneController controller)
{
activeModes.Add("Main");
controller.SceneLoaded += controller_SceneLoaded;
controller.SceneUnloading += controller_SceneUnloading;
sceneViewController = controller.SceneViewController;
anatomyController = controller.AnatomyController;
musclePositionController = controller.MusclePositionController;
if (controller.MedicalController.CurrentScene != null)
{
controller_SceneLoaded(controller.MedicalController.CurrentScene);
}
}
public VirtualTextureSceneViewLink(SceneController sceneController, SceneViewController sceneViewController, PluginManager pluginManager, UpdateTimer timer)
{
this.timer = timer;
timer.addUpdateListener(updateListener);
this.sceneController = sceneController;
sceneController.OnSceneLoaded += SceneController_OnSceneLoaded;
sceneController.OnSceneUnloading += SceneController_OnSceneUnloading;
cameraLink = new CameraLink(sceneViewController);
CompressedTextureSupport textureFormat = OgreInterface.Instance.SelectedTextureFormat;
virtualTextureManager = new VirtualTextureManager(UnifiedMaterialBuilder.GetNumCompressedTexturesNeeded(textureFormat), new IntSize2(4096, 4096), 128, 4096, textureFormat, 10, new IntSize2(256, 128), 100 * 1024 * 1024, UnifiedMaterialBuilder.AreTexturesPagedOnDisk(textureFormat));
materialBuilder = new UnifiedMaterialBuilder(virtualTextureManager, OgreInterface.Instance.SelectedTextureFormat, pluginManager.createLiveResourceManager("UnifiedShaders"));
OgreInterface.Instance.MaterialParser.addMaterialBuilder(materialBuilder);
}
public void Initialized(CoreApp pharosApp, PluginManager pluginManager)
{
var scope = pluginManager.GlobalScope;
//Build gui
sceneViewController = scope.ServiceProvider.GetRequiredService <SceneViewController>();
var sceneStatsDisplayManager = scope.ServiceProvider.GetRequiredService <SceneStatsDisplayManager>();
sceneStatsDisplayManager.StatsVisible = true;
sceneViewController.createWindow("Camera 1", Vector3.UnitX * 100, Vector3.Zero, Vector3.Min, Vector3.Max, 0.0f, float.MaxValue, 100);
var testWindow = scope.ServiceProvider.GetRequiredService <TestWindow>();
testWindow.Visible = true;
var rocketWindow = scope.ServiceProvider.GetRequiredService <RocketWindow>();
rocketWindow.Visible = true;
}
public void Initialized(GameApp app, PluginManager pluginManager)
{
Logging.Log.Info($"Loading archive {app.PrimaryArchivePath}");
VirtualFileSystem.Instance.addArchive(app.PrimaryArchivePath);
var scope = pluginManager.GlobalScope;
scope.ServiceProvider.GetRequiredService <VirtualTextureSceneViewLink>();
var guiManager = scope.ServiceProvider.GetRequiredService <GUIManager>();
var layoutChain = scope.ServiceProvider.GetRequiredService <LayoutChain>();
guiManager.createGUILayout(layoutChain);
layoutChain.layout();
//Build gui
sceneViewController = scope.ServiceProvider.GetRequiredService <SceneViewController>();
var sceneStatsDisplayManager = scope.ServiceProvider.GetRequiredService <SceneStatsDisplayManager>();
sceneStatsDisplayManager.StatsVisible = true;
sceneViewController.createWindow("Camera 1", Vector3.UnitX * 100, Vector3.Zero, Vector3.Min, Vector3.Max, 0.0f, float.MaxValue, 100);
lightManager = scope.ServiceProvider.GetRequiredService <SceneViewLightManager>();
var sceneController = scope.ServiceProvider.GetRequiredService <SceneController>();
sceneController.OnSceneLoaded += SceneController_OnSceneLoaded;
sceneController.OnSceneUnloading += SceneController_OnSceneUnloading;
var scene = "Scenes\\TestLevel.sim.xml";
if (VirtualFileSystem.Instance.fileExists(scene))
{
Logging.Log.Info($"Loading scene {scene}");
sceneController.loadSceneDefinition("Scenes\\TestLevel.sim.xml");
}
else
{
Logging.Log.Info($"Cannot load scene {scene}");
}
}
public ViewsGui(SceneViewController sceneViewController, AnatomyController anatomyController)
: base("Medical.GUI.ViewsGui.ViewsGui.layout")
{
this.sceneViewController = sceneViewController;
this.anatomyController = anatomyController;
Button button = window.findWidget("Front") as Button;
button.MouseButtonClick += (s, e) => setStraightAngleView(new Vector3(1.0f, 1.0f, 0.0f), new Vector3(0.0f, 0.0f, 1.0f));
button = window.findWidget("Back") as Button;
button.MouseButtonClick += (s, e) => setStraightAngleView(new Vector3(1.0f, 1.0f, 0.0f), new Vector3(0.0f, 0.0f, -1.0f));
button = window.findWidget("Left") as Button;
button.MouseButtonClick += (s, e) => setStraightAngleView(new Vector3(0.0f, 1.0f, 1.0f), new Vector3(1.0f, 0.0f, 0.0f));
button = window.findWidget("Right") as Button;
button.MouseButtonClick += (s, e) => setStraightAngleView(new Vector3(0.0f, 1.0f, 1.0f), new Vector3(-1.0f, 0.0f, 0.0f));
button = window.findWidget("Top") as Button;
button.MouseButtonClick += (s, e) => setTopBottomView(1);
button = window.findWidget("Bottom") as Button;
button.MouseButtonClick += (s, e) => setTopBottomView(-1);
button = window.findWidget("CenterVisible") as Button;
button.MouseButtonClick += (s, e) => showAllVisibleAnatomy();
undoItem = window.findWidget("Undo") as Button;
undoItem.MouseButtonClick += (s, e) => undo();
redoItem = window.findWidget("Redo") as Button;
redoItem.MouseButtonClick += (s, e) => redo();
sceneViewController.ActiveWindowChanged += sceneViewController_ActiveWindowChanged;
sceneViewController_ActiveWindowChanged(sceneViewController.ActiveWindow);
}
/// <summary>
/// Constructor.
/// </summary>
public AnomalyController(App app, Solution solution, IAnomalyImplementation implementation)
{
this.app = app;
this.solution = solution;
this.implementation = implementation;
//Create the log.
logListener = new LogFileListener();
logListener.openLogFile(AnomalyConfig.DocRoot + "/log.log");
Log.Default.addLogListener(logListener);
mainWindow = new NativeOSWindow(String.Format("{0} - Anomaly", solution.Name), new IntVector2(-1, -1), new IntSize2(AnomalyConfig.EngineConfig.HorizontalRes, AnomalyConfig.EngineConfig.VerticalRes));
mainWindow.Closed += mainWindow_Closed;
//Setup DPI
float pixelScale = mainWindow.WindowScaling;
ScaleHelper._setScaleFactor(pixelScale);
var builder = new ServiceCollection();
//Initialize the plugins
pluginManager = new PluginManager(AnomalyConfig.ConfigFile, builder);
sceneController = new SceneController(pluginManager);
//Hardcoded assemblies
MyGUIInterface.EventLayerKey = EventLayers.Main;
GuiFrameworkCamerasInterface.MoveCameraEventLayer = EventLayers.Cameras;
GuiFrameworkCamerasInterface.SelectWindowEventLayer = EventLayers.AfterMain;
GuiFrameworkCamerasInterface.ShortcutEventLayer = EventLayers.Main;
GuiFrameworkEditorInterface.ToolsEventLayers = EventLayers.Tools;
//Setup microcode cache load
OgreInterface.MicrocodeCachePath = Path.Combine(AnomalyConfig.DocRoot, "ShaderCache.mcc");
OgreInterface.AllowMicrocodeCacheLoad = AnomalyConfig.LastShaderVersion == UnifiedMaterialBuilder.Version;
AnomalyConfig.LastShaderVersion = UnifiedMaterialBuilder.Version;
implementation.AddPlugins(pluginManager);
pluginManager.OnConfigureDefaultWindow = createWindow;
//Create core classes
systemTimer = new NativeSystemTimer();
mainTimer = new NativeUpdateTimer(systemTimer);
mainTimer.FramerateCap = AnomalyConfig.EngineConfig.MaxFPS;
idleHandler = new IdleHandler(mainTimer.OnIdle);
inputHandler = new NativeInputHandler(mainWindow, false);
eventManager = new EventManager(inputHandler, Enum.GetValues(typeof(EventLayers)));
eventUpdate = new EventUpdateListener(eventManager);
builder.TryAddSingleton <EventManager>(eventManager); //This is externally owned
pluginManager.initializePlugins();
frameClearManager = new FrameClearManager(OgreInterface.Instance.OgrePrimaryWindow.OgreRenderTarget, new Color(0.2f, 0.2f, 0.2f));
lightManager = pluginManager.RendererPlugin.createSceneViewLightManager();
//Core resources
MyGUIInterface.Instance.CommonResourceGroup.addResource(this.GetType().AssemblyQualifiedName, "EmbeddedResource", true);
OgreResourceGroupManager.getInstance().initializeAllResourceGroups();
//Intialize the platform
mainTimer.addUpdateListener(eventUpdate);
mainTimer.addUpdateListener(updateEventListener);
pluginManager.setPlatformInfo(mainTimer, eventManager);
GuiFrameworkInterface.Instance.handleCursors(mainWindow);
//Layout Chain
mdiLayout = new MDILayoutManager();
//Scene views
sceneViewController = new SceneViewController(mdiLayout, eventManager, mainTimer, pluginManager.RendererPlugin.PrimaryWindow, MyGUIInterface.Instance.OgrePlatform.RenderManager, null);
sceneStatsDisplayManager = new SceneStatsDisplayManager(sceneViewController, OgreInterface.Instance.OgrePrimaryWindow.OgreRenderTarget);
sceneStatsDisplayManager.StatsVisible = true;
sceneViewController.createWindow("Camera 1", AnomalyConfig.CameraConfig.MainCameraPosition, AnomalyConfig.CameraConfig.MainCameraLookAt, Vector3.Min, Vector3.Max, 0.0f, float.MaxValue, 100);
virtualTextureLink = new VirtualTextureSceneViewLink(this);
//Tools
selectionMovementTools = new SimObjectMover("SelectionMover", PluginManager.Instance.RendererPlugin, eventManager, sceneViewController);
selectionMovementTools.Visible = true;
selectionMovementTools.addMovableObject("Selection", new SelectionMovableObject(selectionController));
mainForm = new AnomalyMain(this);
LayoutChain layoutChain = new LayoutChain();
layoutChain.addLink(new SingleChildChainLink(GUILocationNames.Taskbar, mainForm.LayoutContainer), true);
layoutChain.addLink(new PopupAreaChainLink(GUILocationNames.FullscreenPopup), true);
layoutChain.SuppressLayout = true;
layoutChain.addLink(new MDIChainLink(GUILocationNames.MDI, mdiLayout), true);
layoutChain.addLink(new PopupAreaChainLink(GUILocationNames.ContentAreaPopup), true);
layoutChain.addLink(new FinalChainLink("SceneViews", mdiLayout.DocumentArea), true);
layoutChain.SuppressLayout = false;
guiManager = new GUIManager();
guiManager.createGUI(mdiLayout, layoutChain, mainWindow);
layoutChain.layout();
splashScreen = new SplashScreen(mainWindow, 100, "Anomaly.GUI.SplashScreen.SplashScreen.layout", "Anomaly.GUI.SplashScreen.SplashScreen.xml");
splashScreen.Hidden += splashScreen_Hidden;
splashScreen.StatusUpdated += splashScreen_StatusUpdated;
splashScreen.updateStatus(0, "Loading...");
idleHandler.runTemporaryIdle(finishInitialization());
}
public CameraLink(SceneViewController sceneViewController)
{
this.sceneViewController = sceneViewController;
}
public MyGUIImageDisplayFactory(SceneViewController sceneViewController)
{
this.sceneViewController = sceneViewController;
}
public OgreModelEditorController(App app, String defaultModel)
{
this.app = app;
//Create the log.
logListener = new LogFileListener();
logListener.openLogFile(OgreModelEditorConfig.DocRoot + "/log.log");
Log.Default.addLogListener(logListener);
//Main window
mainWindow = new NativeOSWindow("Ogre Model Editor", new IntVector2(-1, -1), new IntSize2(OgreModelEditorConfig.EngineConfig.HorizontalRes, OgreModelEditorConfig.EngineConfig.VerticalRes));
mainWindow.Closed += mainWindow_Closed;
//Setup DPI
ScaleHelper._setScaleFactor(mainWindow.WindowScaling);
//Initailize plugins
MyGUIInterface.EventLayerKey = EventLayers.Main;
GuiFrameworkCamerasInterface.MoveCameraEventLayer = EventLayers.Cameras;
GuiFrameworkCamerasInterface.SelectWindowEventLayer = EventLayers.AfterMain;
GuiFrameworkCamerasInterface.ShortcutEventLayer = EventLayers.Main;
GuiFrameworkEditorInterface.ToolsEventLayers = EventLayers.Tools;
//Setup microcode cache load
OgreInterface.MicrocodeCachePath = Path.Combine(OgreModelEditorConfig.DocRoot, "ShaderCache.mcc");
OgreInterface.AllowMicrocodeCacheLoad = OgreModelEditorConfig.LastShaderVersion == UnifiedMaterialBuilder.Version;
OgreModelEditorConfig.LastShaderVersion = UnifiedMaterialBuilder.Version;
OgreInterface.TrackMemoryLeaks = true;
OgreInterface.CompressedTextureSupport = OgreModelEditorConfig.CompressedTextureSupport;
RuntimePlatformInfo.addPath(OgreModelEditorConfig.OpenGLESEmulatorPath);
pluginManager = new PluginManager(OgreModelEditorConfig.ConfigFile, new ServiceCollection());
pluginManager.OnConfigureDefaultWindow = createWindow;
pluginManager.addPluginAssembly(typeof(OgreInterface).Assembly);
pluginManager.addPluginAssembly(typeof(NativePlatformPlugin).Assembly);
pluginManager.addPluginAssembly(typeof(MyGUIInterface).Assembly);
pluginManager.addPluginAssembly(typeof(GuiFrameworkInterface).Assembly);
pluginManager.addPluginAssembly(typeof(GuiFrameworkCamerasInterface).Assembly);
pluginManager.addPluginAssembly(typeof(GuiFrameworkEditorInterface).Assembly);
pluginManager.addPluginAssembly(typeof(GuiFrameworkDebuggingInterface).Assembly);
pluginManager.initializePlugins();
frameClearManager = new FrameClearManager(OgreInterface.Instance.OgrePrimaryWindow.OgreRenderTarget, new Color(0.2f, 0.2f, 0.2f));
lightManager = pluginManager.RendererPlugin.createSceneViewLightManager();
//Core resources
MyGUIInterface.Instance.CommonResourceGroup.addResource(this.GetType().AssemblyQualifiedName, "EmbeddedResource", true);
OgreResourceGroupManager.getInstance().addResourceLocation(GetType().AssemblyQualifiedName, "EmbeddedResource", "DebugShaders", true);
OgreResourceGroupManager.getInstance().initializeAllResourceGroups();
//Intialize the platform
systemTimer = new NativeSystemTimer();
mainTimer = new NativeUpdateTimer(systemTimer);
mainTimer.FramerateCap = OgreModelEditorConfig.EngineConfig.MaxFPS;
idleHandler = new IdleHandler(mainTimer.OnIdle);
inputHandler = new NativeInputHandler(mainWindow, false);
eventManager = new EventManager(inputHandler, Enum.GetValues(typeof(EventLayers)));
eventUpdate = new EventUpdateListener(eventManager);
mainTimer.addUpdateListener(eventUpdate);
mainTimer.addUpdateListener(updateEventListener);
pluginManager.setPlatformInfo(mainTimer, eventManager);
GuiFrameworkInterface.Instance.handleCursors(mainWindow);
//Layout Chain
mdiLayout = new MDILayoutManager();
//Scene views
sceneViewController = new SceneViewController(mdiLayout, eventManager, mainTimer, pluginManager.RendererPlugin.PrimaryWindow, MyGUIInterface.Instance.OgrePlatform.RenderManager, null);
sceneStatsDisplayManager = new SceneStatsDisplayManager(sceneViewController, OgreInterface.Instance.OgrePrimaryWindow.OgreRenderTarget);
sceneStatsDisplayManager.StatsVisible = true;
sceneViewController.createWindow("Camera 1", OgreModelEditorConfig.CameraConfig.MainCameraPosition, OgreModelEditorConfig.CameraConfig.MainCameraLookAt, Vector3.Min, Vector3.Max, 0.0f, float.MaxValue, 100);
virtualTextureLink = new VirtualTextureSceneViewLink(this);
materialController = new MaterialController(this);
//Tools
objectMover = new SimObjectMover("ModelMover", PluginManager.Instance.RendererPlugin, eventManager, sceneViewController);
mainForm = new OgreModelEditorMain(this);
LayoutChain layoutChain = new LayoutChain();
layoutChain.addLink(new SingleChildChainLink(GUILocationNames.Taskbar, mainForm.LayoutContainer), true);
layoutChain.addLink(new PopupAreaChainLink(GUILocationNames.FullscreenPopup), true);
layoutChain.SuppressLayout = true;
layoutChain.addLink(new MDIChainLink(GUILocationNames.MDI, mdiLayout), true);
layoutChain.addLink(new PopupAreaChainLink(GUILocationNames.ContentAreaPopup), true);
layoutChain.addLink(new FinalChainLink("SceneViews", mdiLayout.DocumentArea), true);
layoutChain.SuppressLayout = false;
guiManager = new GUIManager(mdiLayout, mainWindow);
guiManager.createGUILayout(layoutChain);
layoutChain.layout();
splashScreen = new SplashScreen(mainWindow, 100, "OgreModelEditor.GUI.SplashScreen.SplashScreen.layout", "OgreModelEditor.GUI.SplashScreen.SplashScreen.xml");
splashScreen.Hidden += splashScreen_Hidden;
splashScreen.StatusUpdated += splashScreen_StatusUpdated;
splashScreen.updateStatus(0, "Loading...");
idleHandler.runTemporaryIdle(finishInitialization(defaultModel));
}
public ButtonGridLiveThumbnailController(String baseName, IntSize2 thumbSize, SceneViewController sceneViewController, ButtonGrid buttonGrid, ScrollView scrollView)
: this(new LiveThumbnailController(baseName, thumbSize, sceneViewController), buttonGrid, scrollView)
{
}
public AnatomyFinder(AnatomyController anatomyController, SceneViewController sceneViewController, LayerController layerController, AnatomyTaskManager anatomyTaskManager)
: base("Medical.GUI.Anatomy.AnatomyFinder.layout")
{
this.anatomyController = anatomyController;
anatomyController.AnatomyChanged += anatomyController_AnatomyChanged;
anatomyController.ShowPremiumAnatomyChanged += anatomyController_ShowPremiumAnatomyChanged;
anatomyController.ClearDisplayedAnatomy += anatomyController_ClearDisplayedAnatomy;
if (PlatformConfig.UnrestrictedEnvironment)
{
anatomyController.DisplayAnatomy += anatomyController_DisplayAnatomy;
}
else
{
anatomyController.DisplayAnatomy += anatomyController_DisplayAnatomy_Restricted;
}
anatomyController.SelectedAnatomy.SelectedAnatomyChanged += anatomyController_SelectedAnatomyChanged;
anatomyController.SearchStarted += anatomyController_SearchStarted;
anatomyController.SearchEnded += anatomyController_SearchEnded;
anatomyController.SuggestSearchCaption += anatomyController_SuggestSearchCaption;
this.sceneViewController = sceneViewController;
this.layerController = layerController;
this.layerController = layerController;
layerController.OnRedo += updateUndoRedo;
layerController.OnUndo += updateUndoRedo;
layerController.OnUndoRedoChanged += updateUndoRedo;
layerController.OnActiveTransparencyStateChanged += updateUndoRedo;
anatomyWindowManager = new AnatomyContextWindowManager(sceneViewController, anatomyController, layerController, this, anatomyTaskManager);
anatomyFilter = new AnatomyFilter(anatomyController);
anatomyFilter.refreshCategories();
anatomyFilter.FilterChanged += anatomyFilter_FilterChanged;
anatomyFilter.TopLevelAnatomyChanged += anatomyFilter_TopLevelAnatomyChanged;
Button filter = window.findWidget("Filter") as Button;
filter.MouseButtonClick += filter_MouseButtonClick;
ScrollView anatomyScroll = (ScrollView)window.findWidget("AnatomyList");
anatomyList = new HashSetMultiSelectButtonGrid(anatomyScroll, new ButtonGridListLayout(), naturalSort);
anatomyList.ItemActivated += anatomyList_ItemActivated;
anatomyList.ItemAdded += anatomyList_ItemAdded;
anatomyList.ItemRemoved += anatomyList_ItemRemoved;
anatomyList.ItemChosen += anatomyList_ItemChosen;
buttonGridThumbs = new ButtonGridLiveThumbnailController <Anatomy>("AnatomyFinder_", new IntSize2(ThumbRenderSize, ThumbRenderSize), sceneViewController, anatomyList, anatomyScroll);
searchBox = (EditBox)window.findWidget("SearchBox");
searchBox.EventEditTextChange += new MyGUIEvent(searchBox_EventEditTextChange);
clearButton = (Button)searchBox.findWidgetChildSkin("Clear");
clearButton.MouseButtonClick += new MyGUIEvent(clearButton_MouseButtonClick);
clearButton.NeedToolTip = true;
clearButton.EventToolTip += button_UserObject_EventToolTip;
clearButton.UserObject = "Clear Search";
Button unhideAll = window.findWidget("UnhideAll") as Button;
unhideAll.MouseButtonClick += (s, e) =>
{
LayerState undo = LayerState.CreateAndCapture();
this.layerController.unhideAll();
this.layerController.pushUndoState(undo);
};
undoButton = window.findWidget("Undo") as Button;
undoButton.MouseButtonClick += (s, e) => layerController.undo();
redoButton = window.findWidget("Redo") as Button;
redoButton.MouseButtonClick += (s, e) => layerController.redo();
PickAnatomy.FirstFrameDownEvent += PickAnatomy_FirstFrameDownEvent;
PickAnatomy.OnHeldDown += PickAnatomy_OnHeldDown;
PickAnatomy.FirstFrameUpEvent += pickAnatomy_FirstFrameUpEvent;
OpenAnatomyFinder.FirstFrameUpEvent += openAnatomyFinder_FirstFrameUpEvent;
if (!PlatformConfig.UnrestrictedEnvironment && !anatomyController.ShowPremiumAnatomy)
{
filter.Visible = false;
searchBox.Width = filter.Right - searchBox.Left;
}
this.Resized += new EventHandler(AnatomyFinder_Resized);
fixListItemWidth();
updateSearch();
}
public SlideEditorContext(Slide slide, String slideName, SlideshowEditController editorController, StandaloneController standaloneController, LectureUICallback uiCallback, UndoRedoBuffer undoBuffer, MedicalSlideItemTemplate itemTemplate, bool autoSetupScene, Action <String, String> wysiwygUndoCallback)
{
this.slide = slide;
this.uiCallback = uiCallback;
if (uiCallback.hasCustomQuery(PlayTimelineAction.CustomActions.EditTimeline))
{
uiCallback.removeCustomQuery(PlayTimelineAction.CustomActions.EditTimeline);
}
uiCallback.addOneWayCustomQuery(PlayTimelineAction.CustomActions.EditTimeline, new Action <PlayTimelineAction>(action_EditTimeline));
this.slideEditorController = editorController;
this.undoBuffer = undoBuffer;
this.imageRenderer = standaloneController.ImageRenderer;
this.itemTemplate = itemTemplate;
this.wysiwygUndoCallback = wysiwygUndoCallback;
this.editorController = editorController;
this.layerController = standaloneController.LayerController;
this.sceneViewController = standaloneController.SceneViewController;
panelResizeWidget = new PanelResizeWidget();
panelResizeWidget.RecordResizeUndo += panelResizeWidget_RecordResizeUndo;
displayManager = new SlideDisplayManager(editorController.VectorMode);
RunCommandsAction previewTriggerAction = new RunCommandsAction("PreviewTrigger");
imageStrategy = new SlideImageStrategy(slide, undoBuffer, this.slideEditorController.ResourceProvider, slide.UniqueName);
linkTriggerStrategy = new SlideTriggerStrategy(slide, createTriggerActionBrowser(), undoBuffer, "a", "TriggerLink", "Lecture.Icon.TriggerIcon", standaloneController.NotificationManager, previewTriggerAction);
linkTriggerStrategy.PreviewTrigger += triggerStrategy_PreviewTrigger;
buttonTriggerStragegy = new SlideTriggerStrategy(slide, createTriggerActionBrowser(), undoBuffer, "button", "Trigger", "Lecture.Icon.TriggerIcon", standaloneController.NotificationManager, previewTriggerAction);
buttonTriggerStragegy.PreviewTrigger += triggerStrategy_PreviewTrigger;
inputStrategy = new SlideInputStrategy(slide, undoBuffer, standaloneController.NotificationManager, previewTriggerAction, "input", CommonResources.NoIcon);
inputStrategy.PreviewTrigger += triggerStrategy_PreviewTrigger;
mvcContext = new AnomalousMvcContext();
mvcContext.StartupAction = "Common/Start";
mvcContext.FocusAction = "Common/Focus";
mvcContext.BlurAction = "Common/Blur";
mvcContext.SuspendAction = "Common/Suspended";
mvcContext.ResumeAction = "Common/Resumed";
showEditorWindowsCommand = new RunCommandsAction("ShowEditors");
closeEditorWindowsCommand = new RunCommandsAction("CloseEditors");
RunCommandsAction showCommand = new RunCommandsAction("Show",
new ShowViewCommand("InfoBar"),
new RunActionCommand("Editor/SetupScene"),
new RunActionCommand("Editor/ShowEditors")
);
refreshPanelEditors(false);
htmlDragDrop = new DragAndDropTaskManager <WysiwygDragDropItem>(
new WysiwygDragDropItem("Heading", "Editor/HeaderIcon", "<h1>Add Heading Here</h1>"),
new WysiwygDragDropItem("Paragraph", "Editor/ParagraphsIcon", "<p>Add paragraph text here.</p>"),
new WysiwygCallbackDragDropItem("Image", "Editor/ImageIcon", String.Format("<img src=\"{0}\" class=\"Center\" style=\"width:80%;\"></img>", RmlWysiwygComponent.DefaultImage),
() => //Markup Callback
{
String actionName = Guid.NewGuid().ToString();
ShowPopupImageAction action = new ShowPopupImageAction(actionName)
{
ImageName = RmlWysiwygComponent.DefaultImage
};
slide.addAction(action);
return(String.Format("<img src=\"{0}\" class=\"Center\" style=\"width:80%;\" onclick=\"{1}\"></img>", RmlWysiwygComponent.DefaultImage, actionName));
}),
new WysiwygDragDropItem("Data Dispaly", CommonResources.NoIcon, "<data type=\"volume\" target=\"\">Data Display</data>"),
new WysiwygCallbackDragDropItem("Trigger", "Lecture.Icon.TriggerIcon", "<button class=\"Trigger\" onclick=\"\">Add trigger text here.</a>",
() => //Markup Callback
{
String actionName = Guid.NewGuid().ToString();
SetupSceneAction action = new SetupSceneAction(actionName);
action.captureSceneState(uiCallback);
slide.addAction(action);
return(String.Format("<button class=\"Trigger\" onclick=\"{0}\">Add trigger text here.</a>", actionName));
}),
new WysiwygCallbackDragDropItem("Slider", CommonResources.NoIcon, "<input type=\"range\" min=\"0\" max=\"100\" value=\"0\" change=\"\"/>",
() => //Markup Callback
{
String actionName = Guid.NewGuid().ToString();
BlendSceneAction action = new BlendSceneAction(actionName);
action.captureSceneToStartAndEnd(uiCallback);
slide.addAction(action);
return(String.Format("<input type=\"range\" min=\"0\" max=\"100\" value=\"0\" onchange=\"{0}\"/>", actionName));
})
);
htmlDragDrop.Dragging += (item, position) =>
{
foreach (var editor in rmlEditors.Values)
{
editor.Component.setPreviewElement(position, item.PreviewMarkup, item.PreviewTagType);
}
};
htmlDragDrop.DragEnded += (item, position) =>
{
bool allowAdd = true;
foreach (var editor in rmlEditors.Values)
{
if (allowAdd && editor.Component.contains(position))
{
editor.Component.insertRml(item.createDocumentMarkup());
setCurrentRmlEditor(editor.View.Name);
allowAdd = false;
}
else
{
editor.Component.cancelAndHideEditor();
editor.Component.clearPreviewElement(false);
}
}
};
htmlDragDrop.ItemActivated += (item) =>
{
rmlEditors[currentRmlEditor].Component.insertRml(item.createDocumentMarkup());
};
taskbar = new SlideTaskbarView("InfoBar", slideName);
taskbar.addTask(new CallbackTask("Save", "Save", "CommonToolstrip/Save", "", 0, true, item =>
{
saveAll();
}));
taskbar.addTask(new CallbackTask("Undo", "Undo", "Lecture.Icon.Undo", "Edit", 0, true, item =>
{
undoBuffer.undo();
}));
taskbar.addTask(new CallbackTask("Redo", "Redo", "Lecture.Icon.Redo", "Edit", 0, true, item =>
{
undoBuffer.execute();
}));
foreach (Task htmlDragDropTask in htmlDragDrop.Tasks)
{
taskbar.addTask(htmlDragDropTask);
}
taskbar.addTask(new CallbackTask("AddSlide", "Add Slide", "Lecture.Icon.AddSlide", "Edit", 0, true, item =>
{
slideEditorController.createSlide();
}));
taskbar.addTask(new CallbackTask("DuplicateSlide", "Duplicate Slide", "Lecture.Icon.DuplicateSlide", "Edit", 0, true, item =>
{
slideEditorController.duplicateSlide(slide);
}));
taskbar.addTask(new CallbackTask("RemoveSlide", "Remove Slide", "Lecture.Icon.RemoveSlide", "Edit", 0, true, item =>
{
editorController.removeSelectedSlides();
}));
taskbar.addTask(new CallbackTask("Capture", "Capture", "Lecture.Icon.Capture", "Edit", 0, true, item =>
{
editorController.capture();
}));
taskbar.addTask(new CallbackTask("EditTimeline", "Edit Timeline", "Lecture.Icon.EditTimeline", "Edit", 0, true, item =>
{
editorController.editTimeline(slide, "Timeline.tl", "Timeline");
}));
taskbar.addTask(new CallbackTask("Present", "Present", "Lecture.Icon.Present", "Edit", 0, true, item =>
{
editorController.runSlideshow(slide);
}));
taskbar.addTask(new CallbackTask("PresentFromBeginning", "Present From Beginning", "Lecture.Icon.PresentBeginning", "Edit", 0, true, item =>
{
editorController.runSlideshow(0);
}));
slideLayoutPicker = new SlideLayoutPickerTask();
makeTempPresets();
slideLayoutPicker.ChangeSlideLayout += slideLayoutPicker_ChangeSlideLayout;
taskbar.addTask(slideLayoutPicker);
styleManager = new SlideshowStyleManager(editorController, uiCallback);
styleManager.addStyleFile(Path.Combine(slide.UniqueName, Slide.StyleSheetName), "This Slide");
styleManager.addStyleFile("SlideMasterStyles.rcss", "All Slides");
taskbar.addTask(new CallbackTask("EditSlideshowTheme", "Edit Slideshow Theme", "Lecture.Icon.EditStyle", "Edit", 0, true, item =>
{
IntVector2 taskPosition = item.CurrentTaskPositioner.findGoodWindowPosition(SlideshowStyleManager.Width, SlideshowStyleManager.Height);
styleManager.showEditor(taskPosition.x, taskPosition.y);
}));
taskbar.addTask(new CallbackTask("ResetSlide", "Reset Slide", "Lecture.Icon.RevertIcon", "Edit", 0, true, item =>
{
resetSlide();
}));
mvcContext.Views.add(taskbar);
setupScene = new RunCommandsAction("SetupScene");
if (autoSetupScene)
{
setupScene.addCommand(new CallbackCommand(context =>
{
undoState = LayerState.CreateAndCapture();
undoCamera = sceneViewController.ActiveWindow != null ? sceneViewController.ActiveWindow.createCameraPosition() : null;
}));
slide.populateCommand(setupScene);
setupScene.addCommand(new CallbackCommand(context =>
{
if (undoState != null)
{
layerController.pushUndoState(undoState);
undoState = null;
}
if (undoCamera != null)
{
if (sceneViewController.ActiveWindow != null)
{
sceneViewController.ActiveWindow.pushUndoState(undoCamera);
}
undoCamera = null;
}
}));
}
mvcContext.Controllers.add(new MvcController("Editor",
setupScene,
showCommand,
showEditorWindowsCommand,
closeEditorWindowsCommand,
new RunCommandsAction("Close", new CloseAllViewsCommand())
));
mvcContext.Controllers.add(new MvcController("Common",
new RunCommandsAction("Start", new RunActionCommand("Editor/Show")),
new CallbackAction("Focus", context =>
{
htmlDragDrop.CreateIconPreview();
GlobalContextEventHandler.setEventContext(eventContext);
if (Focus != null)
{
Focus.Invoke(this);
}
slideLayoutPicker.createLayoutPicker();
panelResizeWidget.createResizeWidget();
if (currentRmlEditor != null) //Make sure we have an active editor
{
String current = currentRmlEditor;
currentRmlEditor = null;
setCurrentRmlEditor(current);
}
this.slideEditorController.VectorModeChanged += slideEditorController_VectorModeChanged;
}),
new CallbackAction("Blur", blur),
new RunCommandsAction("Suspended", new SaveViewLayoutCommand()),
new RunCommandsAction("Resumed", new RestoreViewLayoutCommand()),
previewTriggerAction));
eventContext = new EventContext();
ButtonEvent saveEvent = new ButtonEvent(EventLayers.Gui);
saveEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
saveEvent.addButton(KeyboardButtonCode.KC_S);
saveEvent.FirstFrameUpEvent += eventManager =>
{
saveAll();
};
eventContext.addEvent(saveEvent);
ButtonEvent undoEvent = new ButtonEvent(EventLayers.Gui);
undoEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
undoEvent.addButton(KeyboardButtonCode.KC_Z);
undoEvent.FirstFrameUpEvent += eventManager =>
{
undoBuffer.undo();
};
eventContext.addEvent(undoEvent);
ButtonEvent redoEvent = new ButtonEvent(EventLayers.Gui);
redoEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
redoEvent.addButton(KeyboardButtonCode.KC_Y);
redoEvent.FirstFrameUpEvent += eventManager =>
{
undoBuffer.execute();
};
eventContext.addEvent(redoEvent);
ButtonEvent runEvent = new ButtonEvent(EventLayers.Gui);
runEvent.addButton(KeyboardButtonCode.KC_F5);
runEvent.FirstFrameUpEvent += eventManager =>
{
ThreadManager.invoke(() =>
{
editorController.runSlideshow(0);
});
};
eventContext.addEvent(runEvent);
ButtonEvent captureEvent = new ButtonEvent(EventLayers.Gui);
captureEvent.addButton(KeyboardButtonCode.KC_LCONTROL);
captureEvent.addButton(KeyboardButtonCode.KC_SPACE);
captureEvent.FirstFrameUpEvent += eventManager =>
{
editorController.capture();
};
eventContext.addEvent(captureEvent);
}
public BookmarksGUI(BookmarksController bookmarksController, GUIManager guiManager, SceneViewController sceneViewController)
: base("Medical.GUI.Bookmarks.BookmarksGUI.layout", guiManager)
{
this.bookmarksController = bookmarksController;
bookmarksController.BookmarkAdded += bookmarksController_BookmarkAdded;
bookmarksController.BookmarkRemoved += bookmarksController_BookmarkRemoved;
bookmarksController.PremiumBookmarksChanged += bookmarksController_PremiumBookmarksChanged;
bookmarksController.BookmarkPathAdded += bookmarksController_BookmarkPathAdded;
bookmarksController.BookmarkPathRemoved += bookmarksController_BookmarkPathRemoved;
bookmarksController.BookmarksCleared += bookmarksController_BookmarksCleared;
bookmarksController.BookmarkPathsCleared += bookmarksController_BookmarkPathsCleared;
bookmarksController.CurrentPathChanged += bookmarksController_CurrentPathChanged;
ScrollView bookmarksListScroll = (ScrollView)widget.findWidget("BookmarksList");
bookmarksList = new NoSelectButtonGrid(bookmarksListScroll);
bookmarksList.ItemRemoved += bookmarksList_ItemRemoved;
folderTree = new Tree(widget.findWidget("FolderTree") as ScrollView);
folderTree.AfterSelect += folderTree_AfterSelect;
addButton = (Button)widget.findWidget("AddButton");
addButton.MouseButtonClick += new MyGUIEvent(addButton_MouseButtonClick);
emptyTrashButton = widget.findWidget("EmptyTrash") as Button;
emptyTrashButton.MouseButtonClick += emptyTrashButton_MouseButtonClick;
emptyTrashButton.Visible = false;
bookmarkName = (EditBox)widget.findWidget("BookmarkName");
widgetSmallSize = new IntSize2(widget.Width, widget.Height - bookmarksListScroll.Height);
widget.setSize(widgetSmallSize.Width, widgetSmallSize.Height);
this.Showing += BookmarksGUI_Showing;
dragIconPreview = (ImageBox)Gui.Instance.createWidgetT("ImageBox", "ImageBox", 0, 0, BookmarkSize, BookmarkSize, Align.Default, "Info", "BookmarksDragIconPreview");
dragIconPreview.Visible = false;
Button closeButton = (Button)widget.findWidget("CloseButton");
closeButton.MouseButtonClick += new MyGUIEvent(closeButton_MouseButtonClick);
toggleAddCustomBookmarks();
liveThumbController = new ButtonGridLiveThumbnailController <Bookmark>("Bookmarks_", new IntSize2(BookmarkThumbSize, BookmarkThumbSize), sceneViewController, bookmarksList, bookmarksListScroll);
addFolder = widget.findWidget("AddFolder") as Button;
addFolder.MouseButtonClick += addFolder_MouseButtonClick;
removeFolder = widget.findWidget("RemoveFolder") as Button;
removeFolder.MouseButtonClick += removeFolder_MouseButtonClick;
}
public MedicalSlideItemTemplate(SceneViewController sceneViewController, MedicalStateController medicalStateController)
{
this.sceneViewController = sceneViewController;
this.medicalStateController = medicalStateController;
}
public LiveThumbnailController(String baseName, IntSize2 size, SceneViewController sceneViewController)
{
this.sceneViewController = sceneViewController;
this.texturePool = new TextureSceneViewPool(sceneViewController, baseName, size);
texturePool.SceneViewDestroyed += texturePool_SceneViewDestroyed;
}
public ChangeWindowLayoutTask(SceneViewController sceneViewController)
: base("Medical.ChangeWindowLayout", "Window Layout", "PremiumFeatures/WindowLayoutIcon", TaskMenuCategories.System)
{
this.sceneViewController = sceneViewController;
}
public void initializeControllers(BackgroundScene background, LicenseManager licenseManager)
{
//Background
this.background = background;
this.LicenseManager = licenseManager;
atlasPluginManager = new AtlasPluginManager(this);
atlasPluginManager.PluginLoadError += new Medical.AtlasPluginManager.PluginMessageDelegate(atlasPluginManager_PluginLoadError);
atlasPluginManager.manageInstalledPlugins();
clipboard = new SaveableClipboard();
//Documents
DocumentController = new DocumentController();
//MDI Layout
mdiLayout = new MDILayoutManager();
//SceneView
MyGUIInterface myGUI = MyGUIInterface.Instance;
sceneViewController = new SceneViewController(mdiLayout, medicalController.EventManager, medicalController.MainTimer, medicalController.PluginManager.RendererPlugin.PrimaryWindow, myGUI.OgrePlatform.RenderManager, background);
sceneViewController.WindowCreated += sceneViewController_WindowCreated;
sceneViewController.WindowDestroyed += sceneViewController_WindowDestroyed;
sceneViewController.DefaultBackgroundColor = new Color(0.274f, 0.274f, 0.274f);
sceneStatsDisplayManager = new SceneStatsDisplayManager(sceneViewController, OgreInterface.Instance.OgrePrimaryWindow.OgreRenderTarget);
sceneStatsDisplayManager.StatsVisible = MedicalConfig.EngineConfig.ShowStatistics;
MedicalConfig.EngineConfig.ShowStatsToggled += engineConfig => sceneStatsDisplayManager.StatsVisible = engineConfig.ShowStatistics;
lightManager = PluginManager.Instance.RendererPlugin.createSceneViewLightManager();
//Measurement grid
measurementGrid = new MeasurementGrid("MeasurementGrid", sceneViewController);
SceneUnloading += measurementGrid.sceneUnloading;
SceneLoaded += measurementGrid.sceneLoaded;
//Image Renderer
imageRenderer = new ImageRenderer(medicalController, sceneViewController, idleHandler);
imageRenderer.Background = background;
imageRenderer.ImageRenderStarted += measurementGrid.ScreenshotRenderStarted;
imageRenderer.ImageRenderCompleted += measurementGrid.ScreenshotRenderCompleted;
//Anatomy Controller
anatomyController = new AnatomyController();
//Medical states
medicalStateController = new MedicalStateController(imageRenderer, medicalController);
SceneLoaded += medicalStateController.sceneLoaded;
SceneUnloading += medicalStateController.sceneUnloading;
//Movement sequences
movementSequenceController = new MovementSequenceController(medicalController);
this.SceneLoaded += movementSequenceController.sceneLoaded;
musclePositionController = new MusclePositionController(medicalController.MainTimer, this);
SceneLoaded += SleepyActorRepository.SceneLoaded;
SceneUnloading += SleepyActorRepository.SceneUnloading;
//Props
propFactory = new PropFactory(this);
//Timeline
timelineController = new TimelineController(this);
viewHostFactory = new MyGUIViewHostFactory(mdiLayout);
mvcCore = new AnomalousMvcCore(this, viewHostFactory);
//Patient data
patientDataController = new PatientDataController(this);
//Tasks
taskController = new TaskController();
anatomyTaskManager = new AnatomyTaskManager(taskController, guiManager);
//Coroutine
Coroutine.SetTimer(medicalController.MainTimer);
//Notifications
notificationManager = new NotificationGUIManager();
layerController = new LayerController();
//Create virtual texture manager
virtualTextureSceneViewLink = new VirtualTextureSceneViewLink(this);
}
public AspectRatioTask(SceneViewController sceneViewController)
: base("Editor.AspectRatio", "Aspect Ratio", "EditorIcons.AspectRatioIcon", TaskMenuCategories.Create)
{
this.ShowOnTaskbar = false;
this.sceneViewController = sceneViewController;
}
public void setSceneViewController(SceneViewController sceneViewController)
{
sceneViewController.WindowCreated += sceneViewController_WindowCreated;
}
public ChangeRenderingMode(SceneViewController sceneViewController)
: base("Medical.ChangeRenderingMode", "Rendering Mode", "Developer.RenderingMode", "Developer")
{
this.sceneViewController = sceneViewController;
}
void Start()
{
svc = sceneView.GetComponent <SceneViewController>();
}
