Übersetzung nach FreeBasic

**UEZ**

Ich möchte folgende Funktion nach FreeBasic übersetzen, aber ich bekomme eine Speicherschutzverletzung.

AutoIt

Func Translate3Dto2D(ByRef $tStruct, $iPos, $fRotX, $fRotY, $fRotZ, $fCenterX = 0, $fCenterY = 0, $fScale = 1, $fZDeepCorrection = 500)
	Local Const $fCosRotX = Cos($fRotX), $fSinRotX = Sin($fRotX), _
				$fCosRotY = Cos($fRotY), $fSinRotY = Sin($fRotY), _
				$fCosRotZ = Cos($fRotZ), $fSinRotZ = Sin($fRotZ), _
				$f1 = $fCosRotY * $tStruct.x(($iPos)), _
				$f2 = $fSinRotX * $tStruct.y(($iPos)), _
				$f3 = $fCosRotX * $tStruct.z(($iPos)), _
				$f4 = $fCosRotX * $tStruct.y(($iPos)), _
				$f5 = $fSinRotX * $tStruct.z(($iPos)), _
				$f6 = $f1 - $fSinRotY * ($f2 + $f3), _
				$fXPos = ($fCosRotZ * $f6 - $fSinRotZ * ($f4 - $f5)) * $fScale, _
				$fYPos = ($fSinRotZ * $f6 + $fCosRotZ * ($f4 - $f5)) * $fScale, _
				$fZPos = ($fSinRotY * $tStruct.x(($iPos)) + $fCosRotY * ($f2 + $f3)) * $fScale, _
				$fZPerspCorrection = 1 / ($fZPos / $fZDeepCorrection + 1)
	$tStruct.fX(($iPos)) = $fXPos * $fZPerspCorrection + $fCenterX
	$tStruct.fY(($iPos)) = $fYPos * $fZPerspCorrection + $fCenterY
	$tStruct.fZ(($iPos)) = $fZPos
EndFunc   ;==>Translate3Dto2D

Alles anzeigen

Die Struct wird über eine andere Funktion erstellt und ist dynamisch.

AutoIt

Local Const $iCountX = Int($aDim[0] / $iStep), $iCountY = Int($aDim[1] / $iStep)
	Local Const $tagData = "struct;float x[" & $iCountX & "];float y[" & $iCountX & "];float z[" & $iCountX & "];float fX[" & $iCountX & "];float fY[" & $iCountX & "];float fZ[" & $iCountX & "];uint pen[" & $iCountX & "];endstruct"

Hier der fehlerhafter FreeBasic Code:

Code

/'
Type tagData
	x (1 To 10000) As Single
	y (1 To 10000) As Single
	z (1 To 10000) As Single
	fX (1 To 10000) As Single
	fY (1 To 10000) As Single
	fZ (1 To 10000) As Single
	pen As UInteger
End Type
'/


Extern "Windows-MS"


Sub Translate3Dto2D(tStruct As Ptr, iPos As Integer, fRotX As Single, fRotY As Single, fRotZ As Single, fCenterX  As Single = 0, fCenterY As Single = 0.0, fScale As Single = 1.0, fZDeepCorrection As Single = 500.0) Export
	Dim As Single fCosRotX, fSinRotX, fCosRotY, fSinRotY, fCosRotZ, fSinRotZ, f1, f2, f3, f4, f5, f6, fXPos, fYPos, fZPos, fZPerspCorrection
	fCosRotX = Cos(fRotX)
	fSinRotX = Sin(fRotX)
	fCosRotY = Cos(fRotY)
	fSinRotY = Sin(fRotY)
	fCosRotZ = Cos(fRotZ)
	fSinRotZ = Sin(fRotZ)
	/'
	f1 = fCosRotY * tStruct->x(iPos)
	f2 = fSinRotX * tStruct->y(iPos)
	f3 = fCosRotX * tStruct->z(iPos)
	f4 = fCosRotX * tStruct->y(iPos)
	f5 = fSinRotX * tStruct->z(iPos)
	f6 = f1 - fSinRotY * (f2 + f3)
	fXPos = (fCosRotZ * f6 - fSinRotZ * (f4 - f5)) * fScale
	fYPos = (fSinRotZ * f6 + fCosRotZ * (f4 - f5)) * fScale
	fZPos = (fSinRotY * tStruct->x(iPos) + fCosRotY * (f2 + f3)) * fScale
	fZPerspCorrection = 1 / (fZPos / fZDeepCorrection + 1)
	tStruct->fX(iPos) = fXPos * fZPerspCorrection + fCenterX
	tStruct->fY(iPos) = fYPos * fZPerspCorrection + fCenterY
	tStruct->fZ(iPos) = fZPos
	'/
End Sub


End Extern

Alles anzeigen

Im Prinzip will ich die Schleife per freeBasic beschleunigen!

Meine Lösung siehe Post#20. Vielen Dank an @eukalyptus für die Hilfestellungen!

Vielen Dank.

**AspirinJunkie**

Sehe ich das richtig, dass das eine Zentralprojektion werden soll mit einem Augpunkt welcher nicht auf der Z-Achse liegt?
Wenn dann wäre es vielleicht angebracht erst einmal auf algorithmischer Ebene zu optimieren.
So wie ich das sehe führst du die Parameterberechnung dabei für jeden Punkt erneut aus.
Sicherlich wäre es aber möglich die Verschiebung des Augpunktes und der Zentralprojektion in eine Transformationsmatrix zu gießen welche für alle Punkte Gültigkeit besitzt. "Direkte Lineare Transformation" sollte der entsprechende Suchbegriff dazu sein (auch wenn diese meist eher andersherum angewandt wird - also aus Passpunkten die Transformationsparameter zu bestimmen).
Heißt also die Matrix nur einmal berechnen und dann auf alle Punkte anwenden.

Ist zwar nicht deine konkrete Fragestellung und ich selbst müsste dafür auch erst einmal bisschen Zeit aufwenden aber ich denke damit könntest du schon ne Menge rausholen.

**UEZ**

Vielen Dank Aspirin Junkie, aber meine letzte Mathe Vorlesung liegt im letzten Jahrtausend zurück, aber ich versuche die DLT zu verstehen und entsprechend anzuwenden.

Nichtsdestotrotz stößt AutoIt bei solchen Operationen schnell an seine Grenzen, sodass das Einsetzen von 3rd Party Code, z.B. Assembler oder ext. DLLs sich i.d.R. nicht vermeiden lässt, wenn man die FPS erhöhen will.

**Mars**

Soweit ich weiß kann man Abbildungsmatrizen miteinander Multiplizieren und die daraus entstehende Matrix auf die Punkte anwenden, anstatt die Matrizen nacheinander anzuwenden.

In deinem Fall müsste man dann eine Translationsmatrix, eine Rotationsmatrix und eine Zentralprojektionsmatrix zusammenfassen.

Eine Multiplikation einer Matrix mit einem Vektor lässt sich auch in ASM einfach handhaben (Ich wette es gibt genau für diesen Fall irgendeinen speziellen SSE Befehl der das in einem Takt macht). Wenn die Matrix steht sollte das Anwenden also recht flott gehen.

Villeicht hilft die das hier Klick Mich

M

**Andy**

Das (übliche) Problem ist nicht die "Optimierung" des Algorithmus (wobei ich das immer zuerst machen würde) sondern die Ausführungsgeschwindigkeit von AutoIt, in diesem Fall kommt noch die "Langsamkeit" von GDI+ dazu...
Ich hatte die Berechnung der 3D in 2D-Koordinaten spaßeshalber bereits in ASM (unter Verwendung der "sehr langsamen" FPU-Befehle) durchgeführt. Um mal Verhältnisse zu beschreiben, die reine Transformation bzw. Berechnung von mehreren tausend Kanten erfolgt für das Bild in 0,1ms, die "Darstellung" eines Frames über GDI+ dauerte 10-20ms, also schlapper Faktor 100 für das Verhältnis (langsame) Berechnung zu Darstellung!
Es bringt also in diesem Fall nichts, die ohnehin schon sehr schnelle Berechnung zu beschleunigen!

Was sehr wohl etwas bringt, sind die GDI+-Befehle rauszulassen, die 3D-2D Transformation auf die Bildpunkte zu übertragen und die so entstandene "Grafik" als nackte Bitmap per GDI (ohne plus) anzuzeigen....

Dazu gehört aber, die Berechnung für alle BxH Bildpunkte per wie-auch-immer-DLLCall abzuwickeln! Für einen einzelnen Punkt eine 2D3D-Transformation auszuführen (egal wie schnell) und dann in AutoIt diese für die gesamte Grafik aufzurufen ist sogar kontraproduktiv! Da ist selbst das "langsame" AutoIt schneller als der Overhead eines millionenfach aufgerufenen DLLCall() !

**Xorianator**

Zitat von Andy

Es bringt also in diesem Fall nichts, die ohnehin schon sehr schnelle Berechnung zu beschleunigen!

Doch, und wie es das bringt! AutoIt ist nicht gleich ASM, ich gehe mal stark davon aus, dass der Sinus & Cosinus noch mehr Takte verschwenden, als sie es direkt implementiert auf Prozessorebene tun würden.
Gehen wir mal davon aus, dass eine Trigonometrische Funktion 5 Takte, eine Multiplikation dagegen 1 Takt (reine Rechenzeit, Daten laden & speichern mal ausgelassen) benötigt, dann würden wir schon alleine mit den 3 Matrizen pro "Grundberechnung" schon mal 24 Millisekunden sparen. Im Verhältnis dauert das also 4 Mal so lang, wie eine normale Multiplikation.
Gehen wir nun (wenn das nicht AutoIt wäre) davon aus, dass wir unsere Matrizen ferner noch im Cache haben, dann sind wir von der Zeit her absolut unschlaggbar. Diese Sinus & Cosinus Methode lässt den Code nämlich zu 100% Cachefrei, was also zuzüglich noch mehr Takte verschwendet, die wir bereits effektiv nutzen könnten.
Anbei noch kurz zu der Berechnung in unter 0.1ms - Natürlich schaffst du 1000 Kanten in <0.1ms, wenn wir davon ausgehen dass wir 20 Takte pro Kante haben, dann haben wir bei einem 2 GHz Prozessor 0.00002 Sekunden Rechenzeit für das Ganze (20*1000)/(10^9)

**UEZ**

Ich wollte eigentlich erst mal wissen, was FreeBasic bei gleichen Bedingungen schafft, bevor ich mich sukzessiv an die Optimierung mache, z.B. über Direkte Lineare Transformation.

Andy: Dass GDI+ Funktionsaufrufe nicht die Schnellsten sind, ist klar, aber unter den gleichen Bedingungen ist FreeBasic auf meiner Kiste ca. 23x schneller.

Ein klassisches Beispiel im Anhang: zufällige Farben in eine Bitmap schreiben, die 400x300 groß (klein) ist.

GDI+ Test 01.au3:

AutoIt

#include <GDIPlus.au3>
#include <GuiConstantsEx.au3>
#include <WindowsConstants.au3>
_GDIPlus_Startup()
Global $hGUI, $iFPS = 0, $iShowFPS = 0, $bExit
Global Const $iW = 400, $iH = 300, $iWh = $iW / 2, $iHh = $iH / 2, $sTitle = "GDI+ Test"
Global Const $fPi = ACos(-1), $fRad = $fPi / 180, $fDeg = 180 / $fPi
AutoItSetOption("GUIOnEventMode", 1)
GDIPlus_Test()
AutoItSetOption("GUIOnEventMode", 0)
_GDIPlus_Shutdown()
Func GDIPlus_Test()
	$bExit = False
	$hGUI = GUICreate($sTitle, $iW, $iH) ;, 0, 0, $WS_POPUP)
	GUISetState(@SW_SHOW, $hGUI)
;~ 	GUISetCursor(16, 1)
	;create canvas elements
	Local Const $hCanvas = _GDIPlus_GraphicsCreateFromHWND($hGUI)
	Local Const $hBitmap = _GDIPlus_BitmapCreateFromScan0($iW, $iH)
	Local Const $hGfx = _GDIPlus_ImageGetGraphicsContext($hBitmap)
	_GDIPlus_GraphicsSetSmoothingMode($hGfx, $GDIP_SMOOTHINGMODE_HIGHQUALITY)
	_GDIPlus_GraphicsSetPixelOffsetMode($hGfx, $GDIP_PIXELOFFSETMODE_HIGHQUALITY)
	Local Const $hBrush_Clr = _GDIPlus_BrushCreateSolid(0xFF000000), _
				$hBrush_FPS = _GDIPlus_BrushCreateSolid(0xFFFFFFFF), _
				$hFormat_FPS = _GDIPlus_StringFormatCreate(), _
				$hFamily_FPS = _GDIPlus_FontFamilyCreate("Arial"), _
				$hFont_FPS = _GDIPlus_FontCreate($hFamily_FPS, 10), _
				$tLayout_FPS = _GDIPlus_RectFCreate(0, 0, 60, 16)
	$iFPS = 0
	GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit_About")
	AdlibRegister("CalcFPS", 1000)
	Local $fTimer, $iX, $iY
	Do
		$fTimer = TimerInit()
		For $iY = 0 To $iH
			For $iX = 0 To $iW
				DllCall($__g_hGDIPDll, "int", "GdipBitmapSetPixel", "handle", $hBitmap, "int", $iX, "int", $iY, "uint", 0xFF000000 + Random(0, 0xFFFFFF, 1))
			Next
		Next
		ConsoleWrite(TimerDiff($fTimer) & @CRLF)
		_GDIPlus_GraphicsDrawStringEx($hGfx, "FPS: " & $iShowFPS, $hFont_FPS, $tLayout_FPS, $hFormat_FPS, $hBrush_FPS) ;draw background message text
		_GDIPlus_GraphicsDrawImageRect($hCanvas, $hBitmap, 0, 0, $iW, $iH)
		$iFPS += 1
		If $bExit Then ExitLoop
	Until Not Sleep(10)
	AdlibUnRegister("CalcFPS")
	;release resources
	_GDIPlus_FontDispose($hFont_FPS)
	_GDIPlus_FontFamilyDispose($hFamily_FPS)
	_GDIPlus_StringFormatDispose($hFormat_FPS)
	_GDIPlus_BrushDispose($hBrush_Clr)
	_GDIPlus_BrushDispose($hBrush_FPS)
	_GDIPlus_GraphicsDispose($hCanvas)
	GUIDelete($hGUI)
