Beiträge von Andy

  • Tutorial AutoIt und Assembler UPDATE 24. Oktober 2010 Verwendung von Autoitvariablen im Assemblercode

    Beispiel für Übergabe und Rückgabe von Parametern an/von einer AutoItfunktion aus dem Assemblercode

    Anbei ein Beispiel, wie man aus dem Assembler sehr einfach AutoIt-Funktionen aufrufen kann, und natürlich auch die Rückgabe dieser Funktionen auswerten kann.
    Das kann man u.a. natürlich sehr schön zum Debuggen des Assemblercodes verwenden!
    Falls man Werte/Registerinhalte innerhalb des Assemblercodes überprüfen möchte, ist das eine sehr einfache Möglichkeit!

    Spoiler anzeigen
    [autoit]

    #include <FASM.au3>
    #include <Array.au3>
    #include <MemoryDll.au3>

    [/autoit] [autoit][/autoit] [autoit]

    ;Beispiel für Übergabe und Rückgabe von Parametern an und von AutoIt-Funktionen

    [/autoit] [autoit][/autoit] [autoit]

    ;AutoItfunktion erstellen, 3 Parameter
    func _Testfunc($integer,$float,$string)
    msgbox(0,"Parameter aus dem Assemblercode", _
    "Integer: "&$integer&@crlf& _ ;INTEGER
    "Float: "&$float&@crlf& _ ;FLOAT
    "Text: "&$string&@crlf ) ;String
    return 66 ;Rückgabewert an das Assemblerprogramm
    endfunc

    [/autoit] [autoit][/autoit] [autoit]

    ;Callback-Adresse festlegen
    ;Reihenfolge der Funktionsparameter wie bei der AutoIt-Funktion
    $Func = DllCallbackRegister("_Testfunc", "int","int;float;str")

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    Dim $Fasm = FasmInit()
    FasmReset($Fasm)
    _("use32")
    _("org " & FasmGetBasePtr($Fasm))
    _("mov eax,44") ;Integer belegen
    ;Parameter an die AutoItfunktion auf den Stack pushen!
    ;Beachten, daß LIFO, der zuerst gepushte Parameter ist der letzte der Funktion!
    _("push _teststring") ;dritter Parameter der AutoIt-Testfunc bei Strings nur die Adresse!
    _("push [_float]") ;zweiter Parameter der AutoIt-Testfunc ansonsten den INHALT der Variablen
    _("push eax") ;erster Parameter der AutoIt-Testfunc
    _("call " & DllCallbackGetPtr($Func))
    ;der call bereinigt den Stack, daher KEINESFALLS POPen!
    _("shr eax, 1") ;rückgabe aus dem call in EAX shiftright 1 = geteilt durch 2
    _("ret")
    ;variablen
    _("_float dd 3.1415926")
    _("_teststring db 'Hallo, das ist ein Text',0")

    [/autoit] [autoit][/autoit] [autoit]

    ConsoleWrite(String(FasmGetBinary($Fasm)) & @CRLF)
    $Ret = MemoryFuncCall("int", FasmGetFuncPtr($Fasm))
    msgbox(0,"Rückgabe aus der AutoItfunktion","EAX / 2 = "&$ret[0])

    [/autoit] [autoit][/autoit] [autoit]

    DllCallbackFree($Func) ;Funktion freigeben
    FasmExit($Fasm)

    [/autoit] [autoit][/autoit] [autoit]

    Func _($str) ; Nur für die bequemlichkeit ^^
    Fasmadd($Fasm,$str)
    EndFunc ;==>f
    exit

    [/autoit]

  • StringRegExp überarbeiten - Bitte helfen

    Wie wäre es denn, generell "gute" Beispiele aus dem Forum (dort könnte man ggf eine eigene Abteilung einrichten) als weiterführende Links unterhalb des Beispielcodes einzusetzen?
    Weiterhin Tutorials, z.B. Seubo´s Tut zu den Regexen, BugFixens DLL-Tut, UEZ´s Beispielscripte für GDI+-Funktionen usw.

    Das würde die "deutsche" Hilfe wesentlich verbessern und gerade Einsteiger hätten durch die Links hier ins Forum sofort mehrere Beispielscripte zur Verfügung.

  • Server pakete zum Client senden lassen

    Die Sockets sind eine Verbindung zw. Server und Client.
    Somit kann ein Server eine Verbindung mit mehreren Clients haben und ein Client mit mehreren Servern verbinden. Jede Verbindung ist ein eigener "Socket"
    Auch der Server kann natürlich zum Client senden, per TCPSend() und per TCPRecv() empfangen

  • Excel, öffnen einer csv Datei mit autoit

    Ich verstehe das Problem nicht?!
    Du hast eine CSV-Datei, die von Excel ohne Probleme geöffnet wird, wenn die von BugFix beschriebenen Feldtrenner eingefügt sind.
    Wieso fügst du die fehlenden Feldtrenner nicht per AutoIt in die CSV ein bzw machst die CSV Excel-tauglich?
    Sollten doch nur eine Handvoll Zeilen Code sein....

  • probleme mit filegetpos

    @veal19
    lies dir mal in der Hilfe durch, was FileGet/SetPos eigentlich macht. Es wird idR dazu verwendet Dateien direkt auf Platte zu bearbeiten, ohne den kompletten Dateiinhalt einzulesen.
    Wenn du sowieso mit Filereadline die Zeile einliest, wozu brauchst du dann FileGetPos?

  • Assembler Hilfe-Thread

    @Marsi
    Im Examples-Order des FASM-Paketes sind einige Beispiele, mE. auch für den 64-Bit-Mode, ansonsten bei FASM auf der Homepage.
    Sowohl 32- als auch 64-Bitprogramme greifen über die Include-Dateien auf fast die gesamte Windows-API zu. Am Präfix der includierten Datei erkennt man den Anwendungsbereich.
    Weil, wie gesagt, die gesamte Windows-API zur Verfügung steht, muss man keine grossen Klimmzüge machen, um z.B. Fenster zu erzeugen. Schau dir einfach mal die Beispiele an, für Windows lassen sich Programme wesentlich einfacher als für DOS erstellen.

    Zitat

    Autoit ist ja teils über Tausendfach langsamer und C#/C++ liegt auch in fast allen Fällen um mehr als das 10-100 Fache hinten.

    Wobei man fairerweise sagen muss, das die gängigen C++Compiler schon sehr nah am Optimum arbeiten! Aber es gilt wie überall auf der Welt, man kann aus Sch*** kein Gold machen! Das heisst im Klartext, wer im Vorfeld weiss, was der Compiler aus dem Code macht und entsprechendes Know-How hat, der kann auch mit C++ extrem schnellen Maschinencode erzeugen. Wer da Interesse zeigt, dem kann ich nur die sehr guten AMD-Dokumente, u.a. dieses empfehlen.

    Das gilt übrigens und gerade auch für den Assembler! Ich bin sicher, dass die allermeisten C++Compiler aus gutem bis mittelmäßigem C++Code schnelleren Maschinencode fabrizieren als mittelmässige Assemblerprogrammierer!

  • QuickDraw 100mal so schnell wie GDIPlus Update10 Texture speichern / Screencap

    War mein Fehler, sollte Faktor 10 höher sein, und war mit Füllen eines Arrays, aber die Richtung wo ich hinwollte sollte rausgekommen sein^^
    Für mehrere ineinandergeschachtelte Schleifen mit Berechnungen im "inner Loop", will sagen "Numbercrunching", ist AutoIt einfach nicht gemacht. Dafür gibts ja die exzellente Anbindung mit Objekten, Dll´s und wers wirklich hardcoremässig braucht, einem embedded Assembler^^

  • Tutorial AutoIt und Assembler UPDATE 24. Oktober 2010 Verwendung von Autoitvariablen im Assemblercode

    Einsatz von SSE/SSE2 Befehlen am Beispiel Tunnelflug

    Neben MMX und 3DNOW gibt es in den neueren Prozessoren eine ganze Reihe Befehle um SIMD (SingleInstructionMultipleData) anzuwenden. Auch im 32-Bit-Modus können bis zu 8 Register XMM0-XMM7 mit jeweils 128Bit Breite angesprochen werden. Der 64-Bitmodus erweitert die Anzahl der Register noch einmal beträchtlich. Ich verwende die Datenblätter und Manuals von AMD, für interessierte gibts gerade im Bereich Optimierung dort sehr lesenswerte Sachen.
    Als Nachschlagewerk für das vorliegende Programm empfehle ich http://support.amd.com/us/Processor_TechDocs/26568.pdf

    Ich bleibe beim folgenden Beispiel im 32-Bitmodus und verwende dabei einige der SSE/SSE2-Befehle. Das gute an SIMD ist,es werden mit einem Befehl mehrere Daten verändert.
    Ein schönes Beispiel ist PMADDWD, welcher in der Lage ist, 8 Multiplikationen und 4 Additionen auf einmal durchzuführen.

    Was heisst mehrere Befehle auf einmal?
    Nun, wir können ein 128 Bit breites Register in verschiedenen Varianten nutzen, als dqword mit 128 bit, oder als 2er Gruppe mit je 64 Bit, als 4er Gruppe mit je 32 Bit, 8x16Bit, oder 16x8 Bit. Man kann die Registerinhalte als Floatingpoint oder Integer nutzen.
    Ich benutze im vorliegenden Beispiel die XMM-Register als 4x32 Bit. Denn 1 Pixel hat 32 Bit, so kann man 4 Pixel mit einem einzigen Befehl berechnen!
    Das läuft im Prinzip so ab, daß ich die Berechnungen statt mit einem Pixel mit 4en gleichzeitig durchführe.

    Ich habe versucht, so gut wie möglich zu kommentieren, wenn man im oben angegeben AMD-Manual nachschlägt, bekommt man eigentlich eine optimale Darstellung, wie die Register miteinander verwendet werden!
    Ansonsten gilt wie immer, wenn etwas nicht verstanden wurde, nachfragen...

    Ach so...noch etwas zur Geschwindigkeit. Auf meinem Rechner wird der Tunnelflug in 500x500 mit ca.160FPS durchgeführt. Im Vergleich zum Autoit-Script ca. 4300 (viertausendreihundert) mal schneller 8o
    Auf Intel-Prozessoren sollte es noch ein gutes Stück schneller laufen...

    Ich habe die Abfrage nach dem Vorhandensein eines Prozessors mit SSE-Befehlen nicht integriert, auf einem PIII (so einen hab ich auch noch^^) läuft das Script also nicht...

    Spoiler anzeigen
    [autoit]

    #include <FASM.au3>
    #include <MemoryDll.au3>
    #include <WinAPI.au3>
    #include <WindowsConstants.au3>
    #include <StructureConstants.au3>
    #include <GDIConstants.au3>
    #include <array.au3>
    #include <GUIConstantsEx.au3>

    [/autoit] [autoit][/autoit] [autoit]

    ;Optimierung 1. Teil
    ;im folgenden Beispiel wird der Befehl FPATAN() der ca 300 Takte braucht, durch einen schnellen Zugriff auf eine LookUp-Tabelle LUT ersetzt
    ;der Geschwindigkeitsgewinn beträgt ca. x2!
    ;die lookuptabelle ist ein Array mit dem Index von 0 bis 1000 und enthält die Werte atan(0) bis atan(10)

    [/autoit] [autoit][/autoit] [autoit]

    ;Optimierung 2. Teil
    ;um die Berechnungen noch etwas zu beschleunigen werden 128 Bit breite Register der SSE-Befehlssatzerweiterung angesprochen
    ;damit kann man 4 Pixel auf einmal berechnen. Der Coprozessor wird nur noch genutzt, um per FPATAN die Lookup-Tabelle zu beschreiben

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    Opt("GUIOnEventMode", 1)

    [/autoit] [autoit][/autoit] [autoit]

    $b=500 ;Breite und höhe in pixel
    $h=500

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    If $b/4<>int($b/4) then
    msgbox(0,"Information!","Die Breite muss restlos durch 4 teilbar sein, um alignment der Daten zu gewährleisten!")
    $mod=mod($b,4)
    $b=$b+4-$mod
    endif

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    global $Fasm = FasmInit(), $FPS
    _createbytecode() ;assemblercode erstellen

    [/autoit] [autoit][/autoit] [autoit]

    ;backbuffer erstellen für die Bitmap
    local $ptr_bitmap,$hbmp_bitmap ;byref
    $hDC_bitmap=_CreateNewBmp32($b, $h, $ptr_bitmap,$hbmp_bitmap) ;DC, Pointer auf die Bitmapdaten und ein Handle für GDI+....eine eierlegende Wollmilchsau

    [/autoit] [autoit][/autoit] [autoit]

    $hgui=guicreate("",$b,$h,1,1)
    $hdc_gui=_WinAPI_GetDC($hgui)
    guisetstate()

    [/autoit] [autoit][/autoit] [autoit]

    GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit")
    adlibregister("_fps",1000) ;FramesPerSecond

    [/autoit] [autoit][/autoit] [autoit]

    $step=0.005 ;das ist die Schrittweite, um die der Tunnelflug ein Frame weiter gezeichnet wird

    [/autoit] [autoit][/autoit] [autoit]

    $struct_a=dllstructcreate("float") ;
    dllstructsetdata($struct_a,1,$step) ;zähler, wird nach jedem Frame um $step erhöht

    [/autoit] [autoit][/autoit] [autoit]

    ;$struct_ret=dllstructcreate("float") ;
    ;$struct_ret1=dllstructcreate("dword",DllStructGetPtr($struct_ret)) ;int to float

    [/autoit] [autoit][/autoit] [autoit]

    while 1;sleep(20)
    $Ret = MemoryFuncCall("int", FasmGetFuncPtr($Fasm), "int", $b,"int",$h,"float",dllstructgetdata($struct_a,1),"ptr", $ptr_bitmap)
    _winapi_bitblt($hdc_gui,0,0,$b,$h,$hDC_bitmap,0,0,$srccopy) ;bitmap in die GUI blitten
    $fps+=1
    dllstructsetdata($struct_a,1,dllstructgetdata($struct_a,1)+$step) ;zähler um step erhöhen
    wend

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    func _createbytecode()

    [/autoit] [autoit][/autoit] [autoit]

    FasmReset($Fasm)

    [/autoit] [autoit][/autoit] [autoit]

    _("use32")
    _("org " & FasmGetBasePtr($Fasm))
    _("mov eax,[esp+4]") ;breite
    _("mov [breite],eax") ;
    _("mov [invbreite+0],eax") ;
    _("mov [invbreite+4],eax") ;
    _("mov [invbreite+8],eax") ;
    _("mov [invbreite+12],eax") ;
    _("mov eax,[esp+8]") ;hoehe
    _("mov [hoehe+0],eax") ; 10
    _("mov [hoehe+4],eax") ;
    _("mov [hoehe+8],eax") ;
    _("mov [hoehe+12],eax") ;
    _("mov eax,[esp+12]") ;A1
    _("mov [va1],eax") ;
    _("mov [va1+4],eax") ;
    _("mov [va1+8],eax") ;
    _("mov [va1+12],eax") ;
    _("mov edi,[esp+16]") ;Ptr auf bitmapdaten

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    _("FINIT") ;copro init 10
    ;die Tabelle mit Werten füllen
    _("mov ecx,1000") ;tabellenlimit
    _("mov ebx,0") ;zähler tabellenindex
    ;atantabelle[ebx]=ATAN(ebx/100)
    _("_atanschleife:") ;
    _("inc ebx") ;index eins höher
    _("mov dword [atanindex],ebx ") ;index in speicher
    _("fild dword [atanindex]") ;st0=index
    _("fdiv dword[hundert]") ;st0=index/100
    _("fld1") ;st0=1 st1=index/100
    _("fpatan") ; ;st0=atan(st1/st0)
    _("fstp dword[atantabelle+ebx*4]") ;atan im atantabelle[index*4] speichern
    _("cmp ebx, ecx") ;ist limit erreicht?
    _("jne _atanschleife") ;wenn limit noch nicht erreicht, dann nächsten index
    ;lookup-tabelle gefüllt

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    _("mov esi,nulldrei") ;4 Konstanten in register packen
    _("movdqa xmm7,[esi+0]") ;nulldrei
    _("movdqa xmm6,[esi+16]") ;viernullsechs
    _("movdqa xmm5,[esi+32]") ;minuseinhalb
    _("movdqa xmm4,[esi+48]") ;breite
    _("cvtdq2ps xmm4,xmm4") ;breite von integer nach float
    _("rcpps xmm4,xmm4") ;invbreite 30

    [/autoit] [autoit][/autoit] [autoit]

    _("mov edx,0");[hoehe]") ;schleifenzähler höhe
    _("i_schleife:") ; for i=0 to h
    _("mov [vi+0],edx") ;
    _("mov [vi+4],edx") ; 40
    ;dy=($i/H)-0.5
    _("movddup xmm3,[esi+160]") ;vi-zähler in register
    _("cvtdq2ps xmm3,xmm3") ;von integer nach float
    _("mulps xmm3,xmm4") ;i/h
    _("addps xmm3,xmm5") ;i/h-0.5
    _("movdqa xmm2,xmm3 ") ;dy
    _("mulps xmm2,xmm2") ;dy^2 50

    [/autoit] [autoit][/autoit] [autoit]

    ;j-schleife
    _("mov ecx,0");[breite]") ;schleifenzähler breite
    _("j_schleife:") ;for j=0 to w
    ;dx=(j/w)-.5
    _("mov [esi+176+0],ecx") ;schleifenzähler in vj
    _("inc ecx") ;
    _("mov [esi+176+4],ecx") ;
    _("inc ecx") ;
    _("mov [esi+176+8],ecx") ;
    _("inc ecx") ;
    _("mov [esi+176+12],ecx") ;

    [/autoit] [autoit][/autoit] [autoit]

    _("movdqa xmm0,[esi+176]") ;vj-zähler
    _("cvtdq2ps xmm0,xmm0") ;von integer nach float
    _("mulps xmm0,xmm4") ;j/w
    _("addps xmm0,xmm5") ;(j/w)-0.5
    _("movdqa xmm1,xmm0") ;dx
    _("mulps xmm1,xmm1") ;dx^2
    _("addps xmm1,xmm2") ;dx^2+dy^2
    _("sqrtps xmm1,xmm1") ;sqrt
    ;dy/(dx+sqrt)
    _("addps xmm0,xmm1") ;dx+sqrt 60
    _("divps xmm0,xmm3") ;(dx+sqrt)/dy
    _("rcpps xmm0,xmm0") ;dy/(dx+sqrt)
    _("mulps xmm0,[esi+192]") ;*100
    _("cvtps2dq xmm0,xmm0") ;convert to integer (das sind die indizes!)
    _("movdqa [esi+256],xmm0") ;indizes in atanindex
    _("call _indextoatan") ;
    ;im atanindex stehen nun die atan-werte

    [/autoit] [autoit][/autoit] [autoit]

    _("movdqa xmm0,[esi+256]") ;4 atans in xmm0
    ;tu=int(407.xxx * atan)
    _("mulps xmm1,xmm7") ;sqrt/0.3
    _("mulps xmm0,xmm6") ;atan * 407

    [/autoit] [autoit][/autoit] [autoit]

    ;tv=(nulldrei / sqrt) +A1

    [/autoit] [autoit][/autoit] [autoit]

    _("rcpps xmm1,xmm1") ;0.3/sqrt
    _("cvtps2dq xmm0,xmm0") ;convert to integer (das ist tu)
    _("addps xmm1,[esi+112]") ;(0.3/sqrt)+A1
    _("mulps xmm1,[esi+64]") ;*256
    _("cvtps2dq xmm1,xmm1") ;convert to integer (das ist tv)
    _("pxor xmm1,xmm0") ;xor tu,tv
    _("pand xmm1,[esi+208]") ;and 255
    _("movdqa xmm0,xmm1") ;00 00 00 FE die Farbe

    [/autoit] [autoit][/autoit] [autoit]

    ;"Pixel erzeugen" AABBGGRR aus 000000FE soll FFFEFEFE werden
    _("movdqa xmm0,[esi+208]") ;or 00 00 00 FF Alphakanal
    _("pslldq xmm0,1") ;1 byte nach links 00 00 FF 00
    _("por xmm0,xmm1") ;or 00 00 FF FE
    _("pslldq xmm0,1") ;1 byte nach links 00 FF FE 00
    _("por xmm0,xmm1") ;or 00 FF FE FE
    _("pslldq xmm0,1") ;1 byte nach links FF FE FE 00
    _("por xmm0,xmm1") ;or FF FE FE FE

    [/autoit] [autoit][/autoit] [autoit]

    _("movdqa [edi],xmm0") ;4 Pixel in bitmap
    _("add edi,16") ;4 pixel weiter
    _("add ecx,1") ;4 Pixel weiter
    _("cmp ecx,[breite]") ;zeile ausgefüllt?
    _("jl j_schleife") ;
    _("inc edx") ;eine zeile weiter
    _("cmp edx,[hoehe]") ;alle pixel gezeichnet?
    _("jb i_schleife") ;ansonsten nächste zeile
    _("ret 16") ;Programm ende

    [/autoit] [autoit][/autoit] [autoit]

    ;*****FUNKTION, MIT CALL ANGESPRUNGEN*****************************
    ;index in atan umwandeln
    _("_indextoatan:") ;index
    _("") ;
    _("mov eax,-1") ;eax ist der zähler der indizes
    _("_naechsterindex:") ;
    _("inc eax") ;eax=eax+1
    _("mov ebx,[atanindex+eax*4]") ;index holen
    ; _("mov ebx,-30") ;zurück zum call
    ;>1000
    _("cmp ebx,1000") ;index>1000?
    _("jl kleinerminustausend") ;
    _("mov ebx,[atantabelle+4000]") ;größter index
    _("mov [atanindex+eax*4],ebx") ;float nach atanindex
    _("jmp weiter") ;
    ;<-1000
    _("kleinerminustausend:") ;
    _("cmp ebx,-1000") ;
    _("jg groessernull") ;
    _("fld [atantabelle+4000]") ;größter index
    _("fchs") ;vorzeichen auf minus
    _("fstp [atanindex+eax*4]") ;float nach atanindex
    _("jmp weiter") ;
    ;>0
    _("groessernull:") ;
    _("cmp ebx,0") ;
    _("jle kleinernull") ;
    _("mov ebx,[atantabelle+4*ebx]") ;index
    _("mov [atanindex+eax*4],ebx") ;float nach atanindex
    _("jmp weiter") ;
    ;<0
    _("kleinernull:") ;
    _("neg ebx") ;vorzeichen auf plus
    _("fld [atantabelle+4*ebx]") ;index holen
    _("fchs") ;vorzeichen auf minus
    _("fstp [atanindex+eax*4]") ;float nach atanindex
    _("") ;
    _("weiter:") ;
    ;_("ret") ;zurück zum call
    _("cmp eax,3") ;
    _("jb _naechsterindex") ;nächster index
    _("ret") ;zurück zum call
    ;*********************ENDE FUNKTION****************

    [/autoit] [autoit][/autoit] [autoit]

    ;Variablen und Konstanten
    _("align 16") ;ausrichten für sse
    _("nulldrei dd 4 dup 2.56") ;100/256 ;esi+0
    _("viernullsechs dd 4 dup 407.436661265372") ;esi+16
    _("minuseinhalb dd 4 dup -0.5") ;esi+32
    _("invbreite dd 4 dup 0.0") ;esi+48
    _("v256 dd 4 dup 256.0") ;esi+64
    _("hoehe dd 4 dup 0") ;esi+80
    _("breite dd 4 dup 0") ;esi+96
    _("va1 dd 4 dup 0.0") ;esi+112
    _("vtu dd 4 dup 0") ;esi+128
    _("vtv dd 4 dup 0") ;esi+144
    _("vi dd 4 dup 0") ;esi+160
    _("vj dd 4 dup 0") ;esi+176
    _("hundert dd 4 dup 100.0") ;esi+192
    _("i255 dd 4 dup 0xFF") ;esi+208
    _("zehn dd 4 dup 10.0") ;esi+224
    _("minuszehn dd 4 dup -10.0") ;esi+240
    _("atanindex dd 4 dup 0") ;esi+256
    _("atantabelle dd 1000 dup 0") ;array mit 1000 werten für atantabelle[atanindex]=atanvalue erstellen

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    $Binary = FasmGetBinary($Fasm) ;syntaxerror im Assembler abfangen abfangen
    ;~ If @Extended Then ;syntax-error aufgetreten
    ;~ $Error = FasmGetLastError()
    ;~ ConsoleWrite("Error Code:" & $Error[0] & @CRLF & "Error Message:" & $Error[1] & @CRLF & "Error Line:" & $Error[2] & @CRLF)
    ;~ Else ;syntax ok
    ConsoleWrite(String(FasmGetBinary($Fasm)) & @CRLF)
    filedelete("test.bin") ;assembly für externen debugger
    filewrite("test.bin",binarytostring(String(FasmGetBinary($Fasm))))

    [/autoit] [autoit][/autoit] [autoit]

    endfunc

    [/autoit] [autoit][/autoit] [autoit]

    func _fps()
    winsettitle($hgui,"",$fps&" FPS")
    $fps=0
    endfunc

    [/autoit] [autoit][/autoit] [autoit]

    Func _Exit()
    Exit
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func _($str) ; Nur für die bequemlichkeit ^^
    FasmAdd($Fasm, $str)
    EndFunc ;==>f

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    Func _CreateNewBmp32($iwidth, $iheight, ByRef $ptr, ByRef $hbmp) ;erstellt leere 32-bit-Bitmap; Rückgabe DC und ptr und handle auf die Bitmapdaten
    ;by Andy
    Local $hcdc = _WinAPI_CreateCompatibleDC(0) ;Desktop-Kompatiblen DeviceContext erstellen lassen
    Local $tBMI = DllStructCreate($tagBITMAPINFO) ;Struktur der Bitmapinfo erstellen und Daten eintragen
    DllStructSetData($tBMI, "Size", DllStructGetSize($tBMI) - 4);Structgröße abzüglich der Daten für die Palette
    DllStructSetData($tBMI, "Width", $iwidth)
    DllStructSetData($tBMI, "Height", -$iheight) ;minus =standard = bottomup
    DllStructSetData($tBMI, "Planes", 1)
    DllStructSetData($tBMI, "BitCount", 32) ;32 Bit = 4 Bytes => AABBGGRR
    Local $adib = DllCall('gdi32.dll', 'ptr', 'CreateDIBSection', 'hwnd', 0, 'ptr', DllStructGetPtr($tBMI), 'uint', $DIB_RGB_COLORS, 'ptr*', 0, 'ptr', 0, 'uint', 0)
    $hbmp = $adib[0] ;hbitmap handle auf die Bitmap, auch per GDI+ zu verwenden
    $ptr = $adib[4] ;pointer auf den Anfang der Bitmapdaten, vom Assembler verwendet
    ;_arraydisplay($adib)
    _WinAPI_SelectObject($hcdc, $hbmp) ;objekt hbitmap in DC
    Return $hcdc ;DC der Bitmap zurückgeben
    EndFunc ;==>_CreateNewBmp32

    [/autoit]

  • Autoit Debugger

    Zitat

    Dennoch, nie wieder den Debugger nutzen ...

    Falsch, normalerweise hätte dir der "Debugger" die Datei komplett zershreddern müssen, dass du mal aufwachst!
    Wer "probiert" denn irgendwelche heruntergeladenen Scripte mit Orginaldateien aus bzw legt keine Sicherungskopien an? Wahrscheinlich genau derselbe, der 3x in der Woche seinen Rechner neu aufsetzen muss, weil auf jeden Anhang in sämtlichen Spammails geklickt wird und und und...
    Heutzutage ist eine virtuelle Maschine in 15 Minuten auch von einem Laien aufgesetzt. DA gehören irgendwelche Scripte zum ausprobieren rein, und auch wegen mir die Kopien der Orginaldateien.

  • Kipp oder Wippschalter?

    Zitat

    Ich kann aber leider nicht löten

    Dann wirds Zeit^^. Das ist erstmal wesentlich billiger als irgendwelche Steckmodule, und du wirst auch unabhängiger von speziellen Bauteilen wie Netzteilen, Trafos usw.
    Beim nächsten Sperrmüll suchst du ein altes (besser uraltes) Radio (Fernseher am Anfang nicht, das kann gefährlich sein) und schlachtest alles aus, was dort auf den Platinen an Bauteilen rumschwirrt. Beim auslöten lernst du dann den Lötkolben und die verbrannten Fingerspitzen kennen, hast aber umsonst einen Haufen nützlicher Bauteile! Das kostet nichts und du kannst ohne Geld auszugeben experimentieren!
    Bald ist Weihnachten, ein Lötkolben kostet nicht viel und hat bestimmt auf jedem Wunschzettel noch Platz^^

    Zitat

    Reicht auch einfach nur ne Murmel oder so was?

    Verstehe ich nicht....Jede Schaltung braucht einen Plus- und einen Minuspol. Wenn du eine Batterie nimmst, musst du auch beide Pole anschliessen. Ansonsten einfach alles, wo GND auf dem Schaltplan steht, an Minus anschliessen.Was liefert dir denn deine Spannung für das Display?

  • TCP-Server mit Öffentlicher- oder Internen IP??

    Zitat

    Tauschbörsen.... Kazzaa... da wird eine Server-Funktion erstellt... dann müsste ich da ja auch nen port freigeben für Kazzaa

    genau so ist es^^
    Jeder Serverdienst, der von aussen erreichbar sein soll, OHNE DASS VORHER DER "SERVER" EINE VERBINDUNG AUFGEBAUT HAT ( diesen Satz 500x durchlesen und dann hoffentlich wissen was passiert^^) , muss dem Router bekanntgemacht werden.

    Diese "Pseudoserver" sind meist garkeine Server in diesem Sinne, denn sie bauen von innen nach draussen eine Verbindung auf und halten diese offen. Schickt jetzt jemand von ausserhalb eine Anfrage, dann empfängt der Router das (vermeintliche Antwort-)Paket und leitet es an den "Pseudoserver" weiter. Ein "richtiger" Server WARTET auf eine Verbindungsanfrage, er baut nicht selbstständig eine auf.

    Vorsichtig muss man nur sein, wenn freigegebene Standardports (z.B. für HTTP usw.) "mißbraucht" werden. Das ist bei fast allen Viren/Trojanern usw. so. Da die Verbindung von innen nach aussen aufgebaut wird, meckert idR keine Firewall (außer man lässt nur bestimmte Programme zu), und der Router schon mal garnicht.

  • QuickDraw 100mal so schnell wie GDIPlus Update10 Texture speichern / Screencap

    Zitat

    das sollte das problem mit der geschwindigkeit von autoit lösen.

    Naja, wie bei den von UEZ geposteten Beispielen wie z.B. Twister wird man nicht viel machen können. Generell ist es mit AutoIt schwer, Geschwindigkeit herauszuholen, da allein die Berechnungen nicht oder nur sehr schwer zu optimieren sind. Beim Primzahlen-µ-It gab es das schöne Statement "Ich weiss nicht, wie ihr auf 3,9 Sekunden kommt, bei mir dauert alleine die For/To-Schleife bis 100000 schon 3 Sekunden..." :D
    "Schnelle" Algorithmen sind nicht automatisch in AutoIt schnell. Wenn mehr Code anfällt, dann wird es eher langsamer....

    Wo OpenGl natürlich irre viel bringt, ist bei den GDI+"Spezialfunktionen", Drehen, Rotieren, Spiegeln usw...
    Auch bei der Darstellung von Diagrammen, Liniengrafiken usw. wird einiges beschleunigt werden, aber das sind dann eher Anwendungen, wo es nicht auf die letzte Millisekunde ankommt.

  • Kipp oder Wippschalter?

    GND (GrouND) bedeutet einfach nur Masse. Also in der Regel der Minuspol.
    Falls du noch nicht bestellt hast, solltest du noch eine Rolle "Kabel" (20m Klingeldraht sollte da reichen) kaufen, ein Stück in die Massepunkt(GND) Klemme des K8055 und du hast deinen "universellen" Massepunkt.
    Ist zwar schon etwas länger her als ich angefangen habe mit dem Löteisen zu experimentieren, aber Lochrasterplatinen kosten so gut wie nichts mehr und die darauf aufgebauten Schaltungen sind leichter nachzuvollziehen.
    Ein dicker, fetter Batzen Lötzinn an der Unterseite der Platine war immer mein Massepunkt, an dem dann zig Kabel zusammenliefen^^
    Nachdem ich dann Industrieroboter anlernte, feinste Lötstellen mit einer Wasserstoff-Flamme nachzulöten, wars vorbei mit den "fetten Batzen"

  • QuickDraw 100mal so schnell wie GDIPlus Update10 Texture speichern / Screencap

    Die Frage ist, ob es sich lohnt auf QD zu portieren. "Normale" Spiele mit bewegtem Hintergrund und 10-20 bewegten transparenten Sprites laufen auch mit WinAPI mit >100FPS. Also die reine Darstellung ohne Berechnung. QD löst ja das Problem der "langsamen" Rechnerei von AutoIt nicht!
    Ich habe neulich gelesen, daß auf einigen Grafikchipsätzen sämtliche 3D-Funktionen vom Prozessor emuliert werden müssen, in diesem Fall wäre QD sogar hinderlich.
    QD spielt dann seine Vorteile aus, je größer das Fenster wird. Während bei einem Bitblt dann jedes Mal der gesamte Fensterinhalt vom Hauptspeicher über den Bus in die Graka geschoben wird, erledigt OpenGl das in einem Bruchteil der Zeit.

    Mal davon abgesehen, daß es in einem Spiel völlig unüblich ist, mit den Zeichenfunktionen permanent Linien, Punkte, Kreise und Rechtecke usw. auf den Bildschirm zu "malen". Das Bewegen von Sprites ist in jedem Falle schneller, egal welches System man anwendet.

  • WinAPI Bild zeichnen

    Zitat

    Wie kann man mit WinAPI ein Bild zeichen (.jpg) ?

    Die Frage ist schon falsch :huh: , denn .jpg ist ein DATEIFORMAT!
    Man kann ein Bild zeichnen (Bitmap) und dieses dann per Kompressionsverfahren in eine .jpg-Datei abspeichern.
    Umgekehrt muss man eine .jpg-Datei erst dekomprimieren und kann diese dann als Bitmap darstellen.

    Die "Zeichen"-Funktionen beschränken sich in der WinAPI auf Linien(züge) und Rechtecke, aber auch Text und Bitmaps/icons. Allerdings ist es kein Problem, die GDI-Zeichenfunktionen einzubinden.
    Von AutoIt aus ist es relativ einfach und unkompliziert, man holt sich den DeviceContext eines Fensters, erstellt sich eine Bitmap und "blittet" (_winapi_bitblt() ) diese dann in das Fenster.
    Beispiele findet man hier im Forum, wenn man nach "Steganographie" sucht.
    Auch transparentes Blitten, oder Blitten mit Alphakanal ist machbar, es ist eine der schnellsten Funktionen zum Darstellen von Bitmaps.

    Natürlich kann man auch pixelweise "Zeichnen", man erstellt eine Struct an der Position der Bitmap und kann dann per dllstructsetdata() auf die einzelnen "Pixel" zugreifen,