Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

71

07.12.2013, 16:52

Kann man nur in C# entwickeln oder auch in C++? Sieht nämlich echt cool aus :) und ich würde Duality später gerne verwenden. Wenn keine Entwicklung mit C++ unterstützt wird, kann man dann auch ohne C# Kenntnisse was damit machen?


Duality ist klar auf C# ausgelegt, wenn du dich ein wenig mit der .Net Umgebung auskennst solltest du aber auch jede andere .Net Sprache verwenden können - dazu müsstst du dir bloß die entsprechenden Projekttemplates selbst basteln. "Richtiges" C++ wirst du aber nicht verwenden können, da du an irgendeiner Stelle auf jeden Fall eine Anbindung zur verwalteten / managed .Net Welt brauchst.

Generell solltest du aber auch ohne C# Kenntnisse ganz gut klarkommen, weil vieles über den Editor läuft und du direkt sehen kannst, was für Auswirkungen dein Code hat. Außerdem bekommst du durch das Komponentensystem einen klar abgegrenzten Bereich, in dem du dich erstmal austoben kannst, bis du dich mit ersten C#-Kenntnissen darüber hinaus wagst. Außerdem ist C# sowieso einfacher als C++ ;)

Ein anderes wichtiges Thema ist die Performance in Bezug auf viele Objekte. UnityPro batched dafür automatisch alle Texturen zu einem Altlas zusammen, was mich ja persönlich sehr freut. Macht das Duality auch? Schließlich ein ziemlich gutes Feature, um Performance besonders auf mobilen Geräten zu optimieren.


Duality unterstützt ebenfalls eine Textur-Atlas Funktion, allerdings nicht vollautomatisch - kann man aber auch bei Bedarf selbst nachrüsten, braucht ja auch nicht jedes Spiel. Unter Batching verstehe ich allerdings eine andere Sache als das Versammeln mehrerer Sprites auf einer Textur - nämlich das Zusammenfassen zu übertragender Renderingdaten in möglichst wenige Drawcalls. Das macht Duality hinter den Kulissen auch von selbst.

Ich hab mal eine "ketzerische" frage: Was macht Duality im vergleich zu Unity mit Integriertem 2D besser? Was mich an "Unity2D" stark stört ist die Einschränkungen in der Free-Version und die Tatsache, dass man sich bei dir unter Umständen Features wünschen kann. Andererseits finde ich Duality an einigen Stellen bzgl. Usability etwas unhandlich, worauf ich dich auch schon mehrmals hingewiesen habe und dich bisher nicht überzeugen konnte.


Naja, Unity2D gibts ja erst seit ein paar Monaten. Vorher gabs das ja nicht und wenn ich mich richtig erinnere war das ja sozuagen das Ziel von Duality. Ähnlich wie Unity, aber halt für 2D und jetzt, wo Unity das selbst macht ist das für ihn ein wenig ungünstig.

Aber wäre interessant Fetze's Meinung zu hören. Vielleicht hat er sich ja etwas überlegt, wie er sicht gegen Unity platzieren kann. (Vielleicht über den Preis?)


Generell würde ich Unity und Duality nicht als Konkurrenten sehen, da könnte Duality doch ohnehin nicht mithalten ;) Es gibt Gemeinsamkeiten, aber letztendlich ist Duality dann auch einfach anders. Hier mal ein paar allgemeine Worte, um die beiden in einen Kontext zu stellen:

Unity
  • Unity ist ein Produkt, das im Laden steht - es ist fertig, sieht schick aus und kann genau das, was draufsteht.
  • Wenn man gerne ein Bauteil austauschen will, ist das alles etwas schwierig, weil ein Aufschrauben nicht vorgesehen ist.
  • Es ist ein Tool für Entwickler - dem Spieler ist es am Ende egal, ob Unity oder nicht Unity.
  • Außerdem bietet Unity eine Menge Features aus verschiedenen Richtungen - alles, was man eventuell so brauchen könnte.
Duality
  • Duality ist ein Bausatz - hier und da vielleicht noch etwas kantig, aber dafür genau so, wie man es sich eben eingerichtet hat.
  • Die Baupläne liegen bei, jeder kann sie verbessern. Ist ja nicht umsonst Open Source - aufschrauben ist ausdrücklich vorgesehen! Erweitern, Austauschen, Verändern ebenso - deswegen gibts dafür auch eine Menge Schnittstellen.
  • Es ist ein Tool für Entwickler und Spieler - denn jedem Spiel können genau die Level- und Contenteditoren beiliegen, die auch der Entwickler verwendet hat; dazu muss er sie beim Veröffentlichen einfach nur im Spieleordner liegen lassen.
  • Duality versucht nicht, das ultimative Schweizer Taschenmesser zu sein - aber es soll eine solide Grundlage bieten, die keine Richtung ausschließt.

So. Ketzerische Frage hinreichend beantwortet? :D

drakon

Supermoderator

Beiträge: 6 513

Wohnort: Schweiz

Beruf: Entrepreneur

  • Private Nachricht senden

72

07.12.2013, 17:31

