Wir haben nun das Zeitalter der KI erreicht, weshalb hier weniger Lösungen und mehr das Technik Tagebuch Posts kommen.
Lösungen verlinke ich Kategorisch extra auf den weiteren Seiten des Blogs
Ohne DirectX Hardware Beschleuniger ist die Performance eher auf dem Level, hmm.. Ich drücke das mal so aus: "Es geht". Dennoch ist interessant zu testen, was man eigentlich so auf dem Raspberry Pi erreichen kann. Für diese Tests verwende ich den Raspberry Pi 3 Model B+.
Testanwendung
Vom meinem letzten Blogpost Eintrag "3d Karte bewegen (MonoGame)" habe ich einen Branch angelegt, in dem ich die Inhalte für einen kleinen Benchmark aufbereite. Zum Beispiel wird die Eingabe mit dem GamePad oder Tastatur abgestellt. Hinzu kommen dann noch weitere 3D Objekte hinzu, die im Verlauf geändert werden. In der UI selbst wird dann die FPS und Durchschnittsergebnis der verschiedenen drei Durchläufen wiedergegeben.
Testumfeld, Quick and dirty
Der Test selbst ist nur sehr einfach gestrickt und sicherlich kann dort auch Optimiert werden. Aber das sollte diesmal nicht das Thema sein.
Durchläufe:
- 9 Objekte
- 100 Objekte
- 400 Objekte
Die Objekte sind auf 0.25 skaliert. Nur bei dem ersten können wirklich alle Kacheln gesehen werden. Bei den anderen Mengen, übertreten diese den Bildschirmrand.
Auf dem PC werden immer die 60 FPS erreicht. Der eingestellte Vsync beschränkt die FPS, was jedoch nicht weiter schlimm ist. Für den Raspberry Pi sollte die Beschränkung kein Problem darstellen. Kommen wir zu den Testergebnissen
Ergebnis (Debug)
Die Anzahl der Bilder waren nicht sonderlich stabil und schwanke sogar relativ stark. Dennoch hat man erstmal so ein paar Ergebnisse, die man versucht zu verbessern. Da wäre das Auslassen von 3d Objekten, die nicht zu sehen sind.
Was ist mit Core Application
Bisher noch nicht genutzt, aber ich dachte, es paßt gerade hier beim Testen. Also nahm ich den ganzen Code von der aktuellen Test Branch und erstellte ein Projekt mit Core Application. Klingt zunächst super.
Ergebnis (Debug)
Ergebnis (Release)
Nun, die Ergebnisse verhalten sich fast identisch wie der Normalen UWP Projekt. Teilweise hatte ich den Eindruck, daß die Ergebnisse schlechter waren. Das lag mit unter das die Ergebnisse bei mehreren Durchläufen sehr stark schwankten. Das änderte sich auch nicht, als ich den Test für eine Stunde laufen ließ.
Was ist mit 2D?
Vielleicht sollte man nicht zuviel auf 3D Inhalte setzen und lieber auf 2D setzen. Also habe ich von meinem vorigen Post und dessen Beispiel ebenfalls ein Branch erstellt und ähnliche Test Umgebung geschaffen in 2D und zunächst als UWP.
Ergebnis (Debug)
Zugegeben, das hatte ich nicht erwartet. Vielleicht liegt das an der zu rendernden Anzahl von Pixeln, die letztendlich in den Backbuffer landen. Offensichtlich macht die Ausführung in 2D oder 3D keinen Unterschied. Die Schwankungen verhielten sich nicht anders.
Fazit
Das Testumfeld ist nicht sonderlich Realistisch, wenn man vom Optimieren absah. Die Frage ob man MonoGame verwenden kann auf dem Raspberry Pi, dann ist die Antwort ja. Wir stellen fest, die Antwort passt nicht zu den Ergebnissen. Warum ja? Mit Kompromissen, kann man durch aus MonoGame auf dem Raspberry Pi verwenden, wenn man Kompromisse eingeht. Mein Kompromiß ist Interesse.
Kompromisse die in erster Linie bestehen:
- Geringe FPS
- Geringe Auflösung um den FPS hoch zuhalten
- Ich will sehen, wie mein MonoGame Spiel auf dem Raspberry Pi (nicht) performt
Damit will ich das Thema Raspberry und MonoGame nicht schlecht schreiben. Denn nicht alle Spiele setzen auf hohe FPS. Das könnte ein 'Click and Point Adventure' sein.
Zur Vollständigkeit zu meinem letzten Blog-Post wird das Beispiel in 3d Abgebildet. Abgesehen von der 3d Ansicht und Verwendung einer 3d Kamera ist die Steuerung nahe zu gleich, so das ich hier die Ausführung des Inputs auslasse.
Welches 3d Format
Normalerweise werden *.fbx und *.x 3d Formate unterstützt. Für mich war es jedoch neu, daß auch Wavefront *.obj 3d Format unterstütz wird. Das erfreuliche ist, daß z.B. viele frei verwendete 3d Modell in diesem Format vorliegen. Das erspart fehlerhafte Konvertierungen mit anderen Programmen. Wie immer verwende ich hier die Assets von Kenny.nl die nicht nur Texturen anbieten, sondern auch 3d Modell in *.obj und teilweise in *.fbx.
Pipeline 3d Importer
Vermutlich ist das noch ein Fehler in MonoGame Version 3.7.1. Wenn das 3d Model im Pipline Tool hinzugefügt wird, dann werden einige initiale Einstellungen gesetzt die bei einen Punkt manuell umgestellt werden muss.
Bei dem Wavefront Format, liegt neben der *.obj Datei auch eine *.mtl. Diese brauchen wir zunächst nicht in das Pipeline Tool hinzufügen.
Klickt ihr auf die Datei, dann werden in Properties die Einstellungen angezeigt. Hier wurde eigentlich der richtige Importer Ausgewählt. Dies las ich auch in einigen Foren Einträgen.
Fehler beim Laden des 3d Models
Falls ihr einen Ausnahmefehler erhält, das beim Laden des 3d Models auftritt. Could not find ContentTypeReader Type. Please ensure the name of the Assembly..... Naja, ist im folgenden Bild zu sehen.
Kommt also dieser Ausnahmefehler, dann sollte der Importer von Open Asset Import Library - MonoGame umgestellt werden auf Fbx Importer - MonoGame.
Und nicht vergessen, nach dem Hinzufügen einmal auf F6 oder Build (Rebuild) klicken.
Laden des 3d Models
In das Unterverzeichnis zu Component werden die ComponentMap.cs und PlateGrassTile.cs angelegt.
Das verwendete 3d Model in dem Beispiel ist einfach eine Grüne Platte und soll dann später eine größere Fläche Abbilden. Im folgenden Code ist zu sehen, dass das 3d Objekt gedreht wird um 90 Grad. Aus der Gewohnheit her, ist Z hier die Höhe und Y die Tiefe. In Büchern wird oft Z als Tiefe und Y als Höhe angeben, was auch Technisch gesehen auch richtig ist.
Das im Konstruktor der Parameter 'Scale' angegeben wird, findet erst in im nächsten Post eine Verwendung.
public class PlateGrassTile
{
private Vector3 _offsetPosition;
private readonly float _scale = 1;
private readonly Model _model;
private readonly Matrix[] _transform;
private readonly ModelMesh _mesh;
private readonly bool _onlyOneMesh = false;
private Vector3 _offsetRotation;
public Vector3 Position { set; get; } = new Vector3();
public PlateGrassTile(Vector3 offsetPosition, float scale, Model model)
{
this._offsetPosition = offsetPosition;
var offsetRotateX = MathHelper.ToRadians(90);
this._offsetRotation = new Vector3(offsetRotateX, 0, 0);
this._scale = scale;
this._model = model;
this._transform = new Matrix[this._model.Bones.Count];
this._model.CopyAbsoluteBoneTransformsTo(this._transform);
this._mesh = this._model.Meshes.First();
this._onlyOneMesh = !this._model.Meshes.Any();
}
public void Draw(Matrix view, Matrix projection)
{
foreach (ModelMesh mesh in this._model.Meshes)
{
foreach (BasicEffect effect in mesh.Effects)
{
foreach (EffectPass effectPass in effect.CurrentTechnique.Passes)
{
effectPass.Apply();
}
effect.EnableDefaultLighting();
this.SetTransform(effect, mesh);
effect.View = view;
effect.Projection = projection;
}
mesh.Draw();
}
}
private void SetTransform(BasicEffect effect, ModelMesh mesh)
{
effect.World = this._transform[mesh.ParentBone.Index] *
Matrix.CreateRotationX(this._offsetRotation.X) *
Matrix.CreateRotationY(this._offsetRotation.Y) *
Matrix.CreateRotationZ(this._offsetRotation.Z) *
Matrix.CreateTranslation(this.Position + this._offsetPosition) *
Matrix.CreateScale(this._scale);
}
}
Karte erstellen
Die Kartenerstellung wird hier simple gehalten und besteht daher aus 3x3 Felder. Für das Beispiel haben die Objekte einen kleinen Abstand zu einander. So kann man sehen, daß die neun Grasflächen erzeugt wurden. Ansonsten einfach in der Methode 'GetPosition' die Variable 'distance' auf '0f' setzten. Das 3d Objekt wird hier Initial geladen und dessen Referenz zusammen mit der Position zugewiesen in das 'PlateGrassTile' Klassen Objekt.
public class ComponentMap : GameComponent
{
private const float _speed = 0.3f;
private readonly ComponentInputs _componentInputs;
private PlateGrassTile[] _groundTiles = new PlateGrassTile[9];
public ComponentMap(Game game, ComponentInputs componentInputs) : base(game)
{
this._componentInputs = componentInputs;
}
public override void Initialize()
{
var grass = this.Game.Content.Load("Plate_Grass_01");
int index = 0;
for (int iY = 0; iY < 3; iY++)
{
for (int iX = 0; iX < 3; iX++)
{
this._groundTiles[index] = new PlateGrassTile(this.GetPosition(iX, iY),
0.5f,
grass);
index++;
}
}
}
public override void Update(GameTime gameTime)
{
foreach (var item in this._groundTiles)
{
item.Position += new Vector3(this._componentInputs.Inputs.MoveX,
this._componentInputs.Inputs.MoveY, 0)
* _speed;
}
}
public void DrawContent(Matrix view, Matrix projection)
{
foreach (var item in this._groundTiles)
{
item.Draw(view, projection);
}
}
private Vector3 GetPosition(int x, int y)
{
float mapLength = 3f;
float distance = .02f;
float centerMap = (mapLength + distance)
* (float)Math.Sqrt(this._groundTiles.Length) / 2; ;
return new Vector3((y * (mapLength + distance)) - centerMap,
(x * (mapLength + distance)) - centerMap,
0);
}
}
Kamera
So richtig entscheiden konnte ich mich an der stelle nicht, wie ich die Komponente nenne. Render oder Camera. Es wird gerendert, aber auch die Kameraausrichtung vorgenommen. Auftrennen wäre hier zunächst übertrieben, dennoch macht es Sinn die wesentlichen Aspekte der Kamera zu einer Klasse zusammen zufassen.
Die Klasse 'CameraView.cs' setz alle Einstellungen in der Initialize Methode fest. Initial muß auch die AspectRatio gesetzt werden, da mit der UWP vorher nicht festgelegt wird, welche Auflösung verwendet wird.
public class CameraView
{
private readonly Game _game;
private readonly ComponentMap _componentContent;
public Matrix View { get; private set; }
public Matrix Projection { get; private set; }
public CameraView(Game game, ComponentMap componentMap)
{
this._game = game;
this._componentContent = componentMap;
}
public void Initialize()
{
var aspectRatio = this.GetAspectRatio();
var position = new Vector3(-1f, 5f, 5f);
var target = new Vector3(0, 0, 0);
var farPlaneDistance = 10000;
this.View = Matrix.CreateLookAt(position, target, Vector3.Backward);
this.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
aspectRatio,
1,
farPlaneDistance);
}
public void Draw()
{
this._componentContent.DrawContent(this.View, this.Projection);
}
private float GetAspectRatio()
{
var w = (float)ApplicationView.GetForCurrentView().VisibleBounds.Width;
var h = (float)ApplicationView.GetForCurrentView().VisibleBounds.Height;
return w / h;
}
}
Die 'ComponentRender' Klasse ist hier sehr übersichtlich und hat hier auch sonst keine Besonderheit. Mit dem nächsten Blogpost wird jedoch dieser Bereich erweitert.
public class ComponentRender : DrawableGameComponent
{
private readonly CameraView _cameraView;
public ComponentRender(Game game, ComponentMap componentContent) : base(game)
{
this._cameraView = new CameraView(game, componentContent);
this._cameraView.Initialize();
}
public override void Draw(GameTime gameTime)
{
this.GraphicsDevice.Clear(Color.CornflowerBlue);
this._cameraView.Draw();
}
}
Der Rest des Codes ist nahe zu Identisch wie bei dem letzten Post, wie man eine 2d Karte bewegt.
Nachwort
Diese Ausführung funktioniert noch gut auf dem Raspberry Pi 3. Hektische Spiele sollten man denn noch nicht anversieren.
Für die Lösung, wie eine Figur auf der Karte Bewegt werden kann, ist davon abhängig, wieviel Leistung mein Ziel System hat. In den meisten Fällen hat man mehr als genügend Leistung, so dass man sich hierbei entscheiden kann. Für relativ schwache System, z.B. wie bei einem Arduino Esplora kann eine Figur auf dem Bildschirm bewegt werden, ohne einem starken flackern. Eine Karte auf dem Bildschirm zu bewegen sieht dagegen wieder schlecht aus, weil der Bildaufbau zu lange dauert. Und das bei einer Auflösung von 128x160 Pixeln.
Nicht die Figur, sondern die Karte bewegt sich
Nun zurück zum Eigentlichen. Die Figur ist immer mittig auf dem Bildschirm und bewegt sich auf einer Karte. Aber Technisch gesehen, wird die Karte bewegt und die Figur hat eine Laufanimation.
Neues MonoGame Projekt
Aktuell wird für dieses Beispiel eine Neue Solution angelegt mit dem Ziel einer UWP Anwendung. Die Zielplattform und Version hat jedoch keinen Effekt für das Beispiel. Der Grund für UWP ist, das die Lauffähigkeit auf PC, Tablet, Raspberry Pi 2&3 und wenn ich mich nicht irre, auch auf der Xbox funktionieren soll. Sollte die Anwendung/Spiel auch auf dem Windows Phone laufen, dann ist eine ältere Minimum Ziel Version von Windows 10 einzustellen.
Ordnung ist das halbe Leben
Als erstes brauchen wir eine Projekt Struktur und legen ein paar Ordner an. Components wird es später drei Komponenten geben, die für die Benutzereingaben, die Karteverarbeitung und das Zeichnen zuständig sind.
Der Umfang für das Realisieren benötigt einige Zeilen Code, so das eine Aufteilung der Inhalte Notwendig sind. Deshalb kann zunächst in der 'Game1.cs' fast alles weg. Nur der Konstruktor bleibt.
using Microsoft.Xna.Framework;
namespace ExampleWalkingOnMap
{
public class Game1 : Game
{
private GraphicsDeviceManager _graphics;
public Game1()
{
this._graphics = new GraphicsDeviceManager(this);
this.Content.RootDirectory = "Content";
this.Window.Title = "Example Walking on map";
this.IsMouseVisible = true;
}
}
}
Eingabegerät
Für das erfassen von Tasteneingaben, wird die Klasse 'ComponentInputs.cs' und für die Steuerinformation 'InputData.cs' angelegt.
Zunächst muss die 'InputData.cs' bearbeitet werden, um die verarbeiteten Steuerinformationen weiter zutragen.
using Microsoft.Xna.Framework;
namespace ExampleWalkingOnMap.Components.Inputs
{
public class InputData
{
public Vector2 Move => new Vector2(this.MoveX, this.MoveY);
public float MoveX { get; set; }
public float MoveY { get; set; }
}
}
Mit der ‚InputData‘ können die Eingaben in ComponentInputs.cs aufgenommen werden. Im Beispiel wird die Tastatur und ein Xbox Controller eingelesen. Damit wäre die Eingabe Komponente fertig.
Die Realisierung der Karte wird in Kacheln unterteilt und ist auch relativ leicht um zusetzten. Jede Kachel hat eine eigene Position und eine Textur, womit schon mal das nächste Objekt definiert ist.
Für die Textur mit verschiedenen Untergründen wird eine Bilddatei zusammen gefasst, die die Unterschiedlichen Bodentexturen beinhaltet. Jedes Objekt kennt dann nur den Ausschnitt aus der Bilddatei. Für das Beispiel verwende ich die Texturen von https://kenney.nl/assets.
Im Projekt wurde bereits mit der Vorlage, der Ordner 'Content' angelegt. Hier wird nun die Textur abgelegt.
Nun muss die Bilddatei noch mit dem Pipline Tool verarbeitet werden, indem ihr doppelkick auf 'Content.mgcb' ausführt. Im Ausschnitt Projekt wird die Bilddatei hinzugefügt.
Wirkt leider etwas doppelt, aber dies ist notwendig, damit die Textur später im Programmcode geladen werden kann.
Anschließend auf den Button 'Build' oder F6 drücken und fertig ist dieser Teil und könnt das Tool wieder schließen.
Nun zurück zum Code für die Kachel Information. Wie bereits erwähnt, kennt die Kachel nur die Position der Textur, die später über die Methode Draw hinein gereicht wird. Mit dem weiteren Parameter 'offset' wird bestimmt, wo im Fenster gerendert wird.
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
namespace ExampleWalkingOnMap.Components.Map
{
public class GroundTile
{
private Rectangle _texturePosition;
public GroundTile(int x, int y, int width, int height)
{
this._texturePosition = new Rectangle(x, y, width, height);
}
public void Draw(Texture2D textureMapTiles, SpriteBatch spriteBatch, Vector2 offset)
{
spriteBatch.Draw(textureMapTiles,
offset,
this._texturePosition,
Color.White,
0f,
new Vector2(0, 0),
new Vector2(1, 1),
SpriteEffects.None,
0f);
}
}
}
Die Karte soll aus 10x10 Kacheln bestehen und wird in einer Hilfsklasse erstellt.
Mit dem zwei Dimensionalen Integer Array, lässt sich visuell schnell eine Karte dieser Größe zusammenstellen, die wiederum noch übersichtlich ist. Zumindest im ersten Abschnitt der Methode. Anschließend wird hier in das Ziel Array gemappt mit den eigentlichen Ziel Objekt.
using System;
namespace ExampleWalkingOnMap.Components.Map
{
internal class MapHelper
{
internal static GroundTile[,] CreateMap()
{
int[][] map = new int[10][];
map[0] = new int[10] { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2 };
map[1] = new int[10] { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2 };
map[2] = new int[10] { 1, 1, 1, 1, 1, 1, 1, 0, 2, 2 };
map[3] = new int[10] { 0, 0, 0, 0, 0, 0, 1, 0, 2, 2 };
map[4] = new int[10] { 0, 0, 0, 0, 0, 0, 1, 0, 2, 2 };
map[5] = new int[10] { 0, 0, 0, 0, 0, 0, 1, 0, 2, 2 };
map[6] = new int[10] { 0, 0, 0, 0, 0, 0, 1, 0, 2, 2 };
map[7] = new int[10] { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 };
map[8] = new int[10] { 0, 0, 0, 0, 0, 0, 1, 0, 3, 3 };
map[9] = new int[10] { 0, 0, 0, 0, 0, 0, 1, 0, 3, 0 };
GroundTile[,] groundTiles = new GroundTile[10, 10];
for (int iY = 0; iY < 10; iY++)
{
for (int iX = 0; iX < 10; iX++)
{
groundTiles[iY, iX] = GetMappingGroundTile(map[iY][iX]);
}
}
return groundTiles;
}
private static GroundTile GetMappingGroundTile(int groundTile)
{
switch (groundTile)
{
case 0:
return new GroundTile(0, 0, 64, 64);
case 1:
return new GroundTile(64, 0, 64, 64);
case 2:
return new GroundTile(0, 64, 64, 64);
case 3:
return new GroundTile(64, 64, 64, 64);
}
throw new ArgumentException("groundTile can be only 0, 1, 2 and 3");
}
}
}
Für die Verwaltung der Karte wird die Klasse 'ComponentMap.cs' erstellt. Dort werden die Karteninhalte gesteuert und gehalten.
Der Umfang der Klasse ist hier größer als bei den anderen, auch wenn dessen Ausführung sehr klein gehalten ist.
using ExampleWalkingOnMap.Components.Inputs;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
namespace ExampleWalkingOnMap.Components.Map
{
public class ComponentMap : GameComponent
{
private readonly ComponentInputs _inputs;
private GroundTile[,] _mapTiles;
private Texture2D _textureMapTiles;
private int _mapTileWidth, _mapTileHeight;
private Vector2 _screenOffset, _movePosition;
public Vector2 Position => new Vector2(this._movePosition.X + this._screenOffset.X,
this._movePosition.Y + this._screenOffset.Y);
private int _mapWidth, _mapHeight;
public ComponentMap(Game game, ComponentInputs inputs) : base(game) => this._inputs = inputs;
internal void SetScreenOffset(float screenWidth, float screenHeight)
{
var centerScreenWidth = screenWidth / 2;
var centerScreenHeight = screenHeight / 2;
this._screenOffset = new Vector2(centerScreenWidth, centerScreenHeight);
this._movePosition = new Vector2(0, 0);
}
public override void Initialize()
{
using (var stream = TitleContainer.OpenStream("Content/MapTiles.png"))
{
this._textureMapTiles = Texture2D.FromStream(this.Game.GraphicsDevice, stream);
}
this._mapTiles = MapHelper.CreateMap();
this._mapTileWidth = this._textureMapTiles.Width / 2;
this._mapTileHeight = this._textureMapTiles.Height / 2;
this._mapWidth = this._mapTileWidth * this._mapTiles.GetLength(0);
this._mapHeight = this._mapTileHeight * this._mapTiles.GetLength(1);
}
public override void Update(GameTime gameTime)
{
this._movePosition += this._inputs.Inputs.Move * 2f;
}
public void DrawMapTiles(SpriteBatch spriteBatch)
{
for (int iY = 0; iY < this._mapTiles.GetLength(0); iY++)
{
for (int iX = 0; iX < this._mapTiles.GetLength(1); iX++)
{
Vector2 textureOffset = new Vector2(iX * this._mapTileWidth, iY * this._mapTileHeight);
Vector2 offset = this.Position + textureOffset;
this._mapTiles[iY, iX].Draw(this._textureMapTiles, spriteBatch, offset);
}
}
}
}
}
In der Update Methode wird die Bewegung mit 2 Multipliziert. Wenn die Bewegung zu langsam erscheint, dann kann hier der Wert erhöht werden. Wie bereits angemerkt, zeigt dieser Teil das Nötigste, um eine Karte anzulegen und für das Rendern vorzubereiten.
Rendern
Am Ende muss die Karte auf dem Bildschirm gerendert werden. Dazu wird noch eine weitere Komponente angelegt mit dem Namen 'ComponentRender.cs'.
Damit die Karte auf die Start Position in die Mitte zentriert wird, wird die Größe des Fensters eingelesen und dessen Werte für den Offset der Karte zugewiesen.
using ExampleWalkingOnMap.Components.Map;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Windows.UI.ViewManagement;
namespace ExampleWalkingOnMap.Components.Render
{
public class ComponentRender : DrawableGameComponent
{
private readonly ComponentMap _componentMap;
private SpriteBatch _spriteBatch;
public ComponentRender(Game game, ComponentMap componentMap) : base(game)
{
this._componentMap = componentMap;
}
public override void Initialize()
{
this._spriteBatch = new SpriteBatch(this.GraphicsDevice);
var screenWidth = (float)ApplicationView.GetForCurrentView().VisibleBounds.Width;
var screenHeight = (float)ApplicationView.GetForCurrentView().VisibleBounds.Height;
this._componentMap.SetScreenOffset(screenWidth, screenHeight);
}
public override void Draw(GameTime gameTime)
{
this.GraphicsDevice.Clear(Color.DarkBlue);
this._spriteBatch.Begin();
this._componentMap.DrawMapTiles(this._spriteBatch);
this._spriteBatch.End();
}
}
}
Zurück zum Start
Am Ende müssen die Komponenten in die GameComponentCollection hinzugefügt werden, damit die Inhalte ausgeführt werden. Dazu geht es wieder in die 'Game1.cs' Code Datei. Hier werden in den Member die Komponenten eingetragen und im Konstruktor wird die 'UpdateOrder' zugewiesen und schließlich in die Collection aufgenommen.
using ExampleWalkingOnMap.Components.Inputs;
using ExampleWalkingOnMap.Components.Map;
using ExampleWalkingOnMap.Components.Render;
using Microsoft.Xna.Framework;
namespace ExampleWalkingOnMap
{
public class Game1 : Game
{
private GraphicsDeviceManager _graphics;
private ComponentInputs _componentInputs;
private ComponentMap _componentMap;
private ComponentRender _componentRender;
public Game1()
{
this._graphics = new GraphicsDeviceManager(this);
this.Content.RootDirectory = "Content";
this.Window.Title = "Example Walking on map";
this.IsMouseVisible = true;
this._componentInputs = new ComponentInputs(this);
this._componentInputs.UpdateOrder = 1;
this.Components.Add(this._componentInputs);
this._componentMap = new ComponentMap(this, this._componentInputs);
this._componentMap.UpdateOrder = 2;
this.Components.Add(this._componentMap);
this._componentRender = new ComponentRender(this, this._componentMap);
this._componentRender.UpdateOrder = 3;
this.Components.Add(this._componentRender);
}
}
}
Wenn ich hier im Blog-Post keinen Code ausgelassen habe, dann sollte sich die Anwendung starten lassen und die Karte mit den Tasten AWSD sich bewegen lassen. Oder auch mit dem Xbox Controller.
Nachwort
Mit ein wenig mehr Code, kann man dann einige Unreinheiten beheben, wie z.B. die Übergänge von Kachel zu Kachel sehen nicht immer sauber aus oder das der Untergrund Einfluss auf die Laufgeschwindigkeit hat. Und Überhaupt fehlt die Laufende Figur in der Mitte.
Die Anwendung läuft soweit auch auf einem Raspberry Pi mit Windows 10 IoT. Jedoch sollte man keine hohen Performance erwarten, da hier keine DirectX Unterstützung vorhanden ist. Im Folgenden Video zeige ich die Anwendung auf einem Bildschirm mit einer Eingestellten Auflösung von 640x350 Pixeln (Nativ sind jedoch 480x320). In HD, also 1920x1080p, sind weniger als fünf Bilder pro Sekunde zu erwarten. Zudem ist der Boot Vorgang relativ lang und bis die MonoGame App gestartet ist. Da vergehen schon einige Minuten.
Der Aufbau und das Prinzip funktioniert auch mit Windows Forms, WPF und XAML. Auch wenn diese UI Technologien nicht dafür gedacht sind, kann man sehen zumindest sehen wie Leistungsfähig die anderen sind.
Die fertige Solution habe ich wie immer auf dem GitHub geladen. Zusätzlich sind die meisten Inhalte kommentiert.
Was mit dem Netduino geht, geht für gewöhnlich auch auf dem Raspberry Pi (wenn es nicht gerade um PWM Ausgänge geht). Grundsätzlich hatte ich das Modul tatsächlich für den Rasperry Pi gekauft, um die Fehlende Ausgabemöglichkeit eines PWM Signal auszugleichen. Zwar kann man einen Pin so programmieren, dass ein PWM Signal erzeugt wird, aber ich fand dieses Lösung zunächst nicht sehr ansprechend.
Benötigt:
Raspberry Pi 2 oder 3
8GB SD Karte mit installierten Windows 10 IoT
Mindestens ein Servo zum Testen
Externe Spannungsquelle mit Maximal 6V
UWP Anwendung erstellen
Nam dem anlegen einer neuen Solution wird für den Zugriff auf die Schnittstelle I²C die Reference "Windows IoT Extensions for the UWP" hinzugefügt. Das Beispiel geht mit allen Version die für Windows 10 IoT und Raspberry Pi.
Fast identisch
Außer der Zugriff auf das Interface für I²C, ist der Aufruf gleich. Das Konfigurieren der Schnittstelle erfolgt z.B. nicht im Konstruktor, sondern in einer eigenen Initialisierungsmethode. Grund hierfür ist das abrufen der Instanz von I2cDevice das über die DeviceInformation abgeholt werden kann.
internal class Pca9685 {
private readonly byte _address = 0x40;
private readonly byte PCA9685_MODE1 = 0x00;
private readonly byte PCA9685_PRESCALE = 0xFE;
private readonly byte LED0_ON_L = 0x06;
private readonly byte LED0_ON_H = 0x07;
private readonly byte LED0_OFF_L = 0x08;
private readonly byte LED0_OFF_H = 0x09;
private I2cDevice _i2cDevice;
public Pca9685(int period) : base()
{
this._period = period * 1000;
}
private async Task Init()
{
var i2cSettting = new I2cConnectionSettings(this._address);
i2cSettting.BusSpeed = I2cBusSpeed.StandardMode;
var deviceSelector = I2cDevice.GetDeviceSelector();
var deviceInfo = await DeviceInformation.FindAllAsync(deviceSelector);
Zudem sind alle Methodenaufrufe Asynchron. Die Lösung ist auch in Synchron möglich, jedoch denke ich, dass die Verwendung von Async, Await und Task noch im Übersichtlichen Rahmen ist.
Allerdings muss man sich bewusst machen, obwohl die Methoden Asynchron ausgeführt werden können, müssen die Aufrufe nacheinander erfolgen. Überschneiden oder gleichzeitig ist Technisch für die Schnittstelle nicht möglich, weil die Bits nacheinander geschrieben werden können.
Zur Vollständigkeit kommen noch die restlichen Methoden. Das Umrechnen (GetPrescale) ist hier direkt kopiert und unterscheidet sich auch nicht mal von der C++ Version die in den Sourcecode von Adafruit fand.
Das Versenden der Bytes braucht nicht mehr code als die Netduino Lösung.
…
private byte GetPrescale(float frequency)
{
frequency *= 0.9f;
// internal clock frequency
float prescaleval = 25000000;
prescaleval /= 4096;
prescaleval /= frequency;
prescaleval -= 1;
return (byte)(prescaleval + 0.5);
}
private bool Write(byte[] buffer)
{
var result = this._i2cDevice.WritePartial(buffer);
if (result.Status != I2cTransferStatus.FullTransfer)
Bereits im Blog Post für das Netduino Beispiel, hatte ich den Eindruck, dass die Ansteuerung verdreht ist. Das Verhalten ist auch hier Identisch.
Verkabeln
Vier Leitungen reichen, um das Modul Anzusteuern. Hier sind keine Besonderheiten. Damit der Angeschlossene Servo zuverlässig reagiert, sollte eine Externe Spannungsquelle angeschlossen werden.
Die Wesentlichen Technischen Infos:
PWM Signal kann in 4096 Stufen gesteuert werden (12Bit)
PWM Signal kann zwischen 24Hz bis maximal 1526Hz eingestellt werden.
Die 16 Anschlüsse für die Stromversorgung der Servos, können maximal betrieben werden in Abhängigkeit der Angeschlossenen Spannungsversorgung.
PWM Output selbst kann maximal bis 25mA verwendet werden für LEDs
Spannungsversorgung für die Steuerung über I²C darf von 2,3V bis 5,5V liegen.
16 PWM Ausgänge
Kann über einen Externen Clock betrieben werden, der maximal bis 50MHz sein darf.