EndFunc   ;==>GDIPlus_Test
Func _Exit_About()
	$bExit = True
EndFunc   ;==>_Exit_About
Func CalcFPS() ;display FPS
	$iShowFPS = $iFPS
	$iFPS = 0
EndFunc   ;==>CalcFPS

Alles anzeigen

GDI+ Test 01.bas:

Code

#Include Once "win\gdiplus.bi"
Using GDIPLUS


Extern "Windows-MS"


Declare Function GetRandom(As Integer, As Integer) As Integer


'Returns a random number between low and high
Function GetRandom(iLowerbound As Integer, iUpperbound As Integer) As Integer
	GetRandom = Int((iUpperbound - iLowerbound + 1) * Rnd + iLowerbound)
End Function


Sub RandomPattern(ByVal hBitmap As GpImage Ptr, iW As UInteger, iH As UInteger, iRndLow As Integer = 0, iRndHigh As Integer = &hFFFFFF, iAlpha As UInteger = &hFF000000) Export
	Dim As Integer iX, iY, iColor 
	For iY = 0 To iH
		For iX = 0 To iW
			iColor = iAlpha + GetRandom(iRndLow, iRndHigh)
			GdipBitmapSetPixel(hBitmap, iX, iY, iColor)
		Next 
	Next
End Sub


End Extern

Alles anzeigen

Primär geht es mir erst mal um die Implementierung in FreeBasic!

**Xorianator**

@UEZ dann würdest du dir aber doppelt Arbeit machen. Wenn du den Algorithmus gleich "optimal" entwirfst, dann musst du ja nur den portieren. Wenn du jetzt aber sowohl A als auch B zwei Mal schreibst, dann schreibst du A einmal zu viel.

**UEZ**

Zitat von Xorianator

@UEZ dann würdest du dir aber doppelt Arbeit machen. Wenn du den Algorithmus gleich "optimal" entwirfst, dann musst du ja nur den portieren. Wenn du jetzt aber sowohl A als auch B zwei Mal schreibst, dann schreibst du A einmal zu viel.

Das macht erst mal nichts, denn, wie gesagt, geht es mir primär um FreeBasic, dann um die Optimierung. Dass es zu doppelten Arbeiten dadurch kommt, ist mir erst mal egal.

**Andy**

Zitat von Xorianator

Doch, und wie es das bringt!

Wenn du meinst...
Ich jedenfalls habe eine reale Anwendung geprofiled, und da waren die Anteile von Berechnung + Darstellung ca. 1+ 100 -> FPS ca. 50. Und man muss kein exzellenter Mathematiker sein um herauszufinden, dass bei einer Beschleunigung der Berechnung um Faktor 1000 die Darstellung die gleiche Zeit wie vorher dauert. Ergo 0,001+100 -> 50FPS.

Bei einer Optimierung fängt man generell bei den "großen Brocken" an, und nicht bei irgendeinem Gedöns, welches letztendlich auf das Ergebnis nur minimale Auswirkungen hat!

Übrigens habe ich folgende Mathematische Umformung benutzt, um die Sin() und Cos()-Berechnung komplett aus der Schleife draussen zu lassen. In der eigentlichen Schleife werden statt der trigonometrischen Funktionen nur noch Additionen und Multiplikationen verwendet, in den Prozessoren gibt es dafür den PMADDWD-Befehl, welcher 4 Multiplikationen und 2 Additionen in EINEM Takt durchführen kann!
Übrigens gibt es alle diese "Beschleuniger"-Befehle als Intrinsics für C(++)-Compiler, für diejenigen, die wirklich ans Limit gehen wollen (müssen). Dazu ist zunächst richtiges Profiling nötig, die neueren (INTEL-) Compiler bringen dafür höchst eindrucksvolle Werkzeuge mit, da kann man nur staunen...mich würde brennend interessieren, wie viele "Programmierer" ihren Code damit tatsächlich analysieren...

**eukalyptus**

Um die dynamische Struct in FreeBasic anzusprechen, kannst du mit Pointern arbeiten:

Hier zwei Möglichkeiten:

AutoIt

Global $hDll = DllOpen(@ScriptDir & "\Test.dll")


_Test_1()


_Test_2()