Die Antwort gefällt mir!
Ich würde das noch ein wenig ausformulieren und dann bereit halten, wenn noch mehr Leute Fragen. Und vor allem auf deiner Seite irgendwo prominent verkaufen. Kannst sicher noch ein wenig mehr Entwickler von Unity abhalten und auf deine Seite locken.

73

16.12.2013, 21:32

Die Antwort gefällt mir!
Ich würde das noch ein wenig ausformulieren und dann bereit halten, wenn noch mehr Leute Fragen. Und vor allem auf deiner Seite irgendwo prominent verkaufen. Kannst sicher noch ein wenig mehr Entwickler von Unity abhalten und auf deine Seite locken.
Hab das mal in Form eines Blogeintrags getan. Danke für die Idee ^^ Die Frage, warum Duality existiert, obwohl es doch Unity2D gibt, werden sich vermutlich einige stellen. Darauf gibt es sicher viele verschiedene Antworten - aber auf eine davon kann ich nun direkt verweisen.

SiENcE

Frischling

Beiträge: 16

Wohnort: Berlin

  • Private Nachricht senden

74

31.01.2014, 15:21

Hi Fetze.
Ich schreibe hier eigentlich nie, aber nun sah ich mich genötigt mal was zu schreiben :).

Ich finde Dein Projekt großartig. Deine Bachelorarbeit habe ich mir gleich durchgelesen und danach ein bisschen Duality angeschaut. Du hast Dir ein paar Konzepte im Vorfeld gut überlegt. Ich finde gut. Der Editor lässt sich schon ganz gut bedienen und vom Konzept her gefällt mir, dass der Aufbau Unity ähnelt. Auch die Integration mit Visual Studio ist Klasse.

Ich mag Unity bzgl. diverser Dinge (Lizenzpolitik, OpenSource etc.) nicht besonders...deshalb finde ich Duality sehr interessant.

Ich habe aber ein paar Anmerkungen und Fragen.

* Den Pluginansatz finde ich übrigens sehr gut.

* Prinzipiell sollte es kein Problem sein, Duality für MacOSX und Linux (mit Hilfe von Mono) zum laufen zu bringen (da könnte ich Dir helfen).

* Was mich fast zum verzweifeln brachte, ist das Konzept ...den Editor bei einem neuen Projekt immer mitzukopieren. Das hat mich fast verrückt gemacht. Hast Du Dich bewusst dafür entschieden, oder fehlt einfach das Abspeichern, Laden und Handln von unterschiedlichen Projekten? Ich würde hier das Konzept von Unity favorisieren. Also ein Projektordner mit der Projektdatei und allen Assets. Ein Deploy button um ein Release (ohne/mit Editor) zu bauen.

* Desweiteren ist mir aufgefallen, dass man ältere Projekte nicht mit einem neueren Editor benutzen kann. Das liegt wohl am obigen Konzept!?

* Hast Du irgendwo Deine Roadmap dokumentiert? Also außer die Issue page auf github.

* Ich fand es immer schon eine große pain, größere Projekte in Unity zu handln. Diese ganzen Objekt- und Parameterlisten sind ein graus wenn man Sourcecode gewöhnt ist. Von Nachvollziehbarkeit von Änderungen ganz zu schweigen. Hast Du eine Idee oder ein Konzept dies besser zu machen? Wie kann man zb. gescheit mit dem Editor und Git zusammenarbeiten (mehrere Personen beteiligt) ? Ich denke hier konkret daran....in der jetzigen Phase der Entwicklung die Zusammenarbeit von mehreren Personen an einem Projekt in den Fokus zu rücken.

* Spricht etwas gegen die Integration von Scriptsprachen...zb. Lua?

Alles in allem seh ich Potenzial in Duality...eben weil es OpenSource ist und man Engine Bugs selbst fixen kann. Ich hoffe das weitere Entwickler zum Projekt stoßen!

cheers
SiENcE

75

31.01.2014, 16:11

Hi SiENcE,

danke erstmal für dein ausführliches Feedback :) Werde versuchen, so gut wie möglich auf deine Punkte einzugehen:
* Prinzipiell sollte es kein Problem sein, Duality für MacOSX und Linux (mit Hilfe von Mono) zum laufen zu bringen (da könnte ich Dir helfen).
Sehe da ähnliches Potential. Duality selbst besteht mittlerweile zu 99% aus Managed Code und hat keine plattformgebundenen Dependencies außer OpenTK, wobei eben dieses ja den Zweck hat, das Bindeglied von Grafik und Sound API für verschiedenste Plattformen zu sein. Probleme, die sich da derzeit ergeben:
  • Ich habe selbst weder Testsystem noch Kapazitäten, Duality auf Mac und Linux zum Laufen zu bringen. Hier bräuchte ich Hilfe von außen, würde mich da also über jedwede Experimente deinerseits oder von anderen Helfern freuen :)
  • Der Editor ist nicht ganz so plattformunabhängig und krallt sich über die eine oder andere Dependency in der WinAPI fest. Hier müsste Portierungsarbeit betrieben werden.
Prinzipiell muss man den Editor jedoch nicht portieren, damit man Duality Spiele auf anderen Systemen spielen kann.
* Was mich fast zum verzweifeln brachte, ist das Konzept ...den Editor bei einem neuen Projekt immer mitzukopieren. Das hat mich fast verrückt gemacht. Hast Du Dich bewusst dafür entschieden, oder fehlt einfach das Abspeichern, Laden und Handln von unterschiedlichen Projekten? Ich würde hier das Konzept von Unity favorisieren. Also ein Projektordner mit der Projektdatei und allen Assets. Ein Deploy button um ein Release (ohne/mit Editor) zu bauen.
* Desweiteren ist mir aufgefallen, dass man ältere Projekte nicht mit einem neueren Editor benutzen kann. Das liegt wohl am obigen Konzept!?
Letzteres kommt daher, dass Duality sich in stetiger Entwicklung befindet und vollständige Rückwärtskompatibilität nicht gewährleistet werden kann. Das wiederum ist der Grund für das Konzept des projektlokalen Editors, welches sicherstellt, dass jedes Projekt auch in Zukunft weiter funktioniert.

Es ist die einfache Lösung, aber eine Entscheidung, die ich jederzeit wieder so treffen würde: So bleiben alte Projekte prinzipiell erstmal intakt, und wer sie portieren will, kann das gerne tun - aber es bleibt eine explizite Aktion des Entwicklers auf Basis eines konkreten Projekts. Es ist sozusagen ein primitiver, verteilter Ansatz - der auch ganz gut dazu passt, dass Duality Open Source ist und jeder seinen eigenen Fork davon verwalten kann. Ansonsten ist Duality einfach noch viel zu jung, um sich durch Zentralisierung auf die Garantie der Rückwärtskompatibilität festzulegen. Da wird sich noch eine Menge ändern, idealerweise zum Positiven :)

Ein Seiteneffekt davon, den ich persönlich sehr schätze: Es ist weder für Spiele noch für den Editor eine Installation nötig, es liegt ja sowieso alles im entsprechenden Ordner.
* Hast Du irgendwo Deine Roadmap dokumentiert? Also außer die Issue page auf github.
Ganz grob kannst du das hier nachlesen. Was die vergangene Entwicklung angeht, hab ichs leider nicht genauer, sorry :) Für die Zukunft gibt es keine in Stein gemeißelte Roadmap. Sollten sich größere Dinge ankündigen, könnte sich ein Blick auf meinen Blog lohnen, aber auch hier existiert leider kein konkretes Dokument, wo man sich schnell über die kommenden Planungsjahre informieren kann.

Zitat

* Ich fand es immer schon eine große pain, größere Projekte in Unity zu handln. Diese ganzen Objekt- und Parameterlisten sind ein graus wenn man Sourcecode gewöhnt ist. Von Nachvollziehbarkeit von Änderungen ganz zu schweigen. Hast Du eine Idee oder ein Konzept dies besser zu machen? Wie kann man zb. gescheit mit dem Editor und Git zusammenarbeiten (mehrere Personen beteiligt) ? Ich denke hier konkret daran....in der jetzigen Phase der Entwicklung die Zusammenarbeit von mehreren Personen an einem Projekt in den Fokus zu rücken.



Sprichst du von einer Integration von Git oder SVN direkt in den Duality Editor? Das würde ich gerne vermeiden, da ich kein spezifisches System zur Versionskontrolle bevorzugen will.


Prinzipiell ist es aber durchaus möglich, ein Duality Projekt innerhalb eines Teams zu entwickeln, es hindert dich ja niemand daran, den Projektordner in ein Repository zu packen. ^^ Wenn man dazu als Ressourcenformat XML wählt, dann lassen sich eventuell entstehende Konflikte auch recht gut mergen, speziell diesem Thema hab ich einige Änderungen im Serialisierungsmodul von Duality gewidmet. BatCat hatte da anfänglich einige Probleme, die aber mittlerweile Geschichte sind.


Sollten in Zukunft nochmal Probleme auftreten, oder dringende Featurewünsche existieren, bin ich dafür natürlich offen - Duality soll auf jeden Fall auch in Entwicklerteams funktionieren.
* Spricht etwas gegen die Integration von Scriptsprachen...zb. Lua?
Ich persönlich würde die Einführung einer zweiten Sprache als unnötige Verkomplizierung empfinden. Was spricht dagegen, in C# zu scripten? ^^


Klar, was man sich natürlich überlegen könnte, wäre der Support von C# Scripten, damit man sich kein CorePlugin als Scripte-Container anlegen muss. Das könnte man dann noch mit Convenience Methoden und Helferklassen verfeinern. Allerdings hab ich bisher noch nie den Fall gehabt, dass ich wirklich Skripte als solche gebraucht hätte, und meist gab es akut wichtigeres zu tun. Ansonsten spricht aus meiner Sicht aber nix dagegen.




Hoffe, ich konnte ein wenig Licht in die Sache bringen :)

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Fetze« (31.01.2014, 16:18)


SiENcE

Frischling

Beiträge: 16

Wohnort: Berlin

  • Private Nachricht senden

76

31.01.2014, 17:19

Danke für die schnelle Antwort.


  • Ich habe selbst weder Testsystem noch Kapazitäten, Duality auf Mac und Linux zum Laufen zu bringen. Hier bräuchte ich Hilfe von außen, würde mich da also über jedwede Experimente deinerseits oder von anderen Helfern freuen :)
  • Der Editor ist nicht ganz so plattformunabhängig und krallt sich über die eine oder andere Dependency in der WinAPI fest. Hier müsste Portierungsarbeit betrieben werden.
Prinzipiell muss man den Editor jedoch nicht portieren, damit man Duality Spiele auf anderen Systemen spielen kann.


Prinzipiell habe ich Erfahrung mit .Net -> Mono Ports mit OpenTK. Auf Sony PSM und Windows Phone 7.5 habe ich auch schon portiert. Im Moment bin ich leider ziemlich gefangen in einem größeren Projekt...ich werde mich aber nebenbei ein bisschen in den Duality Code einarbeiten.

Letzteres kommt daher, dass Duality sich in stetiger Entwicklung befindet und vollständige Rückwärtskompatibilität nicht gewährleistet werden kann. Das wiederum ist der Grund für das Konzept des projektlokalen Editors, welches sicherstellt, dass jedes Projekt auch in Zukunft weiter funktioniert.


Für diese Phase ist das okay...aber auf lange Sicht würde ich mir da ein Konzept überlegen. Stell Dir vor ein Nutzer beginnt ein Spiel zu entwickeln...und hat einen Bug...Du bugfixt den Bug aber der Nutzer kann nichts damit anfangen, da er ja nur den alten Editor benutzen kann. Somit wären Engine updates für die Katz.

Eine Lösung wären hier vielleicht ein Migrationstool oder eine Import Funktion.


Sprichst du von einer Integration von Git oder SVN direkt in den Duality Editor? Das würde ich gerne vermeiden, da ich kein spezifisches System zur Versionskontrolle bevorzugen will.


Oh nein...ich meinte nicht in Duality integrieren. Ich spreche davon, den Projektordner unter git oder svn Kontrolle zu stellen, damit ich Änderungen einchecken und ein anderer sich die Änderungen ziehen kann. Hier ist es natürlich auf lange Sicht problematisch, an eine Duality Version zu binden (siehe oben).


Prinzipiell ist es aber durchaus möglich, ein Duality Projekt innerhalb eines Teams zu entwickeln, es hindert dich ja niemand daran, den Projektordner in ein Repository zu packen. ^^ [/size]Wenn man dazu als Ressourcenformat XML wählt, dann lassen sich eventuell entstehende Konflikte auch recht gut mergen, speziell diesem Thema hab ich einige Änderungen im Serialisierungsmodul von Duality gewidmet. BatCat hatte da anfänglich einige Probleme, die aber mittlerweile Geschichte sind.


Kannst Du irgendwo dokumentieren...wie man in Duality im Team mit SVN/Git arbeiten kann und worauf man zu achten hat?


Ich persönlich würde die Einführung einer zweiten Sprache als unnötige Verkomplizierung empfinden. Was spricht dagegen, in C# zu scripten? ^^
Klar, was man sich natürlich überlegen könnte, wäre der Support von C# Scripten, damit man sich kein CorePlugin als Scripte-Container anlegen muss. Das könnte man dann noch mit Convenience Methoden und Helferklassen verfeinern. Allerdings hab ich bisher noch nie den Fall gehabt, dass ich wirklich Skripte als solche gebraucht hätte, und meist gab es akut wichtigeres zu tun. Ansonsten spricht aus meiner Sicht aber nix dagegen.


Ich wollte ja nur wissen ob prinzipiell was dagegen spricht :). Mir schwebt da vor, Objekte direkt im Editor mit Funktionen zu unterlegen, die von der Engine getriggert werden. Also direkt im Editor die Objekte scripten. ZB. für Leute ohne VisualStudio, für einfach Dinge wie Dein Platformer Demo. Dort könnte man das Character Objekt direkt im Editor scripten..ohne den Umweg über Plugin und VS gehen zu müssen.

Also ala:

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Object:new()
end

Object:update()
end

Object:draw()
end

Object:keypressed()
end

Object:keyreleased()
end

Object:quit()
end

usw.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »SiENcE« (31.01.2014, 17:58)


77

31.01.2014, 19:06

Hm, ich glaube das Binden an eine Duality-Version ist bei dir ein wenig zu statisch angekommen. Natürlich ist das von Vorteil, um zu verhindern, dass ein zwei Jahre altes Projekt nicht plötzlich kaputt ist, bloß weil man sich ein Update gezogen hat - so ist es ja gedacht. Es ist aber auf der anderen Seite eine Sache von zwei Minuten, ein solches Update auf ein spezifisches Projekt manuell anzuwenden: Neue Binaries laden, in den Projektordner entpacken (alles überschreiben), die Plugins neu kompilieren, fertig. Einem manuellen Update steht also nichts im Wege - nur dass man es eben für ein konkretes Projekt durchführt, und nicht für die Umgebung an sich :)

Was das Scripting angeht, verstehe ich jetzt besser, was dir genau vorschwebt - allerdings bin ich mir noch unsicher, in welche Richtung ich mit Duality hier gehen will.

Was ich definitiv nicht anstrebe ist die Erschaffung eines "Game Makers", also eines reinen Tools, wo Neulinge sich schnell was zusammenklicken können. So ist das alles nicht gedacht, und dieses Ziel sollten eventuelle Scripte in Duality auch nicht haben. Es geht nicht darum, einen Editor zu basteln, welcher den Source Code ersetzt, und dementsprechend sollte er auch keine Verantwortlichkeiten übernehmen, die eindeutig beim Source Code liegen. Dennoch kann es von Vorteil sein, einem Gamedesigner ohne wesentliche Programmierkenntnisse zu ermöglichen, Objektverhalten zu implementieren - das sollte man nicht vergessen.

Was ich mir vorstellen könnte, wären Scripte als eine Möglichkeit, einzigartiges Verhalten von Objekten abzubilden: Es gibt ja doch eine Menge Objekte, welche nur einmal auftreten, oder vordefinierte Abläufe, die nur einmal gebraucht werden, beispielsweise Zwischensequenzen. Dafür wären Scripte eine sehr gute Lösung. Ich bin mir allerdings noch nicht sicher, welche Form diese annehmen würden, oder auf welche Weise diese vom Nutzer zu editieren wären. Denkbar wären:
  • Scripte als spezielle Klassen (neben Components), welche ebenfalls per (ggf. separatem) CorePlugin definiert werden und entsprechend angepasste Funktionalität mitbringen. Eine vordefinierte ScriptComponent würde als Host dienen und ein Script auf einem Objekt ausführen.
  • Scripte als rein datengetriebene Abläufe, welche im Editor per (erweiterbarem) Baukastensystem zusammensetzbar sind. Ein Script wäre dann eine neue Art von Resource. Eine oben beschriebene ScriptComponent würde auch hier als Host dienen.
Derzeit favorisiere ich keinen der beiden Ansätze, sie haben beide so ihre Vor- und Nachteile, und sicherlich gibt es auch eine Menge Zwischenlösungen, die man in Erwägung ziehen könnte. Alles in allem ist Scripting aber derzeit kein aktuelles Thema in der Entwicklung von Duality.

Edit: Achja, fast vergessen, die Sache mit der Versionskontrolle. Da gibt es nichts spezielles zu beachten, eigentlich: Projektordner ins Repository und gut. Man kann drüber nachdenken, bestimmte Files auf ignore zu setzen, beispielsweise editoruserdata.xml, oder den Source/Media Unterordner, aber alles in allem ist sowas Geschmackssache. "Common Pitfalls" sind mir jedenfalls nicht bekannt.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Fetze« (31.01.2014, 19:16)


SiENcE

Frischling

Beiträge: 16

Wohnort: Berlin

  • Private Nachricht senden

78

03.02.2014, 14:03

Ich gehe davon aus, dass jemand vor einem Update ein Backup macht :). Deswegen würde ich nicht meine Entwicklungsstrategie darauf anpassen.
Allein wenn ich zwei kleine Testprojekte habe...und Duality anpasse...will ich mich doch nicht darum kümmern, die Binaries in allen Projekten immer aktuell zu halten.

Dein Ansatz von Entwickler 'unterstützendem' Editor ist ziemlich praktisch. Das Du kein klicki-bunti machen willst ist mir schon klar ;).

Zum Scripten:
Die erstere Variante hört sich so ungefähr danach an was mir vorschwebte. Eigentlich meinte ich nur eine Verknüpfung von Script-'Methoden' mit Objekten über den Editor.

btw. Was ist denn der Projektordner? Data und Source?

79

03.02.2014, 14:16

btw. Was ist denn der Projektordner? Data und Source?
Der Root-Ordner, in dem sich auch die Binaries befinden. Nachtrag zur Versionskontrolle: Nicht vergessen, das bevorzugte Datenformat im Editor auf XML zu stellen, sonst haben die meisten Systeme Schwierigkeiten mit dem Mergen von Ressourcen. Sollte aber standardmäßig so eingestellt sein.

80

22.05.2014, 15:43

Über fünf Monate seit dem letzten Update, und eine Menge Neuerungen - Zeit, den alten Thread mal wieder zu entstauben!

Highlights

Gamepad Support

Zusätzlich zum bereits existierenden Joystick Support, ist nun dank OpenTK 1.1 ein verbesserter Zugriff auf Gamepads möglich. Diese sind zwar weiterhin auch allgemein als "Joysticks" registriert, aber darüber hinaus per Gamepad-API wesentlich besser ansteuerbar. Was im alten Modell lediglich eine je nach Modell unterschiedliche Ansammlung undefinierter "Buttons" und "Achsen" war, kann nun explizit über Left/RightThumbstick/Trigger und benannte Buttons abgefragt werden.

Visual Logging

Zum Debugging und für sonstige diagnostische Aufgaben können sich Konsolenausgaben als sehr nützlich erweisen. Einige Informationen - Positionen, Areale, etc. - sind allerdings nur schwer in Textform zu kodieren, ohne dabei unübersichtlich zu werden. Diese Lücke soll das neue Visual Logging füllen, welches seit geraumer Zeit zusätzlich verfügbar ist. Genau wie Log.Game.Write("...") und Konsorten können Visual Logs jederzeit und von jedem beliebigen Punkt im Code aufgerufen werden. Da jedes davon standardmäßig nur ein Frame anhält, entfällt auch jegliche manuelle Verwaltung:

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Draws a point on screen at 100, 100
VisualLog.Default.DrawPoint(100, 100);

// Draws a point at world coordinate zero
VisualLog.Default.DrawPoint(0, 0, 0);

// Draws a point at object coordinate zero of GameObject "someGameObject"
VisualLog.Default.DrawPoint(0, 0, 0).AnchorAt(someGameObject);

// Draws a red point on screen at 200, 100
VisualLog.Default.DrawPoint(200, 100).WithColor(ColorRgba.Red);

// Draws a green point on screen at 300, 100 and keeps it alive for one second.
// A new one will be generated with each call, so this is obviously intended for
// specific events, rather than being called each frame.
VisualLog.Default.DrawPoint(200, 100).WithColor(ColorRgba.Green).KeepAlive(1000.0f);

Neben einfachen Punkten wie im obigen Beispiel gibt es auch eine Reihe weiterer Primitives:

C#-Quelltext

1
2
3
4
5
6
7
VisualLog log = VisualLog.Default;
log.DrawPoint(...);
log.DrawVector(...);
log.DrawConnection(...);
log.DrawCircle(...);
log.DrawPolygon(...);
log.DrawText(...);

Es ist bei Bedarf auch möglich, eigene Primitives zu definieren. Oder aber mehrere Logs, von denen jedes einzeln konfiguriert werden kann:

C#-Quelltext

1
2
3
4
5
6
VisualLog logA = VisualLog.Get("A");
logA.VisibilityGroup = VisibilityFlag.Group2;
logA.BaseColor = ColorRgba.Green.WithAlpha(0.5f);

VisualLog logB = VisualLog.Get("B");
log.B.Visible = false;

Hier mal einige besagter Primitives in Aktion. Die Duality-Logos sind echte Objekte im Raum, alles andere wurde per VisualLog draufgemalt:

(Link)


Man sollte aber im Kopf behalten, dass Visual Logging wirklich nicht als schnelle Möglichkeit, Ingame Formen zu malen, sondern zum Testen und Debuggen. Mittlerweile hab ich das Visual Logging selbst schon bei einigen Gelegenheiten eingesetzt und würde nicht mehr drauf verzichten wollen - und sei es auch nur, um mal schnell ein paar aktuelle Variablenwerte auf den Screen schreiben zu lassen. ^^

Große Aufräumaktion

Code hat die unpraktische Eigenschaft, mit der Zeit zu altern und graduell an Qualität einzubüßen. Einige Dinge waren aber auch einfach von Anfang an nicht so angelegt, wie ich das gerne gehabt hätte - also stand eine größere Refactoring-Aktion an. Diese lässt sich wohl am besten in einigen Stichpunkten beschreiben:

  • Die allmächte CorePluginRegistry Klasse im Editor existiert nicht mehr. Sie diente dazu, Typen mit Meta-Informationen für den Editor auszustatten, wie beispielsweise ihre XML Dokumentation, ein schickes Icon, Aktionen für Menüleisten, und so weiter. All diese Aufgaben werden jetzt entweder automatisch per Reflection erledigt, oder aber deklarativ per Klassenattribut ausgeführt, ähnlich dem bereits vorher existenten EditorHint-System.
  • Eingebettete Ressourcen befinden sich nun in jedem Projekt im EmbeddedResources Ordner. Keine Sonderbehandlung mehr für jedes Plugin einzeln.
  • Der DualityEditor namespace heißt jetzt Duality.Editor.
  • Der DualityLauncher namespace heißt jetzt Duality.Launcher.
  • Alle Plugin namespaces heißen jetzt Duality.Plugins.XY bzw. Duality.Editor.Plugins.XY.
  • Duality.ColorFormat und Duality.VertexFormat wurden zu Duality.Drawing fusioniert. Zusätzlich wurden einige Klassen (Canvas, DrawDevice, etc.) dorthin verschoben.
  • Das bisherige Standard-Editorplugin "EditorBase" wurde in modulare Einzelplugins aufgeteilt: CamView, LogView, SceneView, ProjectView und ObjectInspector sind nun einzelne Editorplugins, die keinerlei Abhängigkeiten untereinander aufweisen und unabhängig voneinander ausgetauscht werden können, falls jemand lieber seine eigenen Kreationen verwenden will. Das EditorBase Plugin enthält nun lediglich allgemeine Dinge wie PropertyEditor- und DataConverter Klassen.
  • Seitens des Serialisierungssystems wurde ebenfalls stark vereinfacht: Die komplette MetaFormat API wurde aus Duality entfernt. Es existieren nun lediglich die drei Klassen Formatter, XmlFormatter und BinaryFormatter, anstelle der komplexen Klassenhierarchie zuvor. Das ganze ist so deutlich Erweiterungsfreudiger, sollte jemand sein eigenes Datenformat verwenden wollen (JSON anyone?)
  • Alle Dependency-projekte wurden aus dem Repository entfernt und in eigene Repositories ausgelagert, welche als Submodules verknüpft wurden.
  • Sämtliche WinForms Controls, die ich speziell für Duality geschrieben habe (PropertyGrid, ColorPicker, ...) wurden ebenfalls in ein eigenes Repository ausgelagert und können gerne für andere Projekte genutzt werden.

Verbessertes PropertyGrid

Das PropertyGrid wurde in verschiedener Hinsicht verbessert. Die vermutlich wichtigste Änderung ist das Ableiten von Typinformationen direkt aus den bearbeiteten Objekten, und nicht anhand der Referenzen, mit denen auf diese Objekte verwiesen wird. Nehmen wir beispielsweise an, ein Property vom Typ object[] wird im PropertyGrid bearbeitet: Da sämtliche Typinformationen aus der Referenz abgeleitet werden, wird das dargestellte Array zwar Objekte enthalten, aber uns diese nur als Objekte (bzw. "object" Instanzen) bearbeiten lassen - auch wenn es sich in Wirklichkeit beispielsweise um Strings, Integer, oder ganz andere Objekttypen handelt. In der neuen Version des PropertyGrids werden diese Informationen beachtet, da jedes Objekt einzeln nach seinem konkreten Typ gefragt wird, um einen spezifischeren Editor zur Verfügung stellen zu können.

Neue Helferklassen

Generische Operatoren

Die statische GenericOperator Klasse erlaubt mathematische Operationen mit generischen Typen - was in C# rein auf Sprachebene nicht erlaubt, aber in bestimmten Situationen dennoch unglaublich praktisch ist. Ein Beispiel:

C#-Quelltext

1
2
3
4
5
public T GiveMeTheSum<T>(T first, T second)
{
    // Okay, let's do this!
    return first + second; // Bam! Compiler error :(
}

Weil der Compiler für beliebige Typen nicht annehmen kann, dass arithmetische Operationen möglich sind, ist es nicht möglich, diese in generischen Methoden zu nutzen. Auch where-Klauseln helfen da leider nicht, und Implementierungsvorschriften wie IComparable vorauszusetzen ist nicht immer praktikabel und deckt auch nicht alle Fälle ab. Wenn man nun beispielsweise eine generische Klasse definieren will, die ohne Copy'Paste mit beliebigen Zahlentypen arbeiten kann (int, float, double, ...) wird man ein wenig tricksen müssen - und dabei hilft nun die GenericOperator Klasse:

C#-Quelltext

1
2
3
4
5
public T GiveMeTheSum<T>(T first, T second)
{
    // Okay, let's do this!
    return GenericOperator.Add<T,T>(first, second);
}

Diese generiert den für die gewünschte Operation benötigten Code dynamisch zur Laufzeit als Expression Tree, kompiliert ihn, packt ihn in ein Delegate und ruft dieses dann intern auf. Nach einmaliger Codegenerierung ist der Overhead dann auch nicht mehr größer als zwei Methodenaufrufe und ggf. zwei bis drei Type Casts. Was das Prinzip der generischen Operatoren angeht, ahbe ich mich > hiervon < inspirieren lassen.

Animationen

Eine konkrete Anwendung findet die eben erwähnte GenericOperator Klasse zum Beispiel in einem Satz aus Helferklassen für die Animation von Properties und Feldern. Ein Anwendungsbeispiel:

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SpriteRenderer sprite = ...;
Transform transform = sprite.GameObj.Transform;

// So we have this sprite. Let's animate it's coloring over time!
IPropertyAnimation colorAnim = PropertyAnimation.Create(sprite, () => sprite.ColorTint, new AnimationTrack<ColorRgba>
{
    { 0.0f, ColorRgba.Red },
    { 1.0f, ColorRgba.Green },
    { 2.5f, ColorRgba.Blue },
    { 5.0f, new ColorRgba(255, 128, 0) },
    { 8.0f, ColorRgba.Red }
});

// To run the animation, just make sure to update its Time property each frame.
colorAnim.Time += howFastItShouldRun * Time.TimeMult;

Insgesamt handelt es sich bei besagten Klassen derzeit allerdings eher um ein experimentelles Gimmick, um mal schnell für ein wenig Bewegung zu sorgen.

RawList Klasse

Zur Speicherung einer einfachen Abfolge von Werten oder Objekten gibt es im .Net Framework zwei naheliegende Kandidaten: Arrays und List<T>. Bekanntermaßen ist letzteres ein Wrapper um ein Array, welcher sich um die automatische Vergrößerung und Handhabung dessen kümmert, sollte man nachträglich Elemente einfügen oder entfernen wollen. Ein Array ist da deutlich weniger pflegeleicht, weswegen meist die Liste verwendet wird, sobald eine dynamische Anpassung gewünscht ist. Größter Nachteil: Zugriffe erfolgen nur über einen Index-Operator, was für zusätzlichen Overhead durch herumkopieren von Elementen sorgt:

C#-Quelltext

1
2
3
4
5
6
7
8
List<Vector3> vecList = ...

vecList[0].X = 10.0f; // Can't do that, because vecList[0] returns a copy of the element, since Vector3 is a value type.

// Need to do this:
Vector3 vec = vecList[0]; // Function call & copying data
vec.X = 10.0f; // Assignment
vecList[0] = vec; // Function call & copying data

Bei der Handhabung großer Datenmengen, beispielsweise von komplexen Vertexdaten oder CPU-Partikeln, schadet das der Performance. Deswegen gibt es in Duality die RawList<T>. Macht genau dasselbe wie List<T>, implementiert dieselben interfaces und die wichtigsten Methoden - erlaubt aber den direkten Zugriff auf das interne Array.

C#-Quelltext

1
2
3
4
5
6
RawList<Vector3> vecList = ...

// Let's gain direct access.
Vector3[] data = vecList.Data;

data[0].X = 10.0f; // Such works. So greatness.


Zweidimensionale Daten: Grid<T>

In Vorbereitung für Erweiterungen wie Tilemaps und Co gibt es eine neue Helferklasse für 2D-Grids beliebigen Typs. Ein Auszug aus dem Unit Test beschreibt die Funktionalität vielleicht am besten:

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Grid<int> grid = new Grid<int>(2, 2);
grid[0, 0] = 0;
grid[1, 0] = 1;
grid[0, 1] = 2;
grid[1, 1] = 3;

Assert.AreEqual(4, grid.Capacity);
Assert.AreEqual(2, grid.Width);
Assert.AreEqual(2, grid.Height);
CollectionAssert.AreEqual(new[] { 
    0, 1, 
    2, 3 }, grid);

grid.Resize(4, 4, Alignment.Center);
Assert.AreEqual(16, grid.Capacity);
Assert.AreEqual(4, grid.Width);
Assert.AreEqual(4, grid.Height);
CollectionAssert.AreEqual(new[] { 
    0, 0, 0, 0,
    0, 0, 1, 0,
    0, 2, 3, 0,
    0, 0, 0, 0 }, grid);

grid.ShrinkToFit();
CollectionAssert.AreEqual(new[] { 
    0, 1, 
    2, 3 }, grid);


Sonstige Änderungen

  • Es ist jetzt per DualityUserData möglich, anzugeben ob VSync aktiv sein soll oder nicht.
  • Einige Newbie-Fallgruben entfernt: Die erste Szene eines neuen Projekts wird nun automatisch mit einem Camera-Objekt initialisiert. Wird eine Szene gespeichert, ohne dass eine Startszene definiert wurde, wird die neu gespeicherte Szene als solche angenommen. So kann man einen frisch heruntergeladenen Editor starten, auf Play drücken und direkt was sehen.
  • Neue Zeichenfunktionen für die Canvas Helferklasse.
  • Beim Canvas sind Texturierung und Form beim Zeichnen nun entkoppelt - jede Form kann sowohl mit als auch ohne Textur dargestellt werden, je nach Material. Außerden wird nun ein einheitliches Vertexformat für alles verwendet, was das Batchingverhalten verbessert.
  • Eine Canvas Instanz kann nun mit einem CanvasBuffer ausgestattet werden, um Performance und Speicherbelastung durch Wiederverwendung deutlich zu reduzieren.
  • Neue RigidBodyRenderer Component stellt die einzelnen Shapes eines RigidBodies dar - für Test- und Debugzwecke.
  • Via explizitem EditorHintFlags.Visible flag ist es möglich, private Properties anzulegen, die im Editor wie öffentliche sichtbar sind.
  • Verbesserter Support für PixelGrafik in SpriteRenderer (via AlignToPixelGrid Property) und Pixmap (via AnimFrameBorder).
  • Scene.Current ist jetzt ein readonly-Property. Zum Wechsel der Szene ist Scene.SwitchTo zu verwenden, welches den Szenenwechsel ggf. ans Ende des aktuellen Updates verlegt, um Fehlern vorzubeugen.
  • GameObjects gehören nun explizit zu genau einer Scene, welche über das entsprechende Property abfragbar ist.
  • Upgrade auf OpenTK 1.1 auf Seiten des Backends.
  • Eine Menge neuer Unit Tests für Wartungszwecke des Frameworks.
  • Jede Menge Bugfixes.
  • Entfernung von alter und ungenutzter Duality Funktionalität.

Eine kleine Spielerei am Rande

Nebenbei hab ich ein wenig mit einem Spielkonzept herumexperimentiert, das mir im Kopf herumschwirrte. Das ganze ist mittlerweile schon wieder überholt, aber ehe es auf meiner Festplatte versumpft, nehme ich es einfach mal in diesen Beitrag auf ^^ Es geht dabei im Wesentlichen um ein Magiesystem, welches es dem Spieler erlauben soll, eigene Zauber zuschreiben. Das ganze hat es bis in den Zustand eines (sehr!) frühen Prototyps geschafft und ist > hier < mit kompletter Beschreibung und Downloadlink verfügbar.


(Link)

(Link)


Das ganze wurde mit einer nicht mehr aktuellen Duality Version entwickelt - für eigene Projekte also bitte neu herunterladen.

Weiteres

Aktuelle Duality Version (Binaries): > hier <
Aktuelle Duality Version (Source Code): > hier <



Feedback, Fragen und Anregungen sind wie immer willkommen.

Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von »Fetze« (22.05.2014, 15:48)


Werbeanzeige