[*]Profan

Français

H.Brill

quelquefois reichen qui 15 paramètre oui pas.
siehe

oGL("gluLookAt", P1....P19)

aus qui Glu32.dll

si es technique machbar wäre, pourrait peut-être. un SET - Befehl,
qui le nombre angibt bzw. aus/einschaltet hilfreich son :

Kompilieren Marque Séparation

SET("DLLParameters", x%)
SET("DLLParameters", 0/1)

si oGL déjà cela Nutzen qui API anbietet, devrait aussi alle
Funktionen nutzbar son.

ou bien sais quelqu'un, comment on obiger oGL-Funktion encore anders
qui 19 paramètre übergibt ?

Benutze XPROFAN X3 + FREEPROFAN
Wir sind die XProfaner.
Sie werden von uns assimiliert.
Widerstand ist zwecklos!
Wir werden alle ihre Funktionen und Algorithmen den unseren hinzufügen.

Was die Borg können, können wir schon lange.

01.08.2023 ▲

Vollständiges citation

Absatzweise Citation Zeilenweise Citation

Jens-Arne
Reumschüssel

on a cela Thema en détails dans Paule's PC-Forum diskutiert - herausgekommen ist que voici. sur cet Weise laisser sich beliebig viele paramètre pour une Funktionsaufruf nutzen. vous volonté Stück pour Stück sur den Stack gepusht et ensuite wird qui Funktion aufgerufen, qui cet paramètre utilise.

Kompilieren Marque Séparation


declare _params&[],_hGluDll&,_gluLookAtFuncAddr&
declare eyeX!,eyeY!,eyeZ!,centerX!,centerY!,centerZ!,upX!,upY!,upZ!

ASM "LoopAndCall",3 'ici wird qui Parameteranzahl avec transfert et dans einer Boucle abgearbeitet
  MOV ECX,Par1 // ECX=Count-Register pour qui Boucle avec qui Anzahl paramètre im Array magasin, wird chez chaque Boucle um 1 verringert (paramètre-numéro im Array, qui paramètre doit arriéré sur den Stack gepusht volonté [FILO])
  // MOV EDX,Par2 // Offset des Array-Mémoire dans EDX magasin - pas nötig, EDX peut wir pour autre chose aufsparen (z.B. pour une Multiplikation) et stattdessen simple Par2 benutzen
  Boucle:
    MOV EAX,ECX // aktuellen Schleifenzählerstand (=Nummer des aktuellen Paramters im Array) dans EAX magasin
    SUB EAX,1 // EAX=ECX-1 (grenier-Offset im Array ist nullbasiert)
    ADD EAX,EAX // EAX=EAX+EAX --> im Endeffekt =EAX*2
    ADD EAX,EAX // EAX=EAX+EAX --> im Endeffekt zusammen avec qui la ligne devant =EAX*4 (c'est cela Offset pour den paramètre im Array-grenier)
    // so ginge qui Multiplikation aussi:
    // MOV EDX,4
    // MUL EDX // multipliziert den le contenu des EAX-Registers avec dem le contenu des EDX-Registers (4) et écrit cela Ergebnis ins EAX-Register zurück
    ADD EAX,Par2 //,EDX // Offset des Array-Speicherbereichs trop EAX dazuaddieren
    MOV EBX,EAX // Speicheradresse dans EBX écrivons (eigentlich pas nötig, mais so ist es klarer)
    MOV EAX,[EBX] // paramètre à qui Speicheradresse dans EAX magasin - es ginge aussi MOV EAX,[EAX] (avec cela serait on EBX pour autre chose aufsparen et pourrait sich qui la ligne hiervor sparen)
    PUSH EAX // paramètre sur den Stack pushen
  LOOP Boucle // ECX um 1 verringern et zurückspringen, jusqu'à 0 erreicht ist
  CALL Par3 // Funktion appel
ENDASM