Func _Test_1($iCnt = 100)
	Local $tStruct = DllStructCreate("struct; float X[" & $iCnt & "]; float Y[" & $iCnt & "]; float Z[" & $iCnt & "]; endstruct; ")
	DllCall($hDll, "none", "_Test_1", "struct*", $tStruct, "uint", $iCnt)
	For $i = 1 To $iCnt
		ConsoleWrite("> " & StringFormat("% 4s   %.1f   %.1f   %.1f", $i, $tStruct.X(($i)), $tStruct.Y(($i)), $tStruct.Z(($i))) & @CRLF)
	Next
EndFunc   ;==>_Test_1




Func _Test_2($iCnt = 100)
	Local $tStruct = DllStructCreate("struct; float X[" & $iCnt & "]; float Y[" & $iCnt & "]; float Z[" & $iCnt & "]; endstruct; ")
	DllCall($hDll, "none", "_Test_2", "struct*", DllStructGetPtr($tStruct, "X"), "struct*", DllStructGetPtr($tStruct, "Y"), "struct*", DllStructGetPtr($tStruct, "Z"), "uint", $iCnt)
	For $i = 1 To $iCnt
		ConsoleWrite("+ " & StringFormat("% 4s   %.1f   %.1f   %.1f", $i, $tStruct.X(($i)), $tStruct.Y(($i)), $tStruct.Z(($i))) & @CRLF)
	Next
EndFunc   ;==>_Test_2

Alles anzeigen

Code

Extern "Windows-MS"


Sub _Test_1(pStruct As Any Ptr, iCnt As UInteger) Export
	Dim As Single Ptr pX, pY, pZ
	pX = pStruct
	pY = pStruct + (iCnt * SizeOf(Single))
	pZ = pStruct + (iCnt * 2 * SizeOf(Single))

	For i As UInteger = 0 To iCnt-1
		pX[i] = 10000 + i
		pY[i] = 20000 + i
		pZ[i] = 30000 + i
	Next
End Sub


Sub _Test_2(pX As Single Ptr, pY As Single Ptr, pZ As Single Ptr, iCnt As UInteger) Export	
	For i As UInteger = 0 To iCnt-1
		pX[i] = 10000 + i
		pY[i] = 20000 + i
		pZ[i] = 30000 + i
	Next
End Sub

End Extern

Alles anzeigen

**UEZ**

@eukalyptus: Vielen Dank.

Wie zu erwarten hat Translate3Dto2D in FreeBasic natürlich nichts gebracht, aber darum ging es mir ehe nicht, sondern FB zu lernen.

Nächster Schritt ist nun die Schleifen in Freebasic zu implementieren:

AutoIt

For $iY = 0 To $iCountY
			For $iX = 1 To $iCountX
;~ 				Translate3Dto2D($aData[$iY], $iX, $fX, $fY, $fZ, $iW / 2, $iH / 2, 2.75)
				DllCall($hDLL, "none", "Translate3Dto2D", _
				"struct*", DllStructGetPtr($aData[$iY], "x"), _
				"struct*", DllStructGetPtr($aData[$iY], "y"), _
				"struct*", DllStructGetPtr($aData[$iY], "z"), _
				"struct*", DllStructGetPtr($aData[$iY], "fX"), _
				"struct*", DllStructGetPtr($aData[$iY], "fY"), _
				"struct*", DllStructGetPtr($aData[$iY], "fZ"), _
				"struct*", DllStructGetPtr($aData[$iY], "pen"), _
				"uint", $iX - 1, _
				"float", $fX, "float", $fY, "float", $fZ, "float", $iW / 2, "float", $iH / 2, "float", 2.75, "float", 1000.0)
				If $iX > 1 Then
					DllCall($__g_hGDIPDll, "int", "GdipDrawLine", "handle", $oCanvas.Gfx, "handle", $aData[$iY].Pen(($iX)), _
										   "float", $aData[$iY].fX(($iX - 1)), "float", $aData[$iY].fY(($iX - 1)), _
										   "float", $aData[$iY].fX(($iX)), "float", $aData[$iY].fY(($iX)))
				EndIf
			Next
		Next

Alles anzeigen

Nun muss ich eine Array nach FreeBasic übergeben und dort die Schleife ausführen. Mal sehen, wie schneller dies wird, falls ich FB dazu bekomme, dies zu tun, was ich will.

Geht das überhaupt ein Array (keine Struct!) zu übergeben?

**eukalyptus**

Nein - du musst zunächst dein Script umbauen, dass statt Arrays nur Structs verwendet werden.
Kommst du mit GDIPlus in FreeBasic klar, oder soll ich ein kurzes Beispiel basteln?

**UEZ**

@eukalyptus: ich probiere es mal selbstständig, ansonsten melde ich mich hier wieder.

**UEZ**

Hmm, wie speichere ich am besten die Daten nun in AutoIt ab? Struct in Struct?

**eukalyptus**

Entweder du packst alles in eine Struct "float X[" & iCntX * iCntY & "]; float Y[" & iCntX * iCntY & "];

oder du machst es auf diese Weise:

AutoIt

Global $hDll = DllOpen(@ScriptDir & "\Test.dll")


_Test()


Func _Test($iCnt = 10, $iCntY = 5)
	Local $sTag = "struct; float X[" & $iCnt & "]; float Y[" & $iCnt & "]; float Z[" & $iCnt & "]; endstruct; "
	Local $tStruct = DllStructCreate("ptr Struct[" & $iCntY & "];")
	Local $aStruct[$iCntY + 1]


	For $y = 1 To $iCntY
		$aStruct[$y] = DllStructCreate($sTag)
		DllStructSetData($tStruct, 1, DllStructGetPtr($aStruct[$y]), $y)
	Next


	DllCall($hDll, "none", "_Test", "struct*", $tStruct, "uint", $iCnt, "uint", $iCntY)








	For $y = 1 To $iCntY
		For $i = 1 To $iCnt
			ConsoleWrite("> " & $y & "/" & $i & " = " & StringFormat("%.1f   %.1f   %.1f", $aStruct[$y].X(($i)), $aStruct[$y].Y(($i)), $aStruct[$y].Z(($i))) & @CRLF)
		Next
	Next
EndFunc   ;==>_Test

Alles anzeigen

Code

Extern "Windows-MS"


Sub _Test(pStruct As Any Ptr Ptr, iCnt As UInteger, iCntY As UInteger) Export
	Dim As Single Ptr pX, pY, pZ

	For y As UInteger = 0 To iCntY-1
		pX = pStruct[y]
		pY = pStruct[y] + (iCnt * SizeOf(Single))
		pZ = pStruct[y] + (iCnt * 2 * SizeOf(Single))

		For i As UInteger = 0 To iCnt-1
			pX[i] = y * 10000 + i
			pY[i] = y * 20000 + i
			pZ[i] = y * 30000 + i
		Next
	Next

End Sub


End Extern

Alles anzeigen

**UEZ**

Kackt mit einer Speicherschutzverletzung ab:

AutoIt:

AutoIt

;~ 		For $c = 1 To $iCountX * $iCountY + $iCountX + $iCountY + 1
;~ 			Translate3Dto2D($tData, $c, $fX, $fY, $fZ, $iW / 2, $iH / 2, 2.75)
;~ 			If $c > 1 Then
;~ 				DllCall($__g_hGDIPDll, "int", "GdipDrawLine", "handle", $oCanvas.Gfx, "handle", $tData.Pen(($c)), _
;~ 									   "float", $tData.fX(($c - 1)), "float", $tData.fY(($c - 1)), _
;~ 									   "float", $tData.fX(($c)), "float", $tData.fY(($c)))
;~ 			EndIf
;~ 		Next


		;Sub Boost(ByVal hCanvas As GpGraphics Ptr, ByVal tData As Any Ptr, iCountX As UInteger, iCountY As UInteger, _
		;	 fX As Single, fY As Single, fZ As Single, fW As Single, fH As Single, fScale As Single)
		DllCall($hDLL, "none", "Boost", "ptr", $oCanvas.Gfx, "struct*", $tData, "uint", $iCountX, "uint", $iCountY, _
										"float", $fX, "float", $fY, "float", $fZ, "float", $iW / 2, "float", $iH / 2, "float", 2.75)

Alles anzeigen

FreeBasic:

Code

#Include Once "win\gdiplus.bi"
Using GDIPLUS


Extern "Windows-MS"


/'	Local $iDim = $iCountX * $iCountY + $iCountX + $iCountY + 1
	Local Const $tagData = "struct;float x[" & $iDim & "];float y[" & $iDim & "];float z[" & $iDim & "];float fX[" & $iDim & "];float fY[" & $iDim & "];
									float fZ[" & $iDim & "];int pen[" & $iDim & "];endstruct"
'/
Sub Translate3Dto2D(tData as Any Ptr, iPos As Integer, _
						  fRotX As Single, fRotY As Single, fRotZ As Single, fCenterX  As Single = 0, fCenterY As Single = 0.0, _
						  fScale As Single = 1.0, fZDeepCorrection As Single = 500.0)

	Dim As Single fCosRotX, fSinRotX, fCosRotY, fSinRotY, fCosRotZ, fSinRotZ, f1, f2, f3, f4, f5, f6, fXPos, fYPos, fZPos, fZPerspCorrection

	Dim As Single Ptr pX, pY, pZ, pfX, pfY, pfZ


	pX = tData
	pY = tData + (iPos * 4)
	pZ = tData + (iPos * 8)
	pfX = tData + (iPos * 12)
	pfY = tData + (iPos * 16)
	pfZ = tData + (iPos * 20)


	fCosRotX = Cos(fRotX)
	fSinRotX = Sin(fRotX)
	fCosRotY = Cos(fRotY)
	fSinRotY = Sin(fRotY)
	fCosRotZ = Cos(fRotZ)
	fSinRotZ = Sin(fRotZ)


	f1 = fCosRotY * pX[iPos]
	f2 = fSinRotX * pY[iPos]
	f3 = fCosRotX * pZ[iPos]
	f4 = fCosRotX * pY[iPos]
	f5 = fSinRotX * pZ[iPos]
	f6 = f1 - fSinRotY * (f2 + f3)
	fXPos = (fCosRotZ * f6 - fSinRotZ * (f4 - f5)) * fScale
	fYPos = (fSinRotZ * f6 + fCosRotZ * (f4 - f5)) * fScale
	fZPos = (fSinRotY * pX[iPos] + fCosRotY * (f2 + f3)) * fScale
	fZPerspCorrection = 1 / (fZPos / fZDeepCorrection + 1)
	pfX[iPos] = fXPos * fZPerspCorrection + fCenterX
	pfY[iPos] = fYPos * fZPerspCorrection + fCenterY
	pfZ[iPos] = fZPos
End Sub


Sub Boost(ByVal hCanvas as GpGraphics Ptr, tData As Any Ptr, iCountX As UInteger, iCountY As UInteger, _
			 fX As Single, fY As Single, fZ As Single, fW As Single, fH As Single, fScale As Single) Export

	Dim As Integer c, iUBound
	Dim As Single Ptr pfX, pfY
	Dim As Integer Ptr pPen

	iUBound = iCountX * iCountY + iCountX + iCountY

	For c = 0 To iUbound
		Translate3Dto2D(tData, c, fX, fY, fZ, fW, fH, fScale)
		If c > 0 Then
			pfX = tData + (c * 12)
			pfY = tData + (c * 16)
			pPen = tData + (c * 24)
			GdipDrawLine(hCanvas, pPen[c], pfX[c - 1], pfY[c - 1], pfX[c], pfY[c])  
		EndIf
	Next


End Sub


End Extern

Alles anzeigen

Scheint an GdipDrawLine(hCanvas, hPen, pfX[c - 1], pfY[c - 1], pfX[c], pfY[c]) zu liegen!?

@eukalyptus: kannst du den Fehler sehen?

**eukalyptus**

Dazu bräuchte ich auch das AutoIt-Script dazu...

Du kannst die FB-DLL mit Print debuggen, z.b.: Print "> " & c & " " & pPen[c] & " " & pfX[c - 1]
Das wird dann direkt in die Konsole von SciTE geschrieben

**UEZ**

Bitte sehr.

Es scheint, dass die Pointer nicht stimmen!

Edit:

Code

#Include Once "win\gdiplus.bi"
Using GDIPLUS


Extern "Windows-MS"


/'	Local $iDim = $iCountX * $iCountY + $iCountX + $iCountY + 1
	Local Const $tagData = "struct;float x[" & $iDim & "];float y[" & $iDim & "];float z[" & $iDim & "];float fX[" & $iDim & "];float fY[" & $iDim & "];
									float fZ[" & $iDim & "];int pen[" & $iDim & "];endstruct"
'/
Sub Translate3Dto2D(tData as Any Ptr, iPos As UInteger, _
						  fRotX As Single, fRotY As Single, fRotZ As Single, fCenterX  As Single = 0, fCenterY As Single = 0.0, _
						  fScale As Single = 1.0, fZDeepCorrection As Single = 500.0, iCountX As UInteger, iCountY As UInteger)
	Dim As Single fCosRotX, fSinRotX, fCosRotY, fSinRotY, fCosRotZ, fSinRotZ, f1, f2, f3, f4, f5, f6, fXPos, fYPos, fZPos, fZPerspCorrection
	Dim As Single Ptr pX, pY, pZ, pfX, pfY, pfZ
	Dim As UInteger iSingle, iUBound
	iUBound = iCountX * iCountY + iCountX + iCountY + 1


	iSingle = SizeOf(Single)
	pX = tData
	pY = tData + 1 * iUBound + iSingle
	pZ = tData + 2 * iUBound + iSingle
	pfX = tData + 3 * iUBound + iSingle
	pfY = tData + 4 * iUBound + iSingle
	pfZ = tData + 5 * iUBound + iSingle


	fCosRotX = Cos(fRotX)
	fSinRotX = Sin(fRotX)
	fCosRotY = Cos(fRotY)
	fSinRotY = Sin(fRotY)
	fCosRotZ = Cos(fRotZ)
	fSinRotZ = Sin(fRotZ)


	f1 = fCosRotY * pX[iPos]
	f2 = fSinRotX * pY[iPos]
	f3 = fCosRotX * pZ[iPos]
	f4 = fCosRotX * pY[iPos]
	f5 = fSinRotX * pZ[iPos]
	f6 = f1 - fSinRotY * (f2 + f3)
	fXPos = (fCosRotZ * f6 - fSinRotZ * (f4 - f5)) * fScale
	fYPos = (fSinRotZ * f6 + fCosRotZ * (f4 - f5)) * fScale
	fZPos = (fSinRotY * pX[iPos] + fCosRotY * (f2 + f3)) * fScale
	fZPerspCorrection = 1 / (fZPos / fZDeepCorrection + 1)
	pfX[iPos] = fXPos * fZPerspCorrection + fCenterX
	pfY[iPos] = fYPos * fZPerspCorrection + fCenterY
	pfZ[iPos] = fZPos
End Sub


Sub Boost(ByVal hCanvas as GpGraphics Ptr, tData As Any Ptr, _
			 iCountX As UInteger, iCountY As UInteger, _
			 fX As Single, fY As Single, fZ As Single, fW As Single, fH As Single, fScale As Single) Export
	Dim As UInteger c, iUBound, iSingle
	Dim As Single Ptr pX, pY, pZ, pfX, pfY, pFZ
	Dim As UInteger Ptr pPen
	iUBound = iCountX * iCountY + iCountX + iCountY + 1
	iSingle = SizeOf(Single)
	For c = 0 To iUbound - 1
			Translate3Dto2D(tData, c, fX, fY, fZ, fW, fH, fScale, 1000, iCountX, iCountY)


			pX = tData '+ 0 * iUBound + 0 * iSingle
			pY = tData + 1 * iUBound * iSingle
			pZ = tData + 2 * iUBound * iSingle
			pfX = tData + 3 * iUBound * iSingle
			pfY = tData + 4 * iUBound * iSingle
			pfZ = tData + 5 * iUBound * iSingle
			pPen = tData + 6 * iUBound * iSingle
			If c > 0 Then
				GdipDrawLine(hCanvas, pPen[c], pfX[c - 1], pfY[c - 1], pfX[c], pfY[c])
			EndIf


	Next


End Sub


End Extern

Alles anzeigen

Dies hier kackt nicht ab, aber Bildschirm bleibt dunkel.

**UEZ**

Das hier funzt:

Code

#Include Once "win\gdiplus.bi"
Using GDIPLUS


Extern "Windows-MS"


Sub Boost(ByVal hCanvas as GpGraphics Ptr, ByVal tData As Any Ptr, _
			 iCountX As UInteger, iCountY As UInteger, _
			 fX As Single, fY As Single, fZ As Single, fW As Single, fH As Single, fScale As Single) Export

	Dim As UInteger c, iUBound, iSingle
	Dim As Single Ptr pX, pY, pZ, pfX, pfY, pFZ
	Dim As UInteger Ptr pPen

	Dim As Single fCosRotX, fSinRotX, fCosRotY, fSinRotY, fCosRotZ, fSinRotZ, f1, f2, f3, f4, f5, f6, fXPos, fYPos, fZPos, fZPerspCorrection, fZDeepCorrection

	iUBound = iCountX * iCountY + iCountX + iCountY + 1
	iSingle = SizeOf(Single)
	fZDeepCorrection = 1000.0

	For c = 0 To iUbound - 1

			pX = tData '+ 0 * iUBound + 0 * iSingle
			pY = tData + 1 * iUBound * iSingle
			pZ = tData + 2 * iUBound * iSingle
			pfX = tData + 3 * iUBound * iSingle
			pfY = tData + 4 * iUBound * iSingle
			pfZ = tData + 5 * iUBound * iSingle
			pPen = tData + 6 * iUBound * iSingle



			fCosRotX = Cos(fX)
			fSinRotX = Sin(fX)
			fCosRotY = Cos(fY)
			fSinRotY = Sin(fY)
			fCosRotZ = Cos(fZ)
			fSinRotZ = Sin(fZ)

			f1 = fCosRotY * pX[c]
			f2 = fSinRotX * pY[c]
			f3 = fCosRotX * pZ[c]
			f4 = fCosRotX * pY[c]
			f5 = fSinRotX * pZ[c]
			f6 = f1 - fSinRotY * (f2 + f3)
			fXPos = (fCosRotZ * f6 - fSinRotZ * (f4 - f5)) * fScale
			fYPos = (fSinRotZ * f6 + fCosRotZ * (f4 - f5)) * fScale
			fZPos = (fSinRotY * pX[c] + fCosRotY * (f2 + f3)) * fScale
			fZPerspCorrection = 1 / (fZPos / fZDeepCorrection + 1)
			pfX[c] = fXPos * fZPerspCorrection + fW
			pfY[c] = fYPos * fZPerspCorrection + fH
			pfZ[c] = fZPos


			If c > 0 Then
				GdipDrawLine(hCanvas, pPen[c], pfX[c - 1], pfY[c - 1], pfX[c], pfY[c])
			EndIf


	Next


End Sub


End Extern

Alles anzeigen