public override void HandleInput(InputHelper inputHelper)
{
base.HandleInput(inputHelper);
if (resume.Pressed)
{
OverlayManager overlay = GameWorld.GetObject("overlay") as OverlayManager;
overlay.SwitchTo("hud");
}
else if (main.Pressed)
{
if (MultiplayerManager.Online)
{
MultiplayerManager.Party.Disconnect();
}
GameEnvironment.ScreenFade.TransitionToScene("titleScreen");
}
else if (quit.Pressed)
{
if (MultiplayerManager.Online)
{
MultiplayerManager.Party.Disconnect();
}
GameEnvironment.QuitGame = true;
}
}
public void Initialize()
{
int index = 0;
overMan = GameManager.instance.overlayManager;
foreach (KeyValuePair <OverlayType, OverlayManager.IOverlay> overPair in overMan.overlays)
{
OverlayType overType = overPair.Key;
OverlayManager.IOverlay over = overPair.Value;
GameObject overlayButton = Instantiate(overlayButtonExample, transform);
Button overlayButtonComponent = overlayButton.GetComponent <Button>();
int value = index;
overlayButtonComponent.onClick.AddListener(delegate {
overMan.SelectOverlay(overType);
Select(value);
});
overlayButton.GetComponent <Tooltip>().AddLocalizedLine(
new Localization.Line("overlay", over.codeName)
);
buttons.Add(overlayButton.GetComponents <Image>());
overlayButton.transform.GetChild(0).gameObject.GetComponent <Image>().sprite = over.sprite;
index++;
}
Destroy(overlayButtonExample);
Reset();
}
public CroppingAdorner(UIElement adornedElement) : base(adornedElement)
{
_visualCollection = new VisualCollection(this);
_originalCanvas = (Canvas)adornedElement;
_canvasOverlay = new Canvas();
_rectangleManager = new RectangleManager(_canvasOverlay);
_overlayManager = new OverlayManager(_canvasOverlay, _rectangleManager);
_thumbManager = new ThumbManager(_canvasOverlay, _rectangleManager);
_displayTextManager = new DisplayTextManager(_canvasOverlay, _rectangleManager);
_visualCollection.Add(_canvasOverlay);
MouseLeftButtonDown += MouseLeftButtonDownEventHandler;
MouseMove += MouseMoveEventHandler;
MouseLeftButtonUp += MouseLeftButtonUpEventHandler;
//add overlay
Loaded += (sender, args) => { _overlayManager.UpdateOverlay(); };
//if rectangle size chanhed, re-draw overlay
_rectangleManager.RectangleSizeChanged += (sender, args) =>
{
_overlayManager.UpdateOverlay();
_displayTextManager.UpdateSizeText();
};
_rectangleManager.OnRectangleDoubleClickEvent += (sender, args) =>
{
if (OnRectangleDoubleClickEvent != null)
{
OnRectangleDoubleClickEvent(sender, new DoubleClickEventArgs()
{
BitmapFrame = GetCroppedBitmapFrame()
});
}
};
}
public static void Init()
{
if (initialized)
return;
if (Skin == null)
{
try
{
Assembly assembly = Assembly.GetExecutingAssembly();
Skin = new Bitmap(assembly.GetManifestResourceStream(ScaleHelper.GetScale() > 1.5 ? "SourceControl.Resources.icons32.png" : "SourceControl.Resources.icons.png"));
}
catch
{
Skin = ScaleHelper.GetScale() > 1.5 ? new Bitmap(320, 32) : new Bitmap(160, 16);
}
}
fsWatchers = new FSWatchers();
ovManager = new OverlayManager(fsWatchers);
vcManager = new VCManager(ovManager);
SetProject(PluginBase.CurrentProject as Project);
initialized = true;
}
public override void HandleInput(InputHelper inputHelper)
{
base.HandleInput(inputHelper);
OverlayManager overlay = GameWorld.GetObject("overlay") as OverlayManager;
if (inputHelper.KeyPressed(Keys.I) || exit.Pressed)
{
overlay.SwitchTo("hud");
}
if (invetory.Pressed)
{
overlay.SwitchTo("inventory");
}
if (skills.Pressed)
{
}
if (button3.Pressed)
{
}
if (button4.Pressed)
{
}
if (intel.Pressed)
{
}
}
public static void Init()
{
if (initialized)
{
return;
}
if (Skin == null)
{
try
{
Assembly assembly = Assembly.GetExecutingAssembly();
Skin = new Bitmap(assembly.GetManifestResourceStream("SourceControl.Resources.icons.png"));
}
catch
{
Skin = new Bitmap(160, 16);
}
}
fsWatchers = new FSWatchers();
ovManager = new OverlayManager(fsWatchers);
vcManager = new VCManager(ovManager);
SetProject(PluginBase.CurrentProject as Project);
initialized = true;
}
public void PaintOverlays_PaintsAllOverlaysAndRestoresGraphicsContextForEachOne()
{
var overlayManager = new OverlayManager();
var overlay1 = new OverlayThatChangesInterpolationMode();
var overlay2 = new OverlayThatChangesInterpolationMode();
overlayManager.AddOverlay(overlay1);
overlayManager.AddOverlay(overlay2);
using (Bitmap bitmap = new Bitmap(32, 32))
{
using (Graphics graphics = Graphics.FromImage(bitmap))
{
graphics.InterpolationMode = InterpolationMode.HighQualityBilinear;
var request = new OverlayPaintRequest(graphics, new Rectangle(0, 0, 32, 32), 0, 0);
overlayManager.PaintOverlays(request);
Assert.Multiple(() =>
{
Assert.AreEqual(InterpolationMode.HighQualityBilinear, graphics.InterpolationMode);
Assert.IsTrue(overlay1.WasPainted);
Assert.AreEqual(InterpolationMode.HighQualityBilinear, overlay1.OldInterpolationMode);
Assert.IsTrue(overlay2.WasPainted);
Assert.AreEqual(InterpolationMode.HighQualityBilinear, overlay2.OldInterpolationMode);
});
}
}
}
/// <summary>
/// Called when the botbase gets stopped.
/// </summary>
public override void Stop()
{
// Destroy the navigator
Navigator.PlayerMover = new NullMover();
Navigator.NavigationProvider = new NullProvider();
// Unregister the hotkeys
HotkeyHelper.Instance.UnregisterHotkeys();
try
{
Core.Memory.Patches["GroundSpeedHook"].Remove();
Core.Memory.Patches["CombatReachHook"].Remove();
Core.Memory.Patches["NoKnockbackPatch"].Remove();
}
catch (Exception e)
{
}
// Stop Overlays
OverlayManager.StopFocusOverlay();
OverlayManager.StopStatusOverlay();
//OverlayManager.StatusOverlay.Update(StatusOverlayUiComponent.RunningStatus.Stopped);
try { PluginManager.Plugins.First(i => i.Plugin.Name == "SideStep").Enabled = sidestepStatus; }
catch { }
}
//static Thread t1 => new Thread(() =>
// {
// LogHelper.Instance.Log("<AnimationHack> Thread Started.");
// while (running)
// {
// if (BotBase.Instance.EnableAnimationLockHack)
// {
// Core.Memory.Write(AnimationLockTimer, BotBase.Instance.AnimationLockMaxDelay);
// }
// if (BotBase.Instance.EnableAnimationSpeedHack)
// {
// Core.Memory.Write(Core.Me.Pointer + 0xCD4, BotBase.Instance.AnimationSpeed);
// Core.Memory.Write(Core.Me.Pointer + 0xCD8, BotBase.Instance.AnimationSpeed);
// }
// Thread.SpinWait(10);
// }
// LogHelper.Instance.Log("<AnimationHack> Thread Aborted.");
// });
/// <summary>
/// Called when the botbase gets started.
/// </summary>
public override void Start()
{
try { sidestepStatus = PluginManager.Plugins.First(i => i.Plugin.Name == "SideStep").Enabled; }
catch { }
// Always start paused
Settings.BotBase.Instance.IsPaused = false;
// Set up navigation
Navigator.PlayerMover = new SlideMover();
Navigator.NavigationProvider = new ServiceNavigationProvider();
// Register the hotkeys
HotkeyHelper.Instance.ReloadHotkeys();
//// Less than 30 TPS are a no-no due to the design of this botbase. At least warn the user of this!
//if (TreeRoot.TicksPerSecond < 30)
//{
// LogHelper.Instance.Log(Localization.Localization.Msg_Not30Tps_Log);
// OverlayHelper.Instance.AddToast(Localization.Localization.Msg_Not30Tps, Colors.Red, Colors.DarkRed, TimeSpan.FromSeconds(10));
//}
if (Settings.BotBase.Instance.UseStatusOverlay)
{
OverlayManager.StartStatusOverlay();
}
if (Settings.BotBase.Instance.UseFocusOverlay)
{
OverlayManager.StartFocusOverlay();
}
}
/// <summary>
/// Static utility method used to get the cursor's offset from the center<para></para>
/// of an overlay element in pixels.
/// </summary>
/// <param name="element"></param>
/// <param name="cursorPos"></param>
/// <returns></returns>
public static Vector2 CursorOffset(OverlayElement element, Vector2 cursorPos)
{
OverlayManager om = OverlayManager.Instance;
return(new Vector2(cursorPos.x - (element.DerivedLeft * om.ViewportWidth + element.Width / 2),
cursorPos.y - (element.DerivedTop * om.ViewportHeight + element.Height / 2)));
}
static public void Init11()
{
GameObject obj = new GameObject();
obj.name = "OverlayManger";
overlayManager = obj.AddComponent <OverlayManager>();
}
public static void AddTextBox(String id, String text, float x, float y, float width, float height, ColourValue colorTop, ColourValue colorBot)
{
try {
OverlayManager overlayMgr = OverlayManager.Singleton;
OverlayContainer panel = (OverlayContainer)overlayMgr.CreateOverlayElement("Panel", "_panel_" + id);
panel.MetricsMode = GuiMetricsMode.GMM_PIXELS;
panel.SetPosition(x, y);
panel.SetDimensions(width, height);
TextAreaOverlayElement textArea = (TextAreaOverlayElement)overlayMgr.CreateOverlayElement("TextArea", "_area_" + id);
textArea.MetricsMode = GuiMetricsMode.GMM_PIXELS;
textArea.SetPosition(0, 0);
textArea.SetDimensions(width, height);
textArea.Caption = text;
textArea.CharHeight = 16;
textArea.FontName = "Verdana";
textArea.ColourTop = colorTop;
textArea.ColourBottom = colorBot;
Overlay overlay = overlayMgr.Create("_overlay_" + id);
overlay.Add2D(panel);
panel.AddChild(textArea);
overlay.Show();
}
catch (Exception e) {
Util.Log("Unable to create text area.");
}
}
public SimpleStaticTextButton(string name, string caption, ColourValue normalStateColor, ColourValue activeStateColor, bool specificColor = false)
{
OverlayManager overlayMgr = OverlayManager.Singleton;
element = overlayMgr.CreateOverlayElement("BorderPanel", name);
element.MetricsMode = GuiMetricsMode.GMM_RELATIVE;
element.HorizontalAlignment = GuiHorizontalAlignment.GHA_LEFT;
element.Height = 0.32f;
mTextArea = overlayMgr.CreateOverlayElement("TextArea", name + "/StaticTextCaption") as TextAreaOverlayElement;
mTextArea.MetricsMode = GuiMetricsMode.GMM_RELATIVE;
mTextArea.HorizontalAlignment = GuiHorizontalAlignment.GHA_LEFT;
mTextArea.SetAlignment(TextAreaOverlayElement.Alignment.Left);
mTextArea.Top = 0.01f;
mTextArea.FontName = "EngineFont";
mTextArea.CharHeight = 0.025f;
mTextArea.SpaceWidth = 0.02f;
if (!specificColor)
{
normalStateColor = new ColourValue(0.9f, 1f, 0.7f);
}
mTextArea.Colour = normalStateColor;
((OverlayContainer)element).AddChild(mTextArea);
Text = caption;
AssignListener(UILayer.Instance.Listener);
this.normalStateColor = normalStateColor;
this.activeStateColor = activeStateColor;
mState = ButtonState.BS_UP;
}
private static void StartMainOverlay()
{
if (!BaseSettings.Instance.UseOverlay)
return;
OverlayManager.StartMainOverlay();
}
public Panel(string name, float width = 0, float height = 0, float left = 0, float top = 0)
{
widgets = new List <Widget>();
OverlayManager overlayMgr = OverlayManager.Singleton;
mElement = OverlayManager.Singleton.CreateOverlayElementFromTemplate("EditorPanel", "BorderPanel", name);
mElement.MetricsMode = GuiMetricsMode.GMM_RELATIVE;
if (width == 0 || height == 0)
{
mElement.Width = 1.0f;
mElement.Height = 1.0f;
}
else if (width > 0 && height > 0)
{
mElement.Width = width;
mElement.Height = height;
}
mElement.Top = top;
mElement.Left = left;
cols = new List <PanelColumn>();
rows = new List <PanelRow>();
cols.Add(new PanelColumn(this)
{
Type = ValueType.Percent, Width = 100
});
rows.Add(new PanelRow(this)
{
Type = ValueType.Percent, Height = 100
});
}
private void Awake()
{
if (GameObject.Find("GameOverlay").GetComponent <OverlayManager>() != null)
{
overlay = GameObject.Find("GameOverlay").GetComponent <OverlayManager>();
}
}
//handles the playingstate
//plays the current level
public override void HandleInput(InputHelper inputHelper)
{
if (level == null)
{
return;
}
if (inputHelper.KeyPressed(Keys.Escape))
{
OverlayManager overlay = level.GetObject("overlay") as OverlayManager;
if (overlay.CurrentOverlayID == "die" || overlay.CurrentOverlayID == "finish")
{
return;
}
if (overlay.CurrentOverlayID == "menu")
{
overlay.SwitchTo("hud");
}
else
{
overlay.SwitchTo("menu");
}
}
if (!paused)
{
level.HandleInput(inputHelper);
}
}
public Overlay()
{
#if DEBUG
if (SteamAppsLocation.Get() == "./../../debug")
{
dotaProcessHandle = Process.GetProcessesByName("notepad")[0].MainWindowHandle;
overlayManager = new OverlayManager(dotaProcessHandle, out window, out renderer);
renderer.SetupHintSlots();
return;
}
#endif
while (Process.GetProcessesByName("dota2").Length == 0)
{
Console.WriteLine("Waiting for dota to start...");
Thread.Sleep(500);
}
while (Process.GetProcessesByName("dota2")[0].MainWindowHandle == IntPtr.Zero)
{
Console.WriteLine("Waiting for dota window handle to appear...");
Thread.Sleep(500);
}
dotaProcessHandle = Process.GetProcessesByName("dota2")[0].MainWindowHandle;
overlayManager = new OverlayManager(dotaProcessHandle, out window, out renderer);
renderer.SetupHintSlots();
Console.WriteLine("Overlay running!");
}
private void OnGUI()
{
//GUI.skin = _mySkin;
CelestialBody current = null;
if (MapView.MapIsEnabled)
{
current = OverlayManager.GetMapBody();
}
else
{
current = FlightGlobals.currentMainBody;
}
if (HeadMaster.useEditor && current != null)
{
if (AdvancedGUI)
{
_mainWindowRect.width = 520;
}
else
{
_mainWindowRect.width = 260;
}
if (CloudLayer.GetBodyLayerCount(ConfigNodeList[SelectedConfig].url, current.name) != 0)
{
_mainWindowRect.height = 745;
_mainWindowRect = GUI.Window(0x8100, _mainWindowRect, DrawMainWindow, "Clouds");
}
else
{
_mainWindowRect.height = 115;
_mainWindowRect = GUI.Window(0x8100, _mainWindowRect, DrawMainWindow, "Clouds");
}
}
}
public void OverlayAnimationsInit()
{
OverlayManager = OverlayManager.instance;
// Grab original locations for objects that will change position.
// Bottom and top panels
topPanelOriginalDimensions = OverlayManager.OverlayTopPanel.GetComponent <RectTransform>().anchoredPosition;
bottomPanelOriginalDimensions = OverlayManager.OverlayBottomPanel.GetComponent <RectTransform>().anchoredPosition;
// BG blocks
for (int i = 0; i < 5; i++)
{
bgBlockOriginalDimensions[i] = OverlayManager.OverlayBGAnimBlocks[i].GetComponent <RectTransform>().sizeDelta;
}
// Set a temporary starting highlight.
OverlayHighlightColor = new Color32(0xFD, 0xC7, 0x0A, 0xff);
// Set up the original positions and calculated positions for each of the primary panels, to prepare them for the transition animations.
//OverlayNavigateBaseLeftPosition, OverlayNavigateBaseOriginalPosition, OverlayNavigateBaseRightPosition
for (int i = 0; i < 4; i++)
{
OverlayNavigateBaseOriginalPosition[i] = OverlayManager.OverlayPanels[i].GetComponent <RectTransform>().anchoredPosition;
OverlayNavigateBaseLeftPosition[i] = new Vector3(OverlayNavigateBaseOriginalPosition[i].x - 90f, OverlayNavigateBaseOriginalPosition[i].y, OverlayNavigateBaseOriginalPosition[i].z);
OverlayNavigateBaseRightPosition[i] = new Vector3(OverlayNavigateBaseOriginalPosition[i].x + 90f, OverlayNavigateBaseOriginalPosition[i].y, OverlayNavigateBaseOriginalPosition[i].z);
}
}
// Reloads the managers and displays the loading screen after scene reloads.
// Ensures correct timing between scene load and finding of objects.
IEnumerator TimeActionsWithSceneLoaded()
{
// Time the actions.
yield return(new WaitForEndOfFrame());
// Update the managers to the ones loaded in the new scene.
sharedVariableManager = GameObject.Find("SharedVariableManager").GetComponent <SharedVariableManager>();
overlayManager = GameObject.Find("OverlayCanvas").GetComponent <OverlayManager>();
robotViewText = GameObject.Find("RobotViewText").GetComponent <Text>();
// Set the approprite robot view text.
switch (trials[currentTrialNum].trialType)
{
case TrialType.AI:
robotViewText.text = AIText;
break;
case TrialType.HUMAN:
robotViewText.text = humanText;
break;
}
// Display the loading screen depending on the type of trial.
overlayManager.DisplayLoadingScreen(trials[currentTrialNum].trialType);
// Load the appropriate models for the player and robot avatars.
assetLoader.LoadPlayerAvatar(experimentDataManager.appearance.gender, experimentDataManager.appearance.skinColor);
assetLoader.LoadRobotAvatar(trials[currentTrialNum].robotType, trials[currentTrialNum].robotColor);
// Load the appropriate environment.
assetLoader.LoadEnvironment(trials[currentTrialNum].environmentType);
}
public StaticText(string name, string caption, float width, bool specificColor, ColourValue color)
{
OverlayManager overlayMgr = OverlayManager.Singleton;
mElement = overlayMgr.CreateOverlayElement("BorderPanel", name);
mElement.MetricsMode = GuiMetricsMode.GMM_PIXELS;
mElement.HorizontalAlignment = GuiHorizontalAlignment.GHA_CENTER;
mElement.Height = 32;
mTextArea = overlayMgr.CreateOverlayElement("TextArea", name + "/StaticTextCaption") as TextAreaOverlayElement;
mTextArea.MetricsMode = GuiMetricsMode.GMM_PIXELS;
mTextArea.HorizontalAlignment = GuiHorizontalAlignment.GHA_CENTER;
mTextArea.SetAlignment(TextAreaOverlayElement.Alignment.Center);
mTextArea.Top = 10;
mTextArea.FontName = "EngineFont";
mTextArea.CharHeight = 18;
mTextArea.SpaceWidth = 9;
if (!specificColor)
{
mTextArea.Colour = new ColourValue(0.9f, 1f, 0.7f);
}
else
{
mTextArea.Colour = color;
}
((OverlayContainer)mElement).AddChild(mTextArea);
SetText(caption);
}
public SimpleStaticTextWidget(string name, string caption, float width, bool specificColor, ColourValue color, float fontSize = 100)
{
OverlayManager overlayMgr = OverlayManager.Singleton;
element = overlayMgr.CreateOverlayElement("BorderPanel", name);
element.MetricsMode = GuiMetricsMode.GMM_RELATIVE;
//element.HorizontalAlignment = GuiHorizontalAlignment.GHA_LEFT;
element.Height = 0.32f;
element.Left = -0.01f;
if (width == 0)
{
element.Width = 1;
}
mTextArea = overlayMgr.CreateOverlayElement("TextArea", name + "/StaticTextCaption") as TextAreaOverlayElement;
mTextArea.MetricsMode = GuiMetricsMode.GMM_RELATIVE;
mTextArea.HorizontalAlignment = GuiHorizontalAlignment.GHA_CENTER;
mTextArea.SetAlignment(TextAreaOverlayElement.Alignment.Center);
mTextArea.Top = 0f;
mTextArea.FontName = "EngineFont";
mTextArea.CharHeight = 0.025f * (fontSize / (float)100);
mTextArea.SpaceWidth = 0.02f;
if (!specificColor)
{
mTextArea.Colour = new ColourValue(0.9f, 1f, 0.7f);
}
else
{
mTextArea.Colour = color;
}
((OverlayContainer)element).AddChild(mTextArea);
Text = caption;
}
/// <summary>
///
/// </summary>
/// <param name="cursorPos"></param>
public override void OnCursorMoved(Vector2 cursorPos)
{
OverlayManager om = OverlayManager.Instance;
if (this.isExpanded)
{
if (this.isDragging)
{
Vector2 co = Widget.CursorOffset(this.scrollHandle, cursorPos);
Real newTop = this.scrollHandle.Top + co.y - this.dragOffset;
Real lowerBoundary = this.scrollTrack.Height - this.scrollHandle.Height;
this.scrollHandle.Top = Math.Utility.Clamp <Real>(newTop, lowerBoundary, 0);
var scrollPercentage = Math.Utility.Clamp <Real>(newTop / lowerBoundary, 0, 1);
var newIndex = (int)(scrollPercentage * (this.items.Count - this.itemElements.Count) + 0.5);
if (newIndex != this.displayIndex)
{
DisplayIndex = newIndex;
}
return;
}
Real l = this.itemElements[0].DerivedLeft * om.ViewportWidth + 5;
Real t = this.itemElements[0].DerivedTop * om.ViewportHeight + 5;
Real r = l + this.itemElements[this.itemElements.Count - 1].Width - 10;
Real b = this.itemElements[this.itemElements.Count - 1].DerivedTop * om.ViewportHeight +
this.itemElements[this.itemElements.Count - 1].Height - 5;
if (cursorPos.x >= l && cursorPos.x <= r && cursorPos.y >= t && cursorPos.y <= b)
{
var newIndex = (int)(this.displayIndex + (cursorPos.y - t) / (b - t) * this.itemElements.Count);
if (this.highlightIndex != newIndex)
{
this.highlightIndex = newIndex;
DisplayIndex = this.displayIndex;
}
}
}
else
{
if (IsCursorOver(this.smallBox, cursorPos, 4))
{
this.smallBox.MaterialName = "SdkTrays/MiniTextBox/Over";
this.smallBox.BorderMaterialName = "SdkTrays/MiniTextBox/Over";
this.IsCursorOver = true;
}
else
{
if (this.IsCursorOver)
{
this.smallBox.MaterialName = "SdkTrays/MiniTextBox";
this.smallBox.BorderMaterialName = "SdkTrays/MiniTextBox";
this.IsCursorOver = false;
}
}
}
base.OnCursorMoved(cursorPos);
}
public static void Run(IntPtr parentWindowHandle)
{
Console.SetWindowSize(Console.LargestWindowWidth / 2, Console.LargestWindowHeight / 2);
var rendererOptions = new Direct2DRendererOptions()
{
AntiAliasing = true,
Hwnd = MainClass.mProc_H,
MeasureFps = true,
VSync = false
};
var manager = new OverlayManager(parentWindowHandle, rendererOptions);
var overlay = manager.Window;
var gfx = manager.Graphics;
var whiteSmoke = gfx.CreateBrush(0xF5, 0xF5, 0xF5, 100);
var blackBrush = gfx.CreateBrush(0, 0, 0, 255);
var redBrush = gfx.CreateBrush(255, 0, 0, 255);
var greenBrush = gfx.CreateBrush(0, 255, 0, 255);
var blueBrush = gfx.CreateBrush(0, 0, 255, 255);
var font = gfx.CreateFont("Consolas", 22);
RECT.Left = overlay.Width - overlay.Width;
RECT.Top = overlay.Height - overlay.Height;
RECT.Right = overlay.Width;
RECT.Bottom = overlay.Height;
RECT.WCenter = overlay.Width - overlay.Width / 2;
RECT.HCenter = overlay.Height - overlay.Height / 2;
while (true)
{
Thread.Sleep(50);
gfx.BeginScene();
gfx.ClearScene(gfx.CreateBrush(0, 0, 0, 0));
if (Settings.Overlay.MenuON && !SDK.m_bIsScoped)
{
gfx.FillRectangle(RECT.Left + 100, RECT.HCenter, 50, 50, blueBrush);
}
if (Settings.Overlay.Crosshair)
{
gfx.FillEllipse(RECT.WCenter, RECT.HCenter, 3, 3, redBrush);
}
if (SDK.HitVal != SDK.HitAmmount || HitMark > 1)
{
HitMarker();
}
gfx.EndScene();
}
Environment.Exit(0);
}
public void TouchEvent()
{
if (_overlayManager == null)
{
_overlayManager = GameObject.Find("RoomModalOverlay").GetComponent <OverlayManager>();
}
_overlayManager.ShowOverlay(_name);
}
protected AutomationBase(IPropertyLibray propertyLibrary, IEventLibrary eventLibrary, IPatternLibrary patternLibrary)
{
PropertyLibrary = propertyLibrary;
EventLibrary = eventLibrary;
PatternLibrary = patternLibrary;
ConditionFactory = new ConditionFactory(propertyLibrary);
OverlayManager = new OverlayManager();
}
internal static void Init()
{
fsWatchers = new FSWatchers();
ovManager = new OverlayManager(fsWatchers);
vcManager = new VCManager(ovManager);
SetProject(PluginBase.CurrentProject as Project);
}
public InventoryUiOverlay(OverlayManager manager) : base("InventoryUiOverlay.html", manager)
{
Attach("close", (_, callback) => Close());
Attach("ready", (_, callback) =>
{
Send("hotkey", "e");
});
}
internal static void Init()
{
fsWatchers = new FSWatchers();
ovManager = new OverlayManager(fsWatchers);
vcManager = new VCManager(ovManager);
SetProject(PluginBase.CurrentProject as Project);
}
public PositionedJob(Vector3 position, float scale, Color color, Overlay jobOverlay, string jobType)
{
Position = position;
_jobType = jobType;
Marker = ObjectPool.Instance.GetObjectForType <JobMarker>(parent: OverlayManager.GetOverlay(jobOverlay));
Marker.Init(position, scale, color);
RemainingTime = 1f;
}
public void AddOverlay_WhenOverlayIsNotNullAndIsNotPresent_DoesNothing()
{
var overlayManager = new OverlayManager();
var overlay = new StubOverlay();
overlayManager.RemoveOverlay(overlay);
Assert.Count(0, overlayManager.Overlays);
}
public VCManager(OverlayManager ovManager)
{
this.ovManager = ovManager;
if (PluginMain.SCSettings.EnableSVN) AddVCManager(new SubversionManager());
if (PluginMain.SCSettings.EnableGIT) AddVCManager(new GitManager());
refreshTimer = new Timer();
refreshTimer.Interval = 100;
refreshTimer.Tick += new EventHandler(refreshTimer_Tick);
refreshTimer.Stop();
}
public static void Init()
{
Camera cam=Camera.main;
if(cam!=null) camT=Camera.main.transform;
GameObject obj=new GameObject();
obj.name="OverlayManger";
overlayManager=obj.AddComponent<OverlayManager>();
int poolSize=3;
overlays=new GUITexture[poolSize];
overlaysB=new GUITexture[poolSize];
inUseFlags=new bool[poolSize];
if(overlayManager!=null){
for(int i=0; i<poolSize; i++){
obj=new GameObject();
obj.name="overlay";
obj.transform.parent=overlayManager.transform;
obj.transform.localScale=new Vector3(0, 0, 1);
overlays[i]=obj.AddComponent<GUITexture>();
overlays[i].texture=(Texture)Resources.Load("GreenBar");
overlays[i].pixelInset=new Rect(0, 0, 0, 0);
obj=new GameObject();
obj.name="overlayB";
obj.transform.parent=overlayManager.transform;
obj.transform.localScale=new Vector3(0, 0, 1);
overlaysB[i]=obj.AddComponent<GUITexture>();
overlaysB[i].texture=(Texture)Resources.Load("GreyBar");
overlaysB[i].pixelInset=new Rect(0, 0, 0, 0);
inUseFlags[i]=false;
}
}
}
public OverlayGUI()
{
//setup the colours
top = new ColourValue(0.9f, 0.9f, 0.9f);
bot = new ColourValue(0.8f, 0.8f, 0.8f);
seltop = new ColourValue(0.9f, 0.7f, 0.7f);
selbot = new ColourValue(0.8f, 0.6f, 0.6f);
//Overlay
overlayManager = OverlayManager.Singleton;
// Create a panel
panel = (OverlayContainer)overlayManager.CreateOverlayElement("Panel", "PanelName");
panel.MetricsMode = GuiMetricsMode.GMM_PIXELS;
panel.SetPosition(0, 0);
panel.SetDimensions(Program.Instance.rWindow.Width, Program.Instance.rWindow.Height);
panel.MaterialName = "fsO/Blank"; // Optional background material
// Create a text area
messageArea = (TextAreaOverlayElement)overlayManager.CreateOverlayElement("TextArea", "TextArea");
messageArea.MetricsMode = GuiMetricsMode.GMM_PIXELS;
messageArea.SetPosition(0, 0);
messageArea.SetDimensions(Program.Instance.rWindow.Width, 100);
messageArea.CharHeight = 24;
messageArea.FontName = "damn";
messageArea.ColourTop = top;
messageArea.ColourBottom = bot;
messageArea.Caption = "";
// Status text area
statArea = (TextAreaOverlayElement)overlayManager.CreateOverlayElement("TextArea", "StatTextArea");
statArea.MetricsMode = GuiMetricsMode.GMM_PIXELS;
statArea.SetPosition(0, Program.Instance.rWindow.Height - 50);
statArea.SetDimensions(Program.Instance.rWindow.Width, 50);
statArea.CharHeight = 24;
statArea.FontName = "damn";
statArea.ColourTop = top;
statArea.ColourBottom = bot;
statArea.Caption = "this is a test" + Environment.NewLine + "This is the test's second line";
//Menus Text Areas
titleArea = (TextAreaOverlayElement)overlayManager.CreateOverlayElement("TextArea", "TitleTextArea");
titleArea.MetricsMode = GuiMetricsMode.GMM_PIXELS;
titleArea.SetPosition(64, 16);
titleArea.SetDimensions(Program.Instance.rWindow.Width, 32);
titleArea.CharHeight = 32;
titleArea.FontName = "damn";
titleArea.ColourTop = top;
titleArea.ColourBottom = bot;
titleArea.Caption = "Title";
for (int i = 0; i < 10; i++)
{
optionAreas[i] = (TextAreaOverlayElement)overlayManager.CreateOverlayElement("TextArea", i+"TextArea");
optionAreas[i].MetricsMode = GuiMetricsMode.GMM_PIXELS;
optionAreas[i].SetPosition(32, 64 + (i*26));
optionAreas[i].SetDimensions(Program.Instance.rWindow.Width, 24);
optionAreas[i].CharHeight = 24;
optionAreas[i].FontName = "damn";
optionAreas[i].ColourTop = top;
optionAreas[i].ColourBottom = bot;
optionAreas[i].Caption = "Option " + i.ToString();
}
maxOptions = 10;
// Create an overlay, and add the panel
overlay = overlayManager.Create("OverlayName");
overlay.Add2D(panel);
// Add the text area to the panel
panel.AddChild(messageArea);
panel.AddChild(titleArea);
panel.AddChild(statArea);
for (int i = 0; i < 10; i++)
{
panel.AddChild(optionAreas[i]);
}
// Show the overlay
overlay.Show();
}
internal void CameraConnected(IVideo driverInstance, VideoWrapper videoObject, OverlayManager overlayManager, int maxOcrErrorsPerRun, bool isIntegrating)
{
this.driverInstance = driverInstance;
this.overlayManager = overlayManager;
this.VideoObject = videoObject;
isIntegratingCamera = isIntegrating;
ocrErrors = 0;
isUsingManualIntegration = false;
providesOcredTimestamps = false;
MAX_ORC_ERRORS_PER_RUN = maxOcrErrorsPerRun;
driverInstanceSupportedActions = driverInstance.SupportedActions.Cast<string>().ToList();
ocrMayBeRunning = driverInstanceSupportedActions.Contains("DisableOcr");
if (isIntegrating)
ChangeState(UndeterminedVtiOsdLocationState.Instance);
else if (driverInstance is Drivers.ASCOMVideo.Video)
ChangeState(ExternallyManagedCameraState.Instance);
else
ChangeState(NoIntegrationSupportedCameraState.Instance);
}
public void Start()
{
_overlayManager = GetComponentInParent<OverlayManager>();
}
public void Start()
{
_loadLevels = FindObjectOfType<LoadLevel>();
_overlayManager = GetComponentInParent<OverlayManager>();
}
private void ConnectToDriver(IVideo driverInstance)
{
try
{
Cursor = Cursors.WaitCursor;
initializationErrorMessages.Clear();
m_PrevStateWasDisconnected = true;
videoObject = m_VideoRenderingController.ConnectToDriver(driverInstance);
if (videoObject.Connected)
{
imageWidth = videoObject.Width;
imageHeight = videoObject.Height;
picVideoFrame.Image = new Bitmap(imageWidth, imageHeight);
ResizeVideoFrameTo(imageWidth, imageHeight);
tssIntegrationRate.Visible = Settings.Default.IsIntegrating && OccuRecContext.Current.IsAAV;
pnlAAV.Visible = OccuRecContext.Current.IsAAV;
tsbtnDisplayMode.Visible = true;
if (videoObject.SupporstFreeStyleGain) videoObject.SetFreeRangeGainIntervals(0);
m_OverlayManager = new OverlayManager(videoObject.Width, videoObject.Height, initializationErrorMessages, m_AnalysisManager, m_StateManager);
m_VideoFrameInteractionController.OnNewVideoSource(videoObject);
OccuRecContext.Current.IsConnected = true;
if (Settings.Default.RecordStatusSectionOnly)
MessageBox.Show(
this,
"The 'Record Status Section Only' flag is currently enabled. No video images will be recorded.",
"OccuRec",
MessageBoxButtons.OK,
MessageBoxIcon.Warning);
}
m_StateManager.CameraConnected(driverInstance, videoObject, m_OverlayManager, Settings.Default.OcrMaxErrorsPerCameraTestRun, OccuRecContext.Current.IsAAV);
UpdateScheduleDisplay();
}
finally
{
Cursor = Cursors.Default;
if (videoObject == null || !videoObject.Connected)
{
foreach (string error in initializationErrorMessages)
{
MessageBox.Show(this, error, "OccuRec", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
picVideoFrame.Width = videoObject.Width;
picVideoFrame.Height = videoObject.Height;
UpdateCameraState(true);
ucVideoControl.Initialize(videoObject);
}
public void Dispose()
{
ovManager = null;
refreshTimer.Stop();
}
public void CameraDisconnected()
{
currentState = null;
driverInstance = null;
overlayManager = null;
}
public void Start()
{
_callback = () => { };
_overlayManager = FindObjectOfType<OverlayManager>();
}
private void DisconnectFromCamera()
{
if (videoObject != null)
{
if (videoObject.State == VideoCameraState.videoCameraRecording)
videoObject.StopRecording();
videoObject.Disconnect();
videoObject = null;
}
UpdateCameraState(false);
tssIntegrationRate.Visible = false;
tsbtnDisplayMode.Visible = false;
m_StateManager.CameraDisconnected();
if (m_OverlayManager != null)
{
m_OverlayManager.Finalise();
m_OverlayManager = null;
}
if (m_ObservatoryController.IsConnectedToVideoCamera())
m_ObservatoryController.DisconnectVideoCamera();
m_PrevStateWasDisconnected = true;
OccuRecContext.Current.IsConnected = false;
}
