/// <summary>Handles the KeyUp event of the Keyboard control.</summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="GorgonKeyboardEventArgs"/> instance containing the event data.</param>
private static void Keyboard_KeyUp(object sender, GorgonKeyboardEventArgs e)
{
switch (e.Key)
{
case Keys.C:
if (_ship.LayerController != null)
{
LayerCamera controller = _ship.LayerController;
_ship.LayerController = null;
_shipDeux.LayerController = controller;
}
else
{
LayerCamera controller = _shipDeux.LayerController;
_shipDeux.LayerController = null;
_ship.LayerController = controller;
}
break;
case Keys.F1:
_showInstructions = !_showInstructions;
break;
}
}
/// <summary>
/// Function to initialize the scene to render.
/// </summary>
private static void SetupScene()
{
// This is our camera used to map our objects into relative space.
// Because it's an Ortho camera, it doesn't really know how to handle aspect ratios, so we'll have to adjust for the current ratio.
var camera = new Gorgon2DOrthoCamera(_renderer, new DX.Size2F(2, 2), 0.1f, 5000)
{
Anchor = new DX.Vector2(0.5f, 0.5f)
};
camera.AllowUpdateOnResize = false; // Since we're using a custom coordinate set, we don't want to change it automatically when we resize the swap chain.
// That means we are responsible for any adjustments required on resize.
// Scenes are composed of layers, which are composed of sprites/meshes/etc...
// Each layer is used to give an illusion of depth by employing parallax scrolling. While we could use the Gorgon camera to do this, it will not give an illusion of depth
// because it is an orthographic projection camera which employs constant Z values.
//
// Each layer is added in the order in which it will be rendered.
BgStarLayer bgLayer = LayerBuilder.GetBackgroundLayer(_renderer, _resources);
SpritesLayer sunLayer = LayerBuilder.GetSunLayer(_renderer, _resources);
PlanetLayer planetLayer = LayerBuilder.GetPlanetLayer(_graphics, _resources);
SpritesLayer shipLayer = LayerBuilder.GetShipLayer(_renderer, _resources);
SpritesLayer shipLayerDeux = LayerBuilder.GetShipLayer(_renderer, _resources);
// Assign our rendering camera so that we have a means of projecting our coordinate information.
sunLayer.Camera =
planetLayer.Camera =
shipLayerDeux.Camera =
shipLayer.Camera = camera;
// Link the light from the sun layer to only show on the planet layer.
// With this particular setup, we can set a light to be parented on one layer, so that it will inherit its transformations, and affect a completely different layer.
// In this example, our sun is distant, so when the layer camera moves, it should move slowly. But in reality, the light source is fairly close to the planet to give
// a subtle (or not, depending on bloom) lighting effect.
sunLayer.Lights[0].Layers.Add(planetLayer);
// Here we'll set up the layer camera controller. This is what will give the illusion of movement across space by shifting the planet, sun, and other sprites.
var controller = new LayerCamera(new Layer[] { bgLayer, sunLayer, planetLayer, shipLayerDeux, shipLayer });
// This is our renderer which is responsible the drawing the layers and applying any post processing effects.
_sceneRenderer = new SceneRenderer(_renderer, _resources, _mainRtv, controller, camera);
_sceneRenderer.LoadResources();
// Our player ship. Since this one is linked to the layer camera controller, we can use our keyboard to move around the scene.
_ship = new Ship(shipLayer);
_ship.Position = new DX.Vector2(120.0f, 75.0f);
_ship.Angle = -45.0f;
_ship.LayerController = controller;
_ship.LoadResources();
// A secondary ship. Just here to look pretty.
_shipDeux = new Ship(shipLayerDeux);
_shipDeux.Position = new DX.Vector2(120.3f, 74.8f);
_shipDeux.Angle = -78.0f;
_shipDeux.Ai = new DummyAi();
_shipDeux.LoadResources();
// Create a big ship for some scene variety.
_bigShip = new BigShip(shipLayerDeux);
_bigShip.Position = new DX.Vector2(120.3f, 74.5f);
_bigShip.Angle = -80.0f;
_bigShip.LoadResources();
}
