public void Initialize()
{
isTransitioning = true;
fullscreen = false;
previousScreenType = ScreenTypes.Intro;
activeScreenType = ScreenTypes.Intro;
resolutions = new List <DisplayMode>();
foreach (DisplayMode mode in GraphicsAdapter.DefaultAdapter.SupportedDisplayModes)
{
if (mode.Width >= 800)
{
resolutions.Add(mode);
}
}
resolutions.Sort(delegate(DisplayMode a, DisplayMode b)
{
int xdiff = a.Width.CompareTo(b.Width);
if (xdiff != 0)
{
return(xdiff);
}
else
{
return(a.Height.CompareTo(b.Height));
}
});
dimensions = new Vector2(resolutions[0].Width, resolutions[0].Height);
}
public GameListScreen(Engine engine, ScreenTypes screen)
{
this.type = screen;
this.engine = engine;
_refresh = new CallDelayer(100, 500, (obj) => Refresh());
}
public GameListScreen(Engine engine, ScreenTypes screen)
{
this.type = screen;
this.engine = engine;
_refresh = new CallDelayer(100, 500, (obj) => Refresh());
}
/// <summary>
/// <see cref="IMultiWindowService"/>
/// </summary>
/// <param name="screen"><see cref="IMultiWindowService"/></param>
/// <returns><see cref="IMultiWindowService"/></returns>
public string GetPageTitleByScreen(ScreenTypes screen)
{
ResourceLoader loader = new ResourceLoader();
switch (screen)
{
case ScreenTypes.LANDING:
return(loader.GetString("LandingScreenTitle"));
case ScreenTypes.WORKFORCE:
return(loader.GetString("WorkforceScreenTitle"));
case ScreenTypes.STRATEGY:
return(loader.GetString("StrategyScreenTitle"));
case ScreenTypes.TASKS:
return(loader.GetString("TasksScreenTitle"));
case ScreenTypes.CUSTOMERS:
return(loader.GetString("CustomersScreenTitle"));
default:
return(string.Empty);
}
}
public static void CreateUIScreen(ScreenTypes aScreenType)
{
GameObject curSelected = EF_Editor_Utils.GetSelectedObject();
GameObject curScreenGO = null;
switch (aScreenType)
{
case ScreenTypes.Base:
curScreenGO = new GameObject("New Screen", typeof(EF_Base_Screen), typeof(RectTransform));
break;
case ScreenTypes.Timed:
curScreenGO = new GameObject("New Screen", typeof(EF_Timed_Screen), typeof(RectTransform));
break;
default:
break;
}
if (curSelected)
{
curScreenGO.transform.SetParent(curSelected.transform);
}
Selection.activeGameObject = curScreenGO;
}
public void changeScreen(ScreenTypes screenId)
{
//teardown previous screen
foreach (IBankScreen c in _view._content.Children)
{
c.CloseScreen();
}
_view._content.Children.Clear();
//create screen based on type
switch (screenId)
{
case ScreenTypes.UserSelection:
_view._content.Children.Add(new UserSelection());
break;
case ScreenTypes.ShowTransactions:
_view._content.Children.Add(new ShowTransactionsScreen(BankApplicationState.AllTransactions));
break;
}
//enable new screen
foreach (IBankScreen c in _view._content.Children)
{
c.ShowScreen();
}
}
protected void CallFormRequestEvent(ScreenTypes form, params string[] Param)
{
// Event will be null if there are no subscribers
if (FormRequestEvent != null)
{
FormRequestEvent(form, Param);
}
}
public GameListScreenAdapter(GameListScreen owner, GameController ctrl, ScreenTypes screen) : base()
{
this.ctrl = ctrl;
this.owner = owner;
this.screen = screen;
_directionSize = (int)(ctrl.Resources.DisplayMetrics.Density * 32.0);
}
public void SwitchScreenTo(ScreenTypes screen)
{
Screens[currentScreenIndex].SetActive(false);
currentScreenIndex = (int)screen;
Screens[currentScreenIndex].SetActive(true);
UnityEngine.UI.LayoutRebuilder.ForceRebuildLayoutImmediate(GetComponent <RectTransform>());
}
public static void Initialise()
{
CurrentScreen = MainMenuScreen.Instance;
ScreenType = ScreenTypes.MainMenuScreen;
Camera.Load();
CurrentScreen.Open();
}
public GameScreen(Game game, ContentManager content, SpriteBatch spriteBatch, ScreenTypes screenType)
{
this.game = game;
this.content = content;
this.spriteBatch = spriteBatch;
this.screenType = screenType;
screenWidth = game.Window.ClientBounds.Width;
screenHeight = game.Window.ClientBounds.Height;
Hide();
}
/*
* Enable the screen with the associated ScreenType
* Created by: Michael Watt
* Last Updated: 2018.10.22
*/
private void EnableScreen(ScreenTypes screenToEnable)
{
DisableScreen();
//Debug.Log(screenToEnable);
//change the indices first
m_ActiveScreens.Push(m_MenuScreens[screenToEnable]);
m_ActiveScreens.Peek().gameObject.SetActive(true);
//EnableMenuButtons();
}
/// <summary>
/// Set next screen as current.
/// </summary>
public void SwitchScreen(ScreenTypes type, params object[] param)
{
CurrentScreen.UnloadContent();
CurrentScreen = Screens[type];
if (!CurrentScreen.IsInitialized)
{
CurrentScreen.Initialize(GraphDev, Core, param);
}
CurrentScreen.LoadContent(Content);
}
// HELPER FUNCTIONS
BaseScreenController FindScreen(ScreenTypes type)
{
foreach (var baseScreenController in baseScreenControllers)
{
if (baseScreenController.GetScreenType() == type)
{
return(baseScreenController);
}
}
Debug.Log("No base screen type found");
return(baseScreenControllers[0]);
}
private void ChangeScreen(ScreenTypes screenIndex)
{
//may be useful for a menu with multiple screens
DisableAllScreens();
//enable the main menu screen
if (m_MenuScreens[screenIndex].m_MainMenuEnabled)
{
EnableScreen(ScreenTypes.MainMenu);
//DisableMenuButtons();
}
//enable the new screen, making it active.
EnableScreen(screenIndex);
}
void ProcessButtonInput(ScreenTypes screenType)
{
_currScreenController.OnScreenExit();
_currScreenController.OnScreenDisable();
_currScreenController.exitMinigame -= ForceExitMinigame;
_prevScreenController = _currScreenController;
_currScreenController = FindScreen(screenType);
uiManager.ChangeBgColor(_currScreenController.bgColor);
_currScreenController.exitMinigame += ForceExitMinigame;
_currScreenController.OnScreenEnable();
_currScreenController.OnScreenEnter();
}
private IScreen CreateScreen(ScreenTypes screenType)
{
switch (screenType)
{
case ScreenTypes.MAIN_MENU:
return(new MainMenu(this)); // Returns new main menu.
case ScreenTypes.GAME_SCREEN:
return(new GameScreen(this)); // Returns new game screen.
default:
/* If the screentype doesnt exist, then return null, this shouldn't happen anyway with the use of a enum,
* due to predetermined values. */
return(null);
}
}
/// <summary>
/// Constructs a new screen manager component.
/// </summary>
public ScreenManager(Game game, float vCursorScale)
: base(game)
{
// we must set EnabledGestures before we can query for them, but
// we don't assume the game wants to read them.
TouchPanel.EnabledGestures = GestureType.None;
_contentManager = game.Content;
_contentManager.RootDirectory = "Content";
_input = new InputState(this);
_screens = new List <GameScreen>();
_screensToUpdate = new List <GameScreen>();
_transitions = new List <RenderTarget2D>();
this.ScreenTypeCurrent = ScreenTypes.None;
_graphics = new GraphicsDeviceManager(game);
cursorScale = vCursorScale;
}
/// <summary>
/// Constructs a new screen manager component.
/// </summary>
public ScreenManager(Game game, float vCursorScale)
: base(game)
{
// we must set EnabledGestures before we can query for them, but
// we don't assume the game wants to read them.
TouchPanel.EnabledGestures = GestureType.None;
_contentManager = game.Content;
_contentManager.RootDirectory = "Content";
_input = new InputState(this);
_screens = new List<GameScreen>();
_screensToUpdate = new List<GameScreen>();
_transitions = new List<RenderTarget2D>();
this.ScreenTypeCurrent = ScreenTypes.None;
_graphics = new GraphicsDeviceManager(game);
cursorScale = vCursorScale;
}
private Page GetPageInstance(ScreenTypes screen)
{
switch (screen)
{
case ScreenTypes.WORKFORCE:
return(new Workforce());
case ScreenTypes.STRATEGY:
return(new Strategy());
case ScreenTypes.TASKS:
return(new Tasks());
case ScreenTypes.CUSTOMERS:
return(new Customers());
default:
return(null);
}
}
/*
* Open the menu starting at the main menu
* Created by Adam Brown
* Last Updated 2018.10.22 by Michael Watt
*/
public void OpenMenu(ScreenTypes screen = ScreenTypes.MainMenu)
{
if (m_IsMenuOpen)
{
EnableScreen(screen);
return;
}
DisableAllScreens();
if (screen != ScreenTypes.MainMenu)
{
EnableScreen(ScreenTypes.MainMenu);
}
EnableScreen(screen);
m_CloseButton.SetActive(true);
m_IsMenuOpen = true;
}
// Pass in a screen type value, and either create the screen if it doesn't exist, or set it as active screen.
public void StartScreen(ScreenTypes screenType)
{
if (screens.ContainsKey(screenType)) // Checks if the screen has been made.
{
activeScreen = screens[screenType]; // If so it sets it as active screen.
activeScreen.Set();
return;
}
else
{
screens.Add(screenType, CreateScreen(screenType)); // If not, it makes the screen.
activeScreen = screens[screenType]; // Sets the active screen to the one just made.
if (activeScreen != null) // If we could make the screen, return.
{
return;
}
else
{
Console.WriteLine("SCREEN_MANAGER: Screen type not found."); // If not, print an error.
}
}
}
/// <summary>
/// <see cref="IMultiWindowService"/>
/// </summary>
/// <param name="screen"><see cref="IMultiWindowService"/></param>
/// <returns><see cref="IMultiWindowService"/></returns>
public async Task <bool> OpenNewWindowForScreen(ScreenTypes screen)
{
Page instance = GetPageInstance(screen);
if (instance != null)
{
CoreWindow window = null;
await CoreApplication.CreateNewView().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
window = CoreWindow.GetForCurrentThread();
var frame = new Frame();
frame.Navigate(instance.GetType());
Window.Current.Content = frame;
Window.Current.Activate();
ApplicationView.GetForCurrentView().Title = GetPageTitleByScreen(screen);
});
var viewId = ApplicationView.GetApplicationViewIdForWindow(window);
return(await ApplicationViewSwitcher.TryShowAsStandaloneAsync(viewId));
}
return(false);
}
public static void EnterScreen(ScreenTypes screenType)
{
ScreenType = screenType;
switch (screenType)
{
case ScreenTypes.MainMenuScreen:
NextScreen = MainMenuScreen.Instance;
break;
case ScreenTypes.GameScreen:
NextScreen = GameScreen.Instance;
break;
case ScreenTypes.EditorLevelSelectScreen:
NextScreen = EditorLevelSelectScreen.Instance;
break;
case ScreenTypes.EditorScreen:
NextScreen = EditorScreen.Instance;
break;
}
CurrentScreen.Close(ExitAction.ExitScreen);
}
//스크린 모드를 설정하고 화면을 초기화한다.
private void SetScreenMode(ScreenTypes screenType)
{
//상태 저장
this.screenType = screenType;
System.Diagnostics.Debug.WriteLine(screenType.ToString());
switch (screenType)
{
case ScreenTypes.PowerPoint:
SetPPTSlideShowButtonVisibility(false);
SetPPTButtonVisibilitiy(true);
break;
case ScreenTypes.PowerPointSlideShow2007:
HideAllChildren();
SetPPTButtonVisibilitiy(false);
SetPPTSlideShowButtonVisibility(true);
break;
case ScreenTypes.PowerPointSlideShow2010:
HideAllChildren();
SetPPTButtonVisibilitiy(false);
SetPPTSlideShowButtonVisibility(true);
//UIUtils.SetVisibility(btnPptBpen, false);
break;
case ScreenTypes.PowerPointSlideShow2013:
HideAllChildren();
SetPPTButtonVisibilitiy(false);
SetPPTSlideShowButtonVisibility(true);
break;
default:
SetPPTButtonVisibilitiy(false);
SetPPTSlideShowButtonVisibility(false);
break;
}
}
public static Bitmap MakeWarpMap(ProjectorEntry pe, double domeSize, bool radialDistortion, List <GroundTruthPoint> gtPointList, ScreenTypes screenType)
{
List <Vector2d> PointTo = new List <Vector2d>();
List <Vector2d> PointFrom = new List <Vector2d>();
double xFactor = pe.Width / 512.0;
double yFactor = pe.Height / 512.0;
Bitmap bmp = new Bitmap(512, 512);
FastBitmap fastBmp = new FastBitmap(bmp);
SolveProjector spProjector = new SolveProjector(pe, domeSize, ProjectionType.Projector, screenType, SolveParameters.Default);
spProjector.RadialDistorion = radialDistortion;
SolveProjector spView = new SolveProjector(pe, domeSize, ProjectionType.View, ScreenTypes.Spherical, SolveParameters.Default);
spView.RadialDistorion = false;
foreach (GroundTruthPoint gt in gtPointList)
{
PointFrom.Add(new Vector2d((double)gt.X / (double)pe.Width * 512, (double)gt.Y / (double)pe.Height * 512));
Vector2d pntOutTarget = spView.ProjectPoint(new Vector2d(gt.Az, gt.Alt));
Vector2d AltAzMapped = spProjector.GetCoordinatesForScreenPoint(gt.X, gt.Y);
Vector2d pntOutMapped = spView.ProjectPoint(new Vector2d(AltAzMapped.X, AltAzMapped.Y));
pntOutTarget.X = pntOutTarget.X * (512 / 2.0) + (512 / 2.0);
pntOutTarget.Y = pntOutTarget.Y * (-512 / 2.0) + (512 / 2.0);
pntOutMapped.X = pntOutMapped.X * (512 / 2.0) + (512 / 2.0);
pntOutMapped.Y = pntOutMapped.Y * (-512 / 2.0) + (512 / 2.0);
PointTo.Add(new Vector2d(pntOutTarget.X - pntOutMapped.X, pntOutTarget.Y - pntOutMapped.Y));
}
//Matrix3d projMat = spView.GetCameraMatrix();
unsafe
{
fastBmp.LockBitmap();
for (int y = 0; y < 512; y++)
{
for (int x = 0; x < 512; x++)
{
Vector2d pnt = spProjector.GetCoordinatesForScreenPoint(x * xFactor, y * yFactor);
Vector2d pntOut = spView.ProjectPoint(pnt);
// Map
pntOut.X = pntOut.X * (512 / 2.0) + (512 / 2.0);
pntOut.Y = pntOut.Y * (-512 / 2.0) + (512 / 2.0);
pntOut = MapPoint(new Vector2d(x, y), pntOut, PointTo, PointFrom);
pntOut.X = (pntOut.X - (512 / 2.0)) / (512 / 2.0);
pntOut.Y = (pntOut.Y - (512 / 2.0)) / (-512 / 2.0);
// End Map
double xo = pntOut.X * (4096 / 2.0) + (4096 / 2.0);
double yo = pntOut.Y * (-4096 / 2.0) + (4096 / 2.0);
int blue = (int)xo & 255;
int green = (int)yo & 255;
int red = (((int)yo) >> 4 & 240) + (((int)xo) >> 8 & 15);
* fastBmp[x, y] = new PixelData(red, green, blue, 255);
}
}
fastBmp.UnlockBitmap();
}
return(bmp);
}
public ActionScreen(Game game, ContentManager content, SpriteBatch spriteBatch, ScreenTypes screenType) : base(game, content, spriteBatch, screenType)
{
Initalize();
LoadContent();
currentLvlUpFrame = 0;
effectWidth = levelUpWaves.Width / levelUpColumns;
effectHeight = levelUpWaves.Height / levelUpRows;
gateWidth = endGate.Width / gateColumns;
gateHeight = endGate.Height / gateRows;
}
public GameListScreenAdapter(GameListScreen owner, GameController ctrl, ScreenTypes screen) : base()
{
this.ctrl = ctrl;
this.owner = owner;
this.screen = screen;
_directionSize = (int)(ctrl.Resources.DisplayMetrics.Density * 32.0);
}
public MenuScreen(Game game, ContentManager content, SpriteBatch spriteBatch, ScreenTypes screenType) : base(game, content, spriteBatch, screenType)
{
mainMenu = new MainMenu(game, content, spriteBatch, "backgrounds/MainMenu", MenuItemTypes.MainMenu);
instructions = new MenuItem(game, content, spriteBatch, "backgrounds/InstructionsItem", MenuItemTypes.Instructions);
controls = new MenuItem(game, content, spriteBatch, "backgrounds/ControlsItem", MenuItemTypes.Controls);
credits = new MenuItem(game, content, spriteBatch, "backgrounds/CreditsItem", MenuItemTypes.Credits);
activeMenu = mainMenu;
activeMenu.Show();
menuComponents = new List <MenuComponent>
{
mainMenu,
instructions,
controls,
credits
};
}
public SolveProjector(ProjectorEntry pe, double radius, ProjectionType type, ScreenTypes tranformType, SolveParameters solveParameters)
{
projectionType = type;
screenType = tranformType;
this.solveParameters = solveParameters;
switch (type)
{
case ProjectionType.View:
{
Fov.Value = pe.ViewProjection.FOV;
Aspect.Value = pe.ViewProjection.Aspect;
OffsetX.Value = pe.ViewProjection.XOffset;
OffsetY.Value = pe.ViewProjection.YOffset;
RadialCenterX.Value = pe.ViewProjection.RadialCenterX;
RadialCenterY.Value = pe.ViewProjection.RadialCenterY;
RadialAmountX.Value = pe.ViewProjection.RadialAmountX;
RadialAmountY.Value = pe.ViewProjection.RadialAmountY;
Pitch.Value = pe.ViewTransform.Pitch;
Heading.Value = pe.ViewTransform.Heading;
Roll.Value = pe.ViewTransform.Roll;
X.Value = -pe.ViewTransform.X;
Y.Value = pe.ViewTransform.Y;
Z.Value = pe.ViewTransform.Z;
}
break;
case ProjectionType.FishEye:
case ProjectionType.Projector:
{
Fov.Value = pe.ProjectorProjection.FOV;
Aspect.Value = pe.ProjectorProjection.Aspect;
OffsetX.Value = pe.ProjectorProjection.XOffset;
OffsetY.Value = pe.ProjectorProjection.YOffset;
RadialCenterX.Value = pe.ProjectorProjection.RadialCenterX;
RadialCenterY.Value = pe.ProjectorProjection.RadialCenterY;
RadialAmountX.Value = pe.ProjectorProjection.RadialAmountX;
RadialAmountY.Value = pe.ProjectorProjection.RadialAmountY;
Pitch.Value = pe.ProjectorTransform.Pitch;
Heading.Value = pe.ProjectorTransform.Heading;
Roll.Value = pe.ProjectorTransform.Roll;
X.Value = -pe.ProjectorTransform.X;
Y.Value = pe.ProjectorTransform.Y;
Z.Value = pe.ProjectorTransform.Z;
}
break;
case ProjectionType.Solved:
{
Fov.Value = pe.SolvedProjection.FOV;
Aspect.Value = pe.SolvedProjection.Aspect;
OffsetX.Value = pe.SolvedProjection.XOffset;
OffsetY.Value = pe.SolvedProjection.YOffset;
RadialCenterX.Value = pe.ProjectorProjection.RadialCenterX;
RadialCenterY.Value = pe.ProjectorProjection.RadialCenterY;
RadialAmountX.Value = pe.ProjectorProjection.RadialAmountX;
RadialAmountY.Value = pe.ProjectorProjection.RadialAmountY;
Pitch.Value = pe.SolvedTransform.Pitch;
Heading.Value = pe.SolvedTransform.Heading;
Roll.Value = pe.SolvedTransform.Roll;
X.Value = -pe.SolvedTransform.X;
Y.Value = pe.SolvedTransform.Y;
Z.Value = pe.SolvedTransform.Z;
}
break;
}
width = pe.Width;
height = pe.Height;
sphereRadius = radius;
}
/// <summary>
/// Shows the screen.
/// </summary>
/// <param name="screen">Screen to show.</param>
/// <param name="obj">Object to show if screen is ScreenType.Details.</param>
public void ShowScreen(ScreenTypes screen, UIObject obj)
{
bool showBackButton = true;
var bar = SupportActionBar;
var ft = this.SupportFragmentManager.BeginTransaction ();
var activeFragment = this.SupportFragmentManager.FindFragmentByTag("active");
// If there is an active remove timer, stop it, because we bring the next screen onto the device
if (removeTimer != null) {
removeTimer.Stop();
removeTimer = null;
}
// A new screen replaces a dialog screen, if there is one
if (screenStack.Count > 0 && screenStack.Peek() is GameDialogScreen)
screenStack.Pop();
// A new screen replaces a screen of same type, if there is one
if (screenStack.Count > 0 && ((screenStack.Peek() is GameDetailScreen && screen == ScreenTypes.Details) || ((screenStack.Peek() is GameMapScreen && screen == ScreenTypes.Map))))
screenStack.Pop();
switch (screen)
{
case ScreenTypes.Main:
// Clear stack, because main screen is always the first
screenStack.Clear();
// Push new main screen onto stack
screenStack.Push(new GameMainScreen (engine));
// Don't show back button on main screen
showBackButton = false;
// Set title for activity
ft.SetBreadCrumbTitle (cartridge.Name);
break;
case ScreenTypes.Locations:
case ScreenTypes.Items:
case ScreenTypes.Inventory:
case ScreenTypes.Tasks:
// Clear stack, except main screen, which is always the first
while(screenStack.Count > 1)
screenStack.Pop();
screenStack.Push(new GameListScreen (engine, screen));
break;
case ScreenTypes.Details:
// Only push a new one, if it isn't the same
if (!(screenStack.Peek() is GameDetailScreen) || !((GameDetailScreen)screenStack.Peek()).ActiveObject.Equals(obj))
screenStack.Push(new GameDetailScreen (this, obj));
break;
case ScreenTypes.Map:
// Only push a new one, if it isn't the same
if (!(screenStack.Peek() is GameMapScreen) || !((GameMapScreen)screenStack.Peek()).ActiveObject.Equals(obj))
screenStack.Push(new GameMapScreen (this, obj));
break;
}
// Show icon as back button
bar.SetDisplayHomeAsUpEnabled (showBackButton);
// Bring topmost fragment to screen
ft.SetTransition (global::Android.Support.V4.App.FragmentTransaction.TransitNone);
ft.Replace (Resource.Id.fragment, screenStack.Peek(), "active");
ft.Commit ();
// Save actuall values for later use
if (screen != ScreenTypes.Dialog && screen != ScreenTypes.Map) {
activeScreen = screen;
activeObject = obj;
}
}
/// <summary>
/// Shows the screen.
/// </summary>
/// <param name="screen">Screen to show.</param>
/// <param name="obj">Object to show if screen is ScreenType.Details.</param>
public void ShowScreen(ScreenTypes screen, UIObject obj)
{
bool showBackButton = true;
var bar = SupportActionBar;
var ft = this.SupportFragmentManager.BeginTransaction();
var activeFragment = this.SupportFragmentManager.FindFragmentByTag("active");
// If there is an active remove timer, stop it, because we bring the next screen onto the device
if (removeTimer != null)
{
removeTimer.Stop();
removeTimer = null;
}
// A new screen replaces a dialog screen, if there is one
if (screenStack.Count > 0 && screenStack.Peek() is GameDialogScreen)
{
screenStack.Pop();
}
// A new screen replaces a screen of same type, if there is one
if (screenStack.Count > 0 && ((screenStack.Peek() is GameDetailScreen && screen == ScreenTypes.Details) || ((screenStack.Peek() is GameMapScreen && screen == ScreenTypes.Map))))
{
screenStack.Pop();
}
switch (screen)
{
case ScreenTypes.Main:
// Clear stack, because main screen is always the first
screenStack.Clear();
// Push new main screen onto stack
screenStack.Push(new GameMainScreen(engine));
// Don't show back button on main screen
showBackButton = false;
// Set title for activity
ft.SetBreadCrumbTitle(cartridge.Name);
break;
case ScreenTypes.Locations:
case ScreenTypes.Items:
case ScreenTypes.Inventory:
case ScreenTypes.Tasks:
// Clear stack, except main screen, which is always the first
while (screenStack.Count > 1)
{
screenStack.Pop();
}
screenStack.Push(new GameListScreen(engine, screen));
break;
case ScreenTypes.Details:
// Only push a new one, if it isn't the same
if (!(screenStack.Peek() is GameDetailScreen) || !((GameDetailScreen)screenStack.Peek()).ActiveObject.Equals(obj))
{
screenStack.Push(new GameDetailScreen(this, obj));
}
break;
case ScreenTypes.Map:
// Only push a new one, if it isn't the same
if (!(screenStack.Peek() is GameMapScreen) || !((GameMapScreen)screenStack.Peek()).ActiveObject.Equals(obj))
{
screenStack.Push(new GameMapScreen(this, obj));
}
break;
}
// Show icon as back button
bar.SetDisplayHomeAsUpEnabled(showBackButton);
// Bring topmost fragment to screen
ft.SetTransition(global::Android.Support.V4.App.FragmentTransaction.TransitNone);
ft.Replace(Resource.Id.fragment, screenStack.Peek(), "active");
ft.Commit();
// Save actuall values for later use
if (screen != ScreenTypes.Dialog && screen != ScreenTypes.Map)
{
activeScreen = screen;
activeObject = obj;
}
}
public SolveProjector(ProjectorEntry pe, double radius, ProjectionType type, ScreenTypes tranformType, SolveParameters solveParameters)
{
this.projectionType = type;
this.screenType = tranformType;
this.solveParameters = solveParameters;
switch (type)
{
case ProjectionType.View:
{
Fov.Value = pe.ViewProjection.FOV;
Aspect.Value = pe.ViewProjection.Aspect;
OffsetX.Value = pe.ViewProjection.XOffset;
OffsetY.Value = pe.ViewProjection.YOffset;
RadialCenterX.Value = pe.ViewProjection.RadialCenterX;
RadialCenterY.Value = pe.ViewProjection.RadialCenterY;
RadialAmountX.Value = pe.ViewProjection.RadialAmountX;
RadialAmountY.Value = pe.ViewProjection.RadialAmountY;
Pitch.Value = pe.ViewTransform.Pitch;
Heading.Value = pe.ViewTransform.Heading;
Roll.Value = pe.ViewTransform.Roll;
X.Value = -pe.ViewTransform.X;
Y.Value = pe.ViewTransform.Y;
Z.Value = pe.ViewTransform.Z;
}
break;
case ProjectionType.FishEye:
case ProjectionType.Projector:
{
Fov.Value = pe.ProjectorProjection.FOV;
Aspect.Value = pe.ProjectorProjection.Aspect;
OffsetX.Value = pe.ProjectorProjection.XOffset;
OffsetY.Value = pe.ProjectorProjection.YOffset;
RadialCenterX.Value = pe.ProjectorProjection.RadialCenterX;
RadialCenterY.Value = pe.ProjectorProjection.RadialCenterY;
RadialAmountX.Value = pe.ProjectorProjection.RadialAmountX;
RadialAmountY.Value = pe.ProjectorProjection.RadialAmountY;
Pitch.Value = pe.ProjectorTransform.Pitch;
Heading.Value = pe.ProjectorTransform.Heading;
Roll.Value = pe.ProjectorTransform.Roll;
X.Value = -pe.ProjectorTransform.X;
Y.Value = pe.ProjectorTransform.Y;
Z.Value = pe.ProjectorTransform.Z;
}
break;
case ProjectionType.Solved:
{
Fov.Value = pe.SolvedProjection.FOV;
Aspect.Value = pe.SolvedProjection.Aspect;
OffsetX.Value = pe.SolvedProjection.XOffset;
OffsetY.Value = pe.SolvedProjection.YOffset;
RadialCenterX.Value = pe.ProjectorProjection.RadialCenterX;
RadialCenterY.Value = pe.ProjectorProjection.RadialCenterY;
RadialAmountX.Value = pe.ProjectorProjection.RadialAmountX;
RadialAmountY.Value = pe.ProjectorProjection.RadialAmountY;
Pitch.Value = pe.SolvedTransform.Pitch;
Heading.Value = pe.SolvedTransform.Heading;
Roll.Value = pe.SolvedTransform.Roll;
X.Value = -pe.SolvedTransform.X;
Y.Value = pe.SolvedTransform.Y;
Z.Value = pe.SolvedTransform.Z;
}
break;
default:
break;
}
useGrid = pe.UseGrid;
width = pe.Width;
height = pe.Height;
sphereRadius = radius;
if (useGrid)
{
LoadGrid(pe.Constraints);
}
}
public static Bitmap MakeWarpMap(ProjectorEntry pe, double domeSize, bool radialDistortion, List<GroundTruthPoint> gtPointList, ScreenTypes screenType)
{
List<Vector2d> PointTo = new List<Vector2d>();
List<Vector2d> PointFrom = new List<Vector2d>();
double xFactor = pe.Width / 512.0;
double yFactor = pe.Height / 512.0;
Bitmap bmp = new Bitmap(512, 512);
FastBitmap fastBmp = new FastBitmap(bmp);
SolveProjector spProjector = new SolveProjector(pe, domeSize, ProjectionType.Projector, screenType, SolveParameters.Default);
spProjector.RadialDistorion = radialDistortion;
SolveProjector spView = new SolveProjector(pe, domeSize, ProjectionType.View, ScreenTypes.Spherical, SolveParameters.Default);
spView.RadialDistorion = false;
foreach (GroundTruthPoint gt in gtPointList)
{
PointFrom.Add(new Vector2d((double)gt.X / (double)pe.Width * 512, (double)gt.Y / (double)pe.Height * 512));
Vector2d pntOutTarget = spView.ProjectPoint(new Vector2d(gt.Az, gt.Alt));
Vector2d AltAzMapped = spProjector.GetCoordinatesForScreenPoint(gt.X,gt.Y);
Vector2d pntOutMapped = spView.ProjectPoint(new Vector2d(AltAzMapped.X, AltAzMapped.Y));
pntOutTarget.X = pntOutTarget.X *(512 / 2.0) + (512 / 2.0);
pntOutTarget.Y = pntOutTarget.Y *(-512 / 2.0) + (512 / 2.0);
pntOutMapped.X = pntOutMapped.X *(512 / 2.0) + (512 / 2.0);
pntOutMapped.Y = pntOutMapped.Y *(-512 / 2.0) + (512 / 2.0);
PointTo.Add(new Vector2d(pntOutTarget.X - pntOutMapped.X, pntOutTarget.Y - pntOutMapped.Y));
}
//Matrix3d projMat = spView.GetCameraMatrix();
unsafe
{
fastBmp.LockBitmap();
for (int y = 0; y < 512; y++)
{
for (int x = 0; x < 512; x++)
{
Vector2d pnt = spProjector.GetCoordinatesForScreenPoint(x * xFactor, y * yFactor);
Vector2d pntOut = spView.ProjectPoint(pnt);
// Map
pntOut.X = pntOut.X * (512 / 2.0) + (512 / 2.0);
pntOut.Y = pntOut.Y * (-512 / 2.0) + (512 / 2.0);
pntOut = MapPoint(new Vector2d(x,y), pntOut, PointTo, PointFrom);
pntOut.X = (pntOut.X - (512 / 2.0)) / (512 / 2.0);
pntOut.Y = (pntOut.Y - (512 / 2.0)) / (-512 / 2.0);
// End Map
double xo = pntOut.X * (4096 / 2.0) + (4096 / 2.0);
double yo = pntOut.Y * (-4096 / 2.0) + (4096 / 2.0);
int blue = (int)xo & 255;
int green = (int)yo & 255;
int red = (((int)yo) >> 4 & 240) + (((int)xo) >> 8 & 15);
*fastBmp[x, y] = new PixelData(red, green, blue, 255);
}
}
fastBmp.UnlockBitmap();
}
return bmp;
}
protected void CallFormRequestEvent(ScreenTypes form, params string[] Param)
{
// Event will be null if there are no subscribers
if (FormRequestEvent != null)
{
FormRequestEvent(form, Param);
}
}
public EndScreen(Game game, ContentManager content, SpriteBatch spriteBatch, ScreenTypes screenType) : base(game, content, spriteBatch, screenType)
{
Initalize();
LoadContent();
}