cls
_hGluDll&=@usedll("glu32.dll")
_gluLookAtFuncAddr&=@external("kernel32.dll","GetProcAddress",_hGluDll&,"gluLookAt") 'Adresse qui aufzurufenden Funktion ermitteln
_params&[1]=@long(@addr(eyeX!),0)
_params&[2]=@long(@addr(eyeX!),4)
_params&[3]=@long(@addr(eyeY!),0)
_params&[4]=@long(@addr(eyeY!),4)
_params&[5]=@long(@addr(eyeZ!),0)
_params&[6]=@long(@addr(eyeZ!),4)
_params&[7]=@long(@addr(centerX!),0)
_params&[8]=@long(@addr(centerX!),4)
_params&[9]=@long(@addr(centerY!),0)
_params&[10]=@long(@addr(centerY!),4)
_params&[11]=@long(@addr(centerZ!),0)
_params&[12]=@long(@addr(centerZ!),4)
_params&[13]=@long(@addr(upX!),0)
_params&[14]=@long(@addr(upX!),4)
_params&[15]=@long(@addr(upY!),0)
_params&[16]=@long(@addr(upY!),4)
_params&[17]=@long(@addr(upZ!),0)
_params&[18]=@long(@addr(upZ!),4)
imprimer LoopAndCall(18,@addr(_params&[1]),_gluLookAtFuncAddr&) '1. paramètre: Anzahl paramètre, 2. paramètre: Adresse des paramètre-Arrays, 3. paramètre: Funktionsadresse
waitinput
freedll _hGluDll&
end

s'il te plaît verzeiht mir den Assembler-Code, j'ai encore nie (sic!) irgendetwas Sinnvolles dans Assembler zustandebekommen, quoique je es souvent versucht habe. Aus diesem Grund habe je cela so intensif et probablement très laienhaft kommentiert. Wahrscheinlich serait quelqu'un, qui sich avec cela wirklich auskennt, cela eleganter faire, mais es funktioniert.

Beste Grüße, Jens-Arne

XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de

04.08.2023 ▲

Vollständiges citation

Absatzweise Citation Zeilenweise Citation

Jens-Arne
Reumschüssel

So, et peux mir maintenant s'il te plaît irgendjemand expliquer, comme son peux, dass gluLookAt dans glu32.dll neuf *Float*-Werte comme paramètre erwartet, qui 64 bit breit sommes? chacun 32-bit-Compiler übergibt 32-bit-Werte comme paramètre sur den Stack. comment soll car quelque chose comme sans unseren mühsamen Workaround-Murks dessus s'il te plaît aller? cela peux je pas du tout begreifen.

Siehe [...]

Salut, Jens-Arne

XProfan X4
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de

04.08.2023 ▲

Vollständiges citation

Absatzweise Citation Zeilenweise Citation

Sven
Bader

aussi ici encore la fois merci pour deine tolle Assembler Funktion!

dans qui OpenGL DLL ist chacun Funktion mehrfach enthalten pour 2, quelquefois 5 Datentypen. cela sieht cela so aus:

glTranslatef() pour 32 Bit Float
glTranslated() pour 64 Bit Float

qui Funktion entspricht dem XProfan ogl("move",x,y,z)

glu scheint cet Anatz pas trop poursuivre et nimmt ensuite im Zweifel plutôt la fois Double, quoi naturellement im 3D-Kontext pas faux ist.

XProfan X4

05.08.2023 ▲

Vollständiges citation

Absatzweise Citation Zeilenweise Citation

Jens-Arne
Reumschüssel

j'ai qui ASM-Funktion pour qui verschiedenen Calling-Conventions generalisiert, sodass avec cela chacun erdenkliche 32-bit-DLL bedient volonté peux. Aussi habe je vous dans PushParamsAndCall umbenannt.

Kompilieren Marque Séparation


declare _params&[],_hGluDll&,_gluLookAtFuncAddr&
declare eyeX!,eyeY!,eyeZ!,centerX!,centerY!,centerZ!,upX!,upY!,upZ!

def &stdcall 1 'paramètre absteigend sur den Stack, Funktion bereinigt den Stack
def &cdecl 2 'paramètre absteigend sur den Stack, Aufrufer muss den Stack selbst bereinigen
def &pascal 3 'paramètre aufsteigend sur den Stack, Funktion bereinigt den Stack

ASM "PushParamsAndCall",4
  MOV ECX,Par1 'ECX=Count-Register pour qui Boucle avec qui Anzahl paramètre im Array magasin, wird chez chaque Boucle um 1 verringert (paramètre-numéro im Array, qui paramètre doit, sauf chez Pascal-Calling-Convention, arriéré sur den Stack gepusht volonté [FILO])
  MOV EDX,Par2 'Offset des Array-Mémoire dans EDX magasin (ist plus rapide comme qui Zugriff sur den paramètre, quel aussi ginge)
  MOV EAX,Par4 '1=stdcall, 2=cdecl, 3=Pascal
  CMP EAX,3
  JZ PascalSchleife
  Boucle:
    MOV EAX,ECX 'aktuellen Schleifenzählerstand (=Nummer des aktuellen Paramters im Array) dans EAX magasin
    DEC EAX 'EAX=ECX-1 (grenier-Offset im Array ist nullbasiert); SUB EAX,1 ginge aussi
    ADD EAX,EAX 'EAX=EAX+EAX --> im Endeffekt =EAX*2
    ADD EAX,EAX 'EAX=EAX+EAX --> im Endeffekt zusammen avec qui la ligne devant =EAX*4 (c'est cela Offset pour den paramètre im Array-grenier)
    ADD EAX,EDX 'Offset des Array-Speicherbereichs trop EAX dazuaddieren
    MOV EAX,[EAX] 'paramètre à qui Speicheradresse dans EAX magasin
    PUSH EAX 'paramètre sur den Stack pushen
  LOOP Boucle 'ECX um 1 verringern et zurückspringen, jusqu'à 0 erreicht ist
  JMP CallFunction
  PascalSchleife:
    MOV EAX,Par1
    SUB EAX,ECX 'paramètre dans aufsteigender Reihenfolge sur den Stack poser (Pascal-Calling-Convention)
    ADD EAX,EAX 'EAX=EAX+EAX --> im Endeffekt =EAX*2
    ADD EAX,EAX 'EAX=EAX+EAX --> im Endeffekt zusammen avec qui la ligne devant =EAX*4 (c'est cela Offset pour den paramètre im Array-grenier)
    ADD EAX,EDX 'Offset des Array-Speicherbereichs trop EAX dazuaddieren
    MOV EAX,[EAX] 'paramètre à qui Speicheradresse dans EAX magasin
    PUSH EAX 'paramètre sur den Stack pushen
  LOOP PascalSchleife 'ECX um 1 verringern et zurückspringen, jusqu'à 0 erreicht ist
  CallFunction:
  CALL Par3 'Funktion aufrufen; ab ici EAX pas plus anfassen, là y qui Rückgabewert steht (ou bien EAX zwischenzeitlich sichern)
  MOV EBX,Par4 'maintenant vérifier, si cdecl, ensuite muss qui Stack manuel bereinigt volonté
  CMP EBX,2
  JNZ Ende 'stdcall & Pascal: Stack wurde bereits de qui Funktion bereinigt
  MOV EBX,Par1
  ADD EBX,EBX
  ADD EBX,EBX
  ADD ESP,EBX 'Stack bereinigen (cdecl)
  Ende:
  'Retour-Wert steht dans EAX
ENDASM

cls
_hGluDll&=@usedll("glu32.dll")
_gluLookAtFuncAddr&=@external("kernel32.dll","GetProcAddress",_hGluDll&,"gluLookAt") 'Adresse qui aufzurufenden Funktion ermitteln
_params&[1]=@long(@addr(eyeX!),0)
_params&[2]=@long(@addr(eyeX!),4)
_params&[3]=@long(@addr(eyeY!),0)
_params&[4]=@long(@addr(eyeY!),4)
_params&[5]=@long(@addr(eyeZ!),0)
_params&[6]=@long(@addr(eyeZ!),4)
_params&[7]=@long(@addr(centerX!),0)
_params&[8]=@long(@addr(centerX!),4)
_params&[9]=@long(@addr(centerY!),0)
_params&[10]=@long(@addr(centerY!),4)
_params&[11]=@long(@addr(centerZ!),0)
_params&[12]=@long(@addr(centerZ!),4)
_params&[13]=@long(@addr(upX!),0)
_params&[14]=@long(@addr(upX!),4)
_params&[15]=@long(@addr(upY!),0)
_params&[16]=@long(@addr(upY!),4)
_params&[17]=@long(@addr(upZ!),0)
_params&[18]=@long(@addr(upZ!),4)
imprimer PushParamsAndCall(18,@addr(_params&[1]),_gluLookAtFuncAddr&,&stdcall) '1. paramètre: Anzahl paramètre, 2. paramètre: Adresse des paramètre-Arrays, 3. paramètre: Funktionsadresse, 4. paramètre: Calling-Convention
waitinput
freedll _hGluDll&
end

XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de

05.08.2023 ▲

Vollständiges citation

Absatzweise Citation Zeilenweise Citation

Jens-Arne
Reumschüssel

...et ici qui Assembler-Funktion pour XProfan jusqu'à X3 (alors sans Inline-Assembler):

Kompilieren Marque Séparation


declare _cPushParamsAndCall#,_a%,_b%
dim _cPushParamsAndCall#,75 'jusqu'à XProfan 9: muss sur long aligned son, ggf. Ende avec nullen auffüllen (ici ist es pas aligned, wird unten erledigt; avant XProfan 10 sur 76 dimensionieren et un weiteres $00 anhängen)
'Opcodes dans Bereich écrivons:
long _cPushParamsAndCall#,0=$5589E58B,$4D088B55,$0C8B4514,$83F80374,$1089C848,$01C001C0,$01D08B00,$50E2F2EB,$108B4508,$29C801C0,$01C001D0,$8B0050E2,$F0FF5510,$8B5D1483,$FB027509,$8B5D0801,$DB01DB01,$DC89EC5D
byte _cPushParamsAndCall#,72=$C2,$10,$00
'sur long alignen (allez seulement ab XProfan 10, weil es auparavant ne...aucune "re"dim donnais):
si ((@sizeof(_cPushParamsAndCall#)) mod 4)<>0
  dim _cPushParamsAndCall#,@sizeof(_cPushParamsAndCall#)+(4-((@sizeof(_cPushParamsAndCall#)) mod 4))
endif
'Bytes dans chaque long retourner:
whileloop 0,@sizeof(_cPushParamsAndCall#)-4,4
  _a%=@long(_cPushParamsAndCall#,&loop)
  whileloop 0,3
    byte @addr(_b%),&loop=@byte(@addr(_a%),3-&loop)
  endwhile
  long _cPushParamsAndCall#,&Loop=_b%
endwhile
'...
'... ici Parameterarray füllen etc.
'...
imprimer @call(_cPushParamsAndCall#,18,@addr(_params&[1]),_gluLookAtFuncAddr&,&stdcall) '1. paramètre: Anzahl paramètre, 2. paramètre: Adresse des paramètre-Arrays, 3. paramètre: Funktionsadresse, 4. paramètre: Calling-Convention
dispose _cPushParamsAndCall#

XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de

07.10.2023 ▲

Vollständiges citation

Absatzweise Citation Zeilenweise Citation

Jens-Arne
Reumschüssel

et, weil es so joli ist, cela ganze nochmal pour JRPC3 avec FreeBasic, weil on sich avec cela cela sonst chez chaque Aufruf de gluLookAt notwendige manuelle mettons des paramètre-Arrays avec einem Makro vom le cou créer peux et cela ganze également sans den XProfan-Inline-Assembler funktioniert (alors pour Versionen avant X4) - voll funktionsfähiges Beispiel:

Kompilieren Marque Séparation


declare _params&[],_hGluDll&,_gluLookAtFuncAddr&,_retval&
declare eyeX!,eyeY!,eyeZ!,centerX!,centerY!,centerZ!,upX!,upY!,upZ!

def &stdcall 1 'paramètre absteigend sur den Stack, Funktion bereinigt den Stack
def &cdecl 2 'paramètre absteigend sur den Stack, Aufrufer muss den Stack selbst bereinigen
def &pascal 3 'paramètre aufsteigend sur den Stack, Funktion bereinigt den Stack

fbPROC PushParamsAndCall(byval AnzParams as long,byval pArray as long,byval pFunc as long,byval CallingConv as long) as integer export
  dim as ulong ReturnValue
  ASM
    MOV ECX,[AnzParams] 'ECX=Count-Register pour qui Boucle avec qui Anzahl paramètre im Array magasin, wird chez chaque Boucle um 1 verringert (paramètre-numéro im Array, qui paramètre doit, sauf chez Pascal-Calling-Convention, arriéré sur den Stack gepusht volonté [FILO])
    MOV EDX,[pArray] 'Offset des Array-Mémoire dans EDX magasin (ist plus rapide comme qui Zugriff sur den paramètre, quel aussi ginge)
    MOV EAX,[CallingConv] '1=stdcall, 2=cdecl, 3=Pascal
    CMP EAX,3
    JZ PascalSchleife
    Boucle:
      MOV EAX,ECX 'aktuellen Schleifenzählerstand (=Nummer des aktuellen Paramters im Array) dans EAX magasin
      DEC EAX 'EAX=ECX-1 (grenier-Offset im Array ist nullbasiert); SUB EAX,1 ginge aussi
      ADD EAX,EAX 'EAX=EAX+EAX --> im Endeffekt =EAX*2
      ADD EAX,EAX 'EAX=EAX+EAX --> im Endeffekt zusammen avec qui la ligne devant =EAX*4 (c'est cela Offset pour den paramètre im Array-grenier)
      ADD EAX,EDX 'Offset des Array-Speicherbereichs trop EAX dazuaddieren
      MOV EAX,[EAX] 'paramètre à qui Speicheradresse dans EAX magasin
      PUSH EAX 'paramètre sur den Stack pushen
    LOOP Boucle 'ECX um 1 verringern et zurückspringen, jusqu'à 0 erreicht ist
    JMP CallFunction
    PascalSchleife:
      MOV EAX,[AnzParams]
      SUB EAX,ECX 'paramètre dans aufsteigender Reihenfolge sur den Stack poser (Pascal-Calling-Convention)
      ADD EAX,EAX 'EAX=EAX+EAX --> im Endeffekt =EAX*2
      ADD EAX,EAX 'EAX=EAX+EAX --> im Endeffekt zusammen avec qui la ligne devant =EAX*4 (c'est cela Offset pour den paramètre im Array-grenier)
      ADD EAX,EDX 'Offset des Array-Speicherbereichs trop EAX dazuaddieren
      MOV EAX,[EAX] 'paramètre à qui Speicheradresse dans EAX magasin
      PUSH EAX 'paramètre sur den Stack pushen
    LOOP PascalSchleife 'ECX um 1 verringern et zurückspringen, jusqu'à 0 erreicht ist
    CallFunction:
    CALL [pFunc] 'Funktion aufrufen; ab ici EAX pas plus anfassen, là y qui Rückgabewert steht (ou bien EAX zwischenzeitlich sichern)
    MOV EBX,[CallingConv] 'maintenant vérifier, si cdecl, ensuite muss qui Stack manuel bereinigt volonté
    CMP EBX,2
    JNZ Ende 'stdcall & Pascal: Stack wurde bereits de qui Funktion bereinigt
    MOV EBX,[AnzParams]
    ADD EBX,EBX
    ADD EBX,EBX
    ADD ESP,EBX 'Stack bereinigen (cdecl)
    Ende:
    MOV [ReturnValue],EAX 'Rückgabewert qui aufgerufenen aus EAX mettons ("MOV [Function],EAX" funktioniert pas, weil JRPC3 automatisch un "return 0" am Ende qui fbPROC ergänzt, si ne...aucune return-Wert angegeben ist, um une entsprechende Compilerwarnung trop vermeiden)
  FIN ASM
  return ReturnValue
ENDPROC 'PushParamsAndCall

MACRO mcrGluLookAt(#p1#,#p2#,#p3#,#p4#,#p5#,#p6#,#p7#,#p8#,#p9#)
  _params&[1]=@long(@addr(#p1#),0)
  _params&[2]=@long(@addr(#p1#),4)
  _params&[3]=@long(@addr(#p2#),0)
  _params&[4]=@long(@addr(#p2#),4)
  _params&[5]=@long(@addr(#p3#),0)
  _params&[6]=@long(@addr(#p3#),4)
  _params&[7]=@long(@addr(#p4#),0)
  _params&[8]=@long(@addr(#p4#),4)
  _params&[9]=@long(@addr(#p5#),0)
  _params&[10]=@long(@addr(#p5#),4)
  _params&[11]=@long(@addr(#p6#),0)
  _params&[12]=@long(@addr(#p6#),4)
  _params&[13]=@long(@addr(#p7#),0)
  _params&[14]=@long(@addr(#p7#),4)
  _params&[15]=@long(@addr(#p8#),0)
  _params&[16]=@long(@addr(#p8#),4)
  _params&[17]=@long(@addr(#p9#),0)
  _params&[18]=@long(@addr(#p9#),4)
  _retval&=@PushParamsAndCall(18,@addr(_params&[1]),_gluLookAtFuncAddr&,&stdcall) '1. paramètre: Anzahl paramètre, 2. paramètre: Adresse des paramètre-Arrays, 3. paramètre: Funktionsadresse, 4. paramètre: Calling-Convention
ENDMACRO 'mcrGluLookAt

cls
_hGluDll&=@usedll("glu32.dll")
_gluLookAtFuncAddr&=@external("kernel32.dll","GetProcAddress",_hGluDll&,"gluLookAt") 'Adresse qui aufzurufenden Funktion ermitteln
mcrGluLookAt(eyeX!,eyeY!,eyeZ!,centerX!,centerY!,centerZ!,upX!,upY!,upZ!)
imprimer _retval&
waitinput
freedll _hGluDll&
end