[gelöst] DLL die Irrlicht.dll mit AutoIt kompatibel macht ...

Schlitzauge

Is doch Quark. Zeiger übergeben???
Man übergibt nicht an irgendwas einfach Zeiger oder führt welche aus.
Was Du eher meinst, ist Funktionen / Unterprogramme, welche sich in der DLL befinden entsprechend ihrer Aufrufkonvention(en) in und mit AutoIt-Syntax auszuführen.
Angenommen Funktion XYZ(*int,*int) aus der DLL möchte als Übergabeparameter Referenzen (Zeiger) auf int-Objekte haben, dann musst Du a.) die DLL zuerst mit AutoIt-Mitteln laden, um damit die benötigte Funktion und Ressourcen bekannt und nutzbar zu machen und b.) musste dann einfach die nun bekannte XYZ()-Funktion mit AutoIt-Mitteln (Syntax) einfach ausführen und dabei dem Funktionsaufruf die Adressen von zwei (Beispiel) passenden Objekten / Datentypen (Variablen) übergeben, also im Beispiel die Adressen von zwei INT-Variablen übergeben.
Das geht natürlich nur solange gut, wie AutoIt kompatible Datentypen zur Zielsprache der DLL besitzt (vergleichbar mit dem Aufruf und Übergabe einer C/C++-Methode in einem Pascal-Programm, auch da brauchste dann C/C++-kompatible Pascal-Datentypen, um diese dann der C/C++-Methode wie gewünscht zu übergeben).
Vermeintlich gleiche Datentypen können in verschiedenen Programmiersprachen nämlich gänzlich anders implementiert sein. Z.B. könnte der int-Datentyp in AutoIt von der Bitbreite her größer oder kleiner sein, als der im Beispiel geforderte int-Datentyp in der DLL (also der dort verwendeten Programmiersprache, z.B. C/C++).

DLL´s zu laden ist in AutoIt kein Problem, ebenso wenig dann die darin befindlichen Funktionen auszuführen, Syntax und AutoIt-Funktionen gibt es hierfür. Zeiger- und Adressen-Operatoren müsste AutoIt glaube ich ebenso besitzen. Inwieweit die Datentypen von AutoIt nun kompatibel mit den Datentypen und Datenstrukturen aus der DLL sind, kA.
Frag bzw. beles Dich dazu einfach mal in der Dokumentation der Irrlicht-API und / oder im Deutschen AutoIT-Forum (http://www.autoit.de/). Insb. im letzteren gibt es schon jede Menge AutoIt-Skripte/Bibliotheken, die anderssprachige Bibliotheken und API´s in AutoIt nutzbar machen, z.B. OpenMP.

EDIT^^*:
http://www.autoit.de/index.php?form=Search&searchID=1564252&highlight=Irrlicht

MfG

Schlitzauge

Make-Grafik

Hey, kannst du den Link bitte nochmals neu reinstellen?
Es scheint so, als würde der Link nicht existieren:
Du hast einen ungültigen oder nicht mehr gültigen Link aufgerufen.

Und jetzt mal zu diesen Textabschnitt:

Frag bzw. beles Dich dazu einfach mal in der Dokumentation der Irrlicht-API und / oder im Deutschen AutoIT-Forum (http://www.autoit.de/).

Wie du im Beitrag #1 sehen kannst, habe ich schon bereits danach gefragt. Das Ergebnis: Es ist in AutoIt so nicht möglich. Es muss dafür eine extra DLL her. Demnach habe ich also hier gefragt.

Wenn ich dich jetzt richtig verstanden habe, dann redest du von den Zeigern die ich nicht meine ... Sorry, ich kenne die Fachbegriffe nicht dafür ^^

Ich rede von diesen Zeigern, die verwendet werden um Variablen in Klassen auf zu rufen. Hier ein kleiner Beispielcode:

#include <iostream>

class klasse {
public:
	int zahl;

	klasse() {
		zahl = 10;
	};

	void output() {
		std::cout << std::endl
				  << "  " << zahl << std::endl
				  << std::endl;
	};
};

int main() {	
	klasse beispiel;
	klasse *zeiger;
	zeiger = &beispiel;

	// Start #
	zeiger->zahl = 15;
	zeiger->output();
	// Ende  #

	system("pause");
	return 0;
}

Ich habe die entsprechende Codezeile mit "Start #" und "Ende #" markiert!
Ich hoffe es ist nun verständlich worum es mir geht. In der Irrlicht.dll befinden sich solche Zeiger beim erstellen von Objekten. Und diese lassen sich mit AutoIt nicht aufrufen!

Ich hoffe das ich mein Problem nun verständlich genug beschrieben habe. Besser kann ich es nicht.

Schlitzauge

Hey, kannst du den Link bitte nochmals neu reinstellen?
Es scheint so, als würde der Link nicht existieren:
Du hast einen ungültigen oder nicht mehr gültigen Link aufgerufen.

Im Ernst, bei mir funktioniert der Link?! Es ist eine einfache Sucheingabe auf der autoit.de-Seite nach Irrlicht...^^
Liefert so einige Ergebnisse zu Irrlicht und AutoIt.

Zum Rest:
Hm, naja, Klassen- und Struktur-Objekte werden meines Wissens nach in C++ implizit über den (Standard-)Konstruktor aufgerufen.
Man könnte eine Klasseninstanz in C++ also auch so aufrufen:

Klasse();

D.h., auch hier wird letztendlich nur wieder eine Methode / Funktion aufgerufen.

ABER ich weiß jetzt was Du meinst. Das scheint mir aber ungewöhnlich für eine DLL zu sein. Dein Beispiel beschreibt nämlich das dynamische Erstellen einer Variablen (inkl. Zuweisung an Zeiger-Variable) auf dem Heap. Deshalb auch der "->"-Operator beim Zugriff auf die Instanz-Elemente in Deinem Beispiel. Statisch erzeugte Variablen (auch Klasseninstanzen) werden nämlich für gewöhnlich auf dem Stack angelegt und dann ist der Zugriffsoperator auf die Elemente der Klasse der ".".
Deshalb finde ich es komisch, dass in der DLL eine dynamisch angelegte Klasseninstanz sein soll. Für gewöhnlich funktionieren Bibliotheken und API´s wie Irrlicht so, dass in ihnen lediglich die Klassen und Strukturen, sowie Konstanten deklariert und implementiert sind, also alles statisch. Gibt es doch dynamisch zu erzeugende Objekte, dann gibt es hierfür meist eine extra Init-Methode als API-Aufruf.
Möchte man nun diese Konstanten, Datentypen, Strukturen und Klassen in anderen Sprachen, wie z.B. AutoIt nutzen, erzeugt man mit den spracheigenen Mitteln (hier von AutoIt) einfach Instanzen (Objekte) davon und kann diese direkt nutzen.

Deshalb mein Gedanke, zunächst die DLL zu laden und dann mit AutoIt-Syntax einen Struct-ähnlichen Datentyp erstellen, der den oder die Datentypen (class, struct, typedefs) aus der DLL aufnimmt. Dann sollte man eigentlich einfach auf die Klassenelemente zugreifen können. Für gewöhnlich bieten Bibliotheken / DLL´s gesetz dem Fall, dass die externe Sprache (hier AutoIt) nicht so einfach auf solche fremdsprachigen Klassenelemente zugreifen können, static/public-deklarierte Schnittstellen, um solche Objekte mittels der DLL zu erzeugen, sowie zu nutzen (Init-, Getter- und Setter-Methoden).
Schau doch einfach mal, ob Deine Irrlicht-DLL nicht einfach entsprechende API-Methoden anbietet und ob Du wirklich eine dynamische Klasseninstanz in der DLL hast.

Um welche Klasse / Objekt in der DLL gehts denn überhaupt?
Bzw., wie kommst Du darauf, dass in Deiner DLL sowas hier sein sollte:

klasse beispiel;
  klasse *zeiger;

Die Stelle würde ich ja mal gerne sehen.

Und ich denke immer noch, dass Du mit AutoIt-spezifischen Anliegen besser im deutschsprachigen AutoIt.de-Forum aufgehoben bist. Würde mir aber auch gerne ein AutoIt-Subforum in diesem Forum wünschen. Ich find AutoIt speziell für Automatisierungszwecke und auch zum Programmieren, sowie Skrippten eine tolle und mächtige Sprache. Ich dächte sogar, dass AutoIt in C# geschrieben ist...

Grüße

Schlitzauge

Make-Grafik

Hmn
Mit DLL's arbeite ich nicht so oft. Daher kann es sein das mein Wissen darüber falsch ist. Aber wie ich bereits erwähnt habe, unterstützt AutoIt kein OOP. Also ist das hier auch so nicht möglich:

Zugriffsoperator auf die Elemente der Klasse der "."

--> Demnach, gleiches Problem wie vorher auch! Kann die DLL nicht verwenden ^^

Um welche Klasse / Objekt in der DLL gehts denn überhaupt?

Ganz speziell geht es um dieses Tutorial: irrlicht.sourceforge.net/docu/example001.html
Wenn man jetzt ein wenig runter scrollt, dann kommt man zu folgenden Code auschnitt:

IVideoDriver* driver = device->getVideoDriver();
    ISceneManager* smgr = device->getSceneManager();
    IGUIEnvironment* guienv = device->getGUIEnvironment();

Und deshalb dachte ich ja, dass es in der DLL genau so verwendet wird? Bis lang musste ich mich ja um sowas nicht kümmern. Aber ich schätze ich werde hier gleich zum besseren belehrt! (Wofür ich sehr dankbar wäre!)

Jedenfalls hast du mich auch durch deinen Beitrag auf etwas hingewiesen worauf ich noch nicht geachtet habe! Ich werde jetzt erst nochmal bischen ausprobieren + googeln und freue mich auf weitere Hilfe

Vielleicht ein kleines Beispiel wie ihr das via DLL aufruf in C++ lösen würdet? Eventuell kann ich daraus auch lernen und vergleichen! Und es könnte zur Lösung meines Problemes führen.

(AutoIt wurde nach meinen Wissen in C++ geschrieben.)

Schlitzauge

Also doch, hab ichs mir doch gedacht.
Es geht primär um das aufrufen von in anderen Sprachen geschriebenen Funktionen, etwa die " createDevice()"-Funktion.

Und wie ich schon vermutet habe, gibts da auch zum Initialisieren von bestimmten Datentypen extra Init/Create-Funktionen. So erzeugt man zum Beispiel eine Instanz von IrrlichtDevice wie folgt:

IrrlichtDevice *device =
        createDevice( video::EDT_SOFTWARE, dimension2d<u32>(640, 480), 16,
            false, false, false, 0);

Die createDevice-Funktion liefert als Rückgabewert ein Objekt bzw. dessen Handle (Referenz) vom Typ IrrlichtDevice zurück und durch die Zuweisung an eine Zeigervariablen dieses Types hat man dann quasi darüber Zugriff auf diese Instanz / Variable.

Der / die Datentypen von Irrlicht, z.B. IrrlichtDevice, IVideoDriver, ISceneManager, IGUIEnvironment, etc. müssten schon in der DLL bekannt sein.
Es sind entweder Typedefs, structs oder class´s. Was genau, müsste man schon in der Irrlicht-Dokumentation nachlesen.
Sind es Klassen, musste von diesen Klassen wie im Beispiel eben Instanzen anlegen, entweder direkt oder über Zeiger-Objekte, wie im Beispiel.
Was da im Tutorial steht, ist nichts weiter als ne Anleitung, wie man Irrlicht bzw. die Funktionen in der Irrlicht-DLL verwendet. Ist aber halt C/C++-Syntax und keine AutoIt-Syntax. Es ist aber falsch, dass diese Beispiel-Anwendungen auch so in der Irrlicht-Dll stehen / Anwendung finden. Man greift wie beschrieben auf die vorhandenen Ressourcen und Funktionen zum Initialisieren, Erzeugen, Lesen und Schreiben, aus der Irrlicht-Bibliothek zurück. Z.B. kommen im Tutorial diverse Getter-Methoden zum Einsatz, um wiederum weitere Instanzen anderen Datentyps oder anderer Klassen zu initialisieren.

Was Du nun brauchst, sind die syntaktischen Befehle und Funktionen von AutoIt, um:
a.) auf Klassen und / oder Funktionen aus der Irrlicht-DLL zuzugreifen, z.B. die createDevice-Funktion. Und ...
b.) wie man auf Membervariablen und Memberfunktion der betroffenen Instanzen in AutoIt darauf zugreift.

Schau mal hier:
http://autoit.de/index.php?page=Thread&postID=300062&highlight=Memberfunktionen#post300062

Hier auch ne hervorragende Anlaufstelle zu AutoIt-Syntax und Funktionen:
http://translation.autoit.de/onlinehilfe/

MfG

Schlitzauge

PS: Zufall, dass Dein Username der selbe ist, wie im verlinkten AutoIt-Forum? ^^*

Make-Grafik

Okey, wir bewegen uns hier eindeutig im Kreis ^^
Nein, es ist kein Zufall das der Benutzername gleich ist wie der von dir verlinkte Link.

Diese Frage habe ich nämlich dort gestellt!
Schau doch mal ganz oben hier im Thread meinen ersten Post!
Dort habe ich den gleichen Link verlinkt wie du.

Soa, ich habe die Frage im AutoIt Forum bereits gestellt (siehe Link) und das Ergebnis dazu: Es ist so nicht möglich.

Demnach bin ich zu euch gekommen wegen einer DLL die auf Membervariablen und Memberfunktionen der betroffenen Instanz zugreift, weil dies in AutoIt so nicht möglich ist!

(Danke, jetzt weiß ich wieder die Fachbegriffe ^^)

Und das ist eigentlich mein Hauptproblem

Aber ich möchte dir schonmal bereits danken dass du dir Zeit für mich genommen hast und ich konnte aus deinen Post's jede Menge lernen!

[Üff, sorry Ich glaube ich verkompliziere hier alles >.<]

Schlitzauge

OK, bei structs und Arrays wäre das ja kein Problem, da man mit Hilfe von Pointern durchiterieren und so die einzelnen Member erreichen und nutzen könnte.
Bei Klassen ist das nicht so leicht, da mit private und protected ein starkes Kapselverhalten impliziert wird.

Deshalb ging ich davon aus, dass die Irrlicht-DLL für alle benötigten Klassen-Member öffentliche (public) Funktionen / Schnittstellen mitbringt, wohl aber nur als Memberfunktionen der Klassen, welche AutoIt anscheinend nicht wie C/C++ ansprechen kann.
Ohne mich darauf jetzt einzuschießen: wenn dem wirklich so ist und zusätzlich AutoIt keine Möglichkeiten bietet, auf Membervariablen-/Funktionen externer C/C++-Klassen zuzugreifen, dann gibt es eigentlich nur eine Möglichkeit:
Wrapper-Methoden.

Das ist so die übliche Vorgehensweise beim mehrsprachigen Programmieren.
Du musst dabei das Rad nicht neu erfinden. Du müsstest eigentlich nur normale Wrapper-Funktionen für die benötigten Funktionen basteln, welche selber nur Teil einer Klasse sind. Damit kannste "quasi" die "->"- & "."-Zeiger umgehen.

Beispiel einer C++-Klasse:

class Test
{
  private:
    int i;
  public:
    void seti(int value){i=value;}
    int geti(void){return i;}
};

Diese enthält nun eine nach außen hin geschützte Membervariable i.
Legt man nun eine Instanz an, kann man je nachdem mit dem "."- oder "->"-Operator auf diese zugreifen, WENN sie public: wäre. Hier ist sie aber private:. Ohne entsprechende ÖFFENTLICHE (public:) Schnittstellenmethoden (üblicherweise Getter- und Setter-Methoden) kann bzw. sollte man nicht versuchen mit Gewalt darauf zugreifen zu wollen.

Wenn AutoIt trotz verfügbarer Schnittstellenmethoden diese nicht nutzen kann, musst Du Wrapper-Methoden drumrumbauen, die man dann wieder mit AutoIt ansprechen könnte.
Bsp. bezogen auf die Beispielklasse:

void Wrapper_seti(Test *Instanz, int wert)
{
  Instanz->seti(wert);
}

int Wrapper_geti(Test *Instanz)
{
  return Instanz->geti();
}

Diese Wrapper nun in eine Bibliothek und daraus eine WRAPPER-Lib, -SO oder -DLL erstellen und in AutoIt laden.
Anders als vorher, hat man nun normale Unterprogramme, die man auch mit AutoIt direkt nutzen könnte. Man arbeitet dann nicht mehr direkt mit der Irrlicht-DLL, sondern nur indirekt über die Wrapper-DLL.

Du brauchst also lediglich nur die benötigten Memberfunktionen der Klasse zu einfach nutzbaren Wrapper-Funktionen kapseln.
Entsprechend dem Beispiel musste dann nur mit AutoIt eine Instanz / Variable der Klasse erstellen und deren Adresse entsprechend dem erstellten SET- bzw. GET-Unterprogramm übergeben.

Wie schon erwähnt (Beispiel GETI-Methode) darauf achten, dass man in AutoIt für den Rückgabetyp auf Konformität mit der Ursprungssprache (hier C/C++) achtet, ebenso bei Übergabeparameter (Beispiel SETI-Methode).

An ETWAS C/C++ wirste wohl nicht drumrum kommen.

MfG

Schlitzauge

Make-Grafik

Okey, dann möchte ich mich recht herzlich bei dir bedanken!
Vielen dank das du dir die Zeit (und auch Nerven) genommen hast dich in die Sache hinein zu lesen und auch zu verstehen was ich möchte! Du hast mir weitergeholfen und auch Themen (Die ich vorher nicht verstanden habe) näher gebracht.

An ETWAS C/C++ wirste wohl nicht drumrum kommen.

Das ist kein Problem! Ich habe so oder so vor mich mit der Sprache C++ auseinander zu setzen.

Ich möchte mich auch bei den Leuten hier bedanken, die sich dieses Thread angeschaut haben und auch versucht haben eine Lösung zu finden!

Danke ^^

MfG. Make-Grafik

hustbaer

Make-Grafik schrieb:

Hallo, ich programmiere Hauptsächlich in AutoIt (Ich bitte an dieser Stelle keine Kommentare dazu und auch keine Bekehrungen ...) und möchte die Irrlicht.dll mit AutoIt kompatibel machen.

Um "Kommentare" oder "Bekehrungen" gehts dabei nicht, dein Vorhaben macht schlicht und ergreifend keinen Sinn.
Und zwar einfach deswegen, weil es ein unheimlicher Aufwand wäre so einen "Wrapper" zu bauen. Mehr als eine Skriptsprache zu lernen die man verwenden kann um diverse Engines zu skripten (Lua oder was auch immer).

Vermutlich wäre sogar der Aufwand ein Projekt (selbst wenn es halbwegs klein ist) mit einem hypothetischen bereits existierenden Irrlicht Wrapper in AutoIt zu schreiben grösser als eine andere Sprache zu lernen + das selbe Projekt in der anderen Sprache umzusetzen.

Schlitzauge

Zu Wrappern: Nunja, um ein paar kurze Tutorials durchzuackern reichts allemale. Wirklich viel Aufwand ist nicht vonnöten. Es werden in seltenen Fällen alle Klassen, Datentypen und Funktionen aus einem eher komplexen Projekt wie Irrlicht gebraucht. Dann hält sich die Anzahl der zu erstellenden Wrapper auch in Grenzen, ergo sinkt zusätzlich der Aufwand. Natürlich wäre es vlt. schlauer, gleich mit der Originalsprache oder zumindest einer (ABI-)kompatiblen Sprache zum Projekt (z.B. Irrlicht) weiter zu arbeiten.

Ich persönlich finde AutoIt ganz praktisch und mächtig zugleich. Ich verwende es selber in meinen Projekten, aber weniger zum Programmieren, sondern zum Skripten und Automatisieren meiner Projekte und Anwendungen.