Matrix-Functionen von ???
Da ich meine Matrix-GUI jetzt fertig hab und sie nicht veröffentlichen werde, poste ich mal nur den Matrix-Effekt. Ich schätze mal den können viele auch gebrauchen. Naja, auf diesem frühen Screenshot meiner GUI kann man schon sehen, was man mit meinen Matrix-Functionen machen kann.

[url]http://mitglied.lycos.de/Blacal/Screen.gif[/url]
Dieses Screenshot ist in 1600x1200

Hier mal der Code der Functionen:
[code:1:9197606424]
;Function CreateMatrix(Anzahl,Rot,Grün,Blau)
Function Matrix_CreateMatrix(CrM_Anzahl,CrM_R,CrM_G,CrM_B)
local CrM_Bank,CrM_R2,CrM_G2,CrM_B2,CrM_Image
Local CrM_Buffer
CrM_Buffer=GraphicsBuffer()
CrM_Bank=CreateBank((CrM_Anzahl+1)*4)
PokeByte CrM_Bank,0,CrM_Anzahl
PokeByte CrM_Bank,1,CrM_R
PokeByte CrM_Bank,2,CrM_G
PokeByte CrM_Bank,3,CrM_B
If CrM_R<>0 then CrM_R2=4 Else CrM_R2=0
If CrM_G<>0 then CrM_G2=4 Else CrM_G2=0
If CrM_B<>0 then CrM_B2=4 else CrM_B2=0
For a=1 to CrM_Anzahl
CrM_Image=CreateImage(10,480)
SetBuffer ImageBuffer(CrM_Image)
For b=1 to 47
If b<47 then Color CrM_R+CrM_R2*b,CrM_G+CrM_G2*b,CrM_B+CrM_B2*b Else Color 250,250,250
Text 0,(b-1)*10,Chr(Rnd(32,200))
Next
PokeInt CrM_Bank,a*4,CrM_Image
Next
SetBuffer CrM_Buffer
Return CrM_Bank
End function
;-------------------------------------------------------------------------------
;Function AddMatrixLines(Matrix,Anzahl)
Function Matrix_AddMatrixLines(CrM_Matrix,CrM_Anzahl)
Local CrM_R,CrM_G,CrM_B,CrM_R2,CrM_G2,CrM_B2,CrM_Image,CrM_Normal
Local CrM_Buffer
CrM_Buffer=GraphicsBuffer()
CrM_Normal=PeekByte(CrM_Matrix,0)
CrM_R=PeekByte(CrM_Matrix,1):If CrM_R<>0 then CrM_R2=4 else CrM_R2=0
CrM_G=PeekByte(CrM_Matrix,2):If CrM_G<>0 then CrM_G2=4 Else CrM_G2=0
CrM_B=PeekByte(CrM_Matrix,3):If CrM_B<>0 Then CrM_B2=4 Else CrM_B2=0
PokeByte CrM_Matrix,0,CrM_Normal+CrM_Anzahl
ResizeBank CrM_Matrix,(CrM_Anzahl+CrM_Normal+1)*4
For a=1 to CrM_Anzahl
CrM_Image=CreateImage(10,480)
SetBuffer imageBuffer(CrM_Image)
For b=1 to 47
If b<47 then Color CrM_R+CrM_R2*b,CrM_G+CrM_G2*b,CrM_B+CrM_B2*b Else Color 250,250,250
Text 0,b*10,Chr(Rnd(32,255))
Next
PokeInt CrM_Matrix,(a+CrM_Normal)*4,CrM_Image
next
SetBuffer CrM_Buffer
End Function
;-------------------------------------------------------------------------------
;DeleteMatrixLines(Matrix,Anzahl)
Function Matrix_DeleteMatrixLines(CrM_Matrix,CrM_Anzahl)
Local CrM_Normal
CrM_Normal=PeekByte(CrM_Matrix,0)
If CrM_Normal<CrM_Anzahl then RuntimeError "Nicht genug MatrixLinien vorhanden"
For a=CrM_Normal-CrM_Anzahl to CrM_Normal
FreeImage PeekInt(CrM_Matrix,a*4)
Next
ResizeBank CrM_Matrix,(CrM_Normal-CrM_Anzahl+1)*4
PokeByte CrM_Matrix,0,CrM_Normal-CrM_Anzahl
end Function
;-------------------------------------------------------------------------------
;DeleteMatrix(Matrix)
Function Matrix_DeleteMatrix(CrM_Matrix)
Local CrM_Anzahl,CrM_Lines.Matrix_Line
CrM_Anzahl=PeekByte(CrM_Matrix,0)
For a=1 to CrM_Anzahl
FreeImage PeekInt(CrM_Matrix,a*4)
Next
For CrM_Lines.Matrix_Line=EAch Matrix_Line
If CrM_LinesMatrix=CrM_Matrix then Delete CrM_Lines
Next
FreeBank CrM_Matrix
end Function
;-------------------------------------------------------------------------------
;CreateMatrixScreen(Länge,Breite)
Function Matrix_CreateMatrixScreen(CrM_Lx,CrM_Ly)
Local CrM_Handle,CrM_Screen.Matrix_Screen
CrM_Screen.Matrix_Screen=New Matrix_Screen
CrM_ScreenImage=CreateImage(CrM_Lx,CrM_Ly)
CrM_ScreenMatrix=0:CrM_ScreenStill=0:CrM_ScreenAktiv=1
CrM_ScreenLastSecs=MilliSecs()-200
CrM_ScreenSecsAbs=150
CrM_Handle=Handle CrM_Screen
Return CrM_Handle
end Function
;-------------------------------------------------------------------------------
;Screenwidth(Screen)
Function Matrix_ScreenWidth(scW_Screen)
Local ScW_Type.Matrix_Screen
ScW_Type.Matrix_Screen=Object.Matrix_Screen(ScW_Screen)
Return ImageWidth(ScW_TypeImage)
End Function
;-------------------------------------------------------------------------------
;Screenheight
Function Matrix_ScreenHeight(ScH_Screen)
Local ScH_Type.Matrix_Screen
ScH_Type.Matrix_Screen=Object.Matrix_Screen(ScH_Screen)
Return ImageHeight(ScH_TypeImage)
End Function
;-------------------------------------------------------------------------------
;MatrixScreenOptions(Screen,[Speed],[Still],[Matrix])
Function Matrix_MatrixScreenOptions(MaS_Screen,MaS_Speed=30,MaS_Still=-1,MaS_Matrix=0)
Local MaS_Type.Matrix_Screen
MaS_Type.Matrix_Screen=Object.Matrix_Screen(MaS_Screen)
If MaS_Speed>0 then MaS_TypeMillis=1000/MaS_Speed
If MaS_Still<>-1 then
MaS_TypeStill=MaS_Still
If MaS_Still=0 then MaS_TypeLastSecs=Millisecs()-MaS_TypeMillis
If MaS_Still=1 then MaS_TypeRender=0
EndIf
If MaS_Matrix>0 then MaS_TypeMatrix=MaS_Matrix
End Function
;-------------------------------------------------------------------------------
;UseMatrixLine(Screen,Matrix,[XPos],[YPos])
Function Matrix_UseMatrixLine(UsM_Screen,UsM_Matrix,UsM_X=-138,UsM_Y=-480)
Local UsM_Line.Matrix_Line
UsM_Line.Matrix_Line=New Matrix_Line
UsM_LineImage=PeekInt(UsM_Matrix,Rand(1,PeekByte(UsM_Matrix,0))*4)
UsM_LineX=UsM_X:UsM_LineY=UsM_Y
If UsM_X=-138 then UsM_LineX=Rand(0,Matrix_Screenwidth(UsM_Screen)/10)*10
UsM_LineScreen=UsM_Screen
UsM_LineMatrix=UsM_Matrix
End Function
;-------------------------------------------------------------------------------
;UpdateMatrix()
Function Matrix_UpdateMatrix()
Local UpM_Screen.Matrix_Screen,UpM_Line.Matrix_Line,UpM_A
Local UpM_Buffer
UpM_Buffer=GraphicsBuffer()
For UpM_Screen.Matrix_Screen=Each Matrix_Screen
If UpM_ScreenAktiv=1 and UpM_ScreenStill=0 then
If UpM_ScreenSecsAbs+(Millisecs()-UpM_ScreenLastSecs)>=UpM_ScreenMillis Then
UpM_ScreenSecsAbs=UpM_ScreenSecsAbs+(MilliSecs()-UpM_ScreenLastSecs)
UpM_ScreenLastSecs=MilliSecs()
UpM_ScreenRender=UpM_ScreenSecsAbs/UpM_ScreenMillis
UpM_ScreenSecsAbs=UpM_ScreenSecsAbs-(UpM_ScreenMillis*UpM_ScreenRender)
SetBuffer ImageBuffer(UpM_ScreenImage)
ClsColor 1,0,0
Cls
ClsColor 0,0,0
SetBuffer BackBuffer()
UpM_A=Matrix_ScreenWidth(Handle UpM_Screen)/250
If UpM_A=0 then UpM_A=1
For a=1 to UpM_ScreenRender
For b=1 to UpM_A
Matrix_UseMatrixLine(Handle UpM_Screen,UpM_ScreenMatrix,-138,-480-((a-1)*15))
next
Next
Else
UpM_ScreenRender=0
EndIf
EndIf
Next
For UpM_Line.Matrix_Line=Each Matrix_Line
UpM_Screen.Matrix_Screen=Object.Matrix_Screen(UpM_LineScreen)
If UpM_ScreenRender<>0 then
For a=1 to UpM_ScreenRender
UpM_LineY=UpM_LineY+15
Next
SetBuffer ImageBuffer(UpM_ScreenImage)
UpM_LineImage=PeekInt(UpM_LineMatrix,Rand(1,PeekByte(UpM_LineMatrix,0))*4)
DrawBlock UpM_LineImage,UpM_LineX,UpM_LineY
If UpM_LineY>Matrix_ScreenHeight(Handle UpM_Screen) then Delete UpM_Line
EndIf
Next
SetBuffer UpM_Buffer
End Function
;-------------------------------------------------------------------------------
;DrawMatrixScreen(Screen,X,Y,[Image?])
Function Matrix_DrawMatrixScreen(DrM_Screen,DrM_X,DrM_Y,DrM_Image=1)
Local DrM_Type.Matrix_Screen
DrM_Type.Matrix_Screen=Object.Matrix_Screen(DrM_Screen)
If DrM_Image=1 then DrawImage DrM_TypeImage,DrM_X,DrM_Y Else DrawBlock DrM_TypeImage,DrM_X,DrM_Y
End Function
;-------------------------------------------------------------------------------
;DeleteMatrixScreen(Screen)
Function Matrix_DeleteMatrixScreen(DeM_ScreenH)
Local DeM_Screen.Matrix_Screen,DeM_Matrix.Matrix_Line
DeM_Screen.Matrix_Screen=Object.Matrix_Screen(DeM_ScreenH)
FreeImage DeM_ScreenImage:Delete DeM_Screen
For DeM_Matrix.Matrix_Line=EAch Matrix_Line
if DeM_MatrixScreen=DeM_ScreenH then Delete DeM_Matrix
Next
End Function
;********************************* Types ***************************************
Type Matrix_Screen ;Der Type für die MatrixScreens
Field Image ;Das Bild
Field Speed ;Die Geschwindigkeit (in FPS)
Field Matrix ;Die benutzten MatrixLinien (Bank Handle)
Field Still ;Steht er still? (0,1)
Field Aktiv ;Ist er Aktiv? (0,1)
Field LastSecs ;Millisecs beim letzten Malen der Matrix
Field SecsAbs ;Abstand in Millisecs seit dem letzten Malen
Field Render ;Wie oft darf er Rendern?
Field Millis ;Zeit zwischen dem Rendern (in Millisecs)
End Type
;-------------------------------------------------------------------------------
Type Matrix_Line ;Der Type für die MatrixLinien
field Image ;Das Bild
Field X ;Die X-Position auf dem MatrixScreen
Field Y ;Die Y-Position auf dem MatrixScreen
Field Screen ;Der benutzte Screen (Type Handle)
Field Matrix ;Die benutzte Matrix (Bank Handle)
End Type
[/code:1:9197606424]

Und hier mal ein Beispiel für einen simplen Hintergrund:

[code:1:9197606424]
Graphics 800,600,32,1

Matrix=Matrix_CreateMatrix(10,0,20,0) ;Erstellt MatrixLinien (10 Stück, in Grüner Farbe)
Screen=Matrix_CreateMatrixScreen(800,600) ;Erstellt einen MatrixScreen (in Bildschirmgröße)
Matrix_MatrixScreenOptions(Screen,30,0,Matrix) ;Ändert die Optionen beim Screen (30 FPS, Matrix für die benutzten MatrixLinien)

While Not KeyHit(1)
Cls

Matrix_UpdateMatrix() ;Updated den/die MatrixScreen/s
Matrix_DrawMatrixScreen(Screen,0,0) ;Malt einen MatrixScreen auf den Bildschirm

Flip
SetBuffer BackBuffer()
wend
[/code:1:9197606424]
===
von ???
oh nein, bitte nich lycos :evil: langsam, nervende werbung und seit neustem funzen directlinks net mehr, weil die den referrer prüfen...

nem dir nen account bei home.pages.at und leg das bitte da drauf...
zugriff erfolgt dann per free.pages.at/username/filename

mfg 8)
===
von ???
schön schön :roll:
===
von ???
@OJay: Hab ich schon vor, nur hab ich diesen Screenshot schon vor ein paar Monaten dort Upgeloadet. Zurzeit geht da ja garnichts mehr. Hab jetzt seit 3 Wochen keinen FTP zugriff mehr!
===
von ???
Wiso setzt du andauernd den BackBuffer neu? Sollte es nicht so aussehn?

[code:1:47d26b7b6d]
Graphics 800,600,32,1
SetBuffer BackBuffer()

<snip>

While Not KeyHit(1)
Cls

Matrix_UpdateMatrix() ;Updated den/die MatrixScreen/s
Matrix_DrawMatrixScreen(Screen,0,0) ;Malt einen MatrixScreen auf den Bildschirm

Flip
wend
[/code:1:47d26b7b6d]

Noch ein Tip:
Je nach dem wer diesen Code verwendet, weisst du nicht in welchem Buffer sich dieser befindet. Da gibts einen kleinen Trick.

[code:1:47d26b7b6d]
image = CreateMatrix(100,120)

Function CreateMatrix(x,y)

savebuffer = GraphicsBuffer() ; hier wird der unbekannte Buffer gespeichert
newimage = CreateImage(x,y)
SetfBuffer ImageBuffer(newimage)

Text 10,10, "Dies ist ein Text"
Oval 20,20,10,15

SetBuffer savebuffer ; hier wird der unbekannte Buffer wieder aktiviert

Return newimage

End Function
[/code:1:47d26b7b6d]

Das hat den Vorteil das man sich nicht um die Verwaltung des Buffer mehr kümmern muss und das dieser auch nicht gelöscht wird.
===
von ???
Danke @morszeck
Ich hab mir schon ein paar mal überlegt, ob sowas geht. Bin aber bis jetzt nicht auf diesen Befehl gestoßen.

Edit:
Hab jetzt den Code verbessert

Und hier noch mal ein Beispiel mit 2 Screens (Der 2. läuft schneller und ist in einer anderen Farbe)

[code:1:cc7d664286]
Graphics 800,600,32,1

Matrix=Matrix_CreateMatrix(10,0,20,0) ;Erstellt MatrixLinien (10 Stück, in Grüner Farbe)
Screen=Matrix_CreateMatrixScreen(800,600) ;Erstellt einen MatrixScreen (in Bildschirmgröße)
Matrix_MatrixScreenOptions(Screen,30,0,Matrix) ;Ändert die Optionen beim Screen (30 FPS, Matrix für die benutzten MatrixLinien)

Matrix2=Matrix_CreateMatrix(10,20,20,0) ;Erstellt MatrixLinien (10 Stück, in Gelber Farbe)
Screen2=Matrix_CreateMatrixScreen(200,500) ;Erstellt einen MatrixScreen (200x500)
Matrix_MatrixScreenOptions(Screen2,60,0,Matrix2) ;Ändert die Optionen beim Screen (60 FPS, Matrix für die benutzten MatrixLinien)

While Not KeyHit(1)
Cls

Matrix_UpdateMatrix() ;Updated den/die MatrixScreen/s
Matrix_DrawMatrixScreen(Screen,0,0) ;Malt einen MatrixScreen auf den Bildschirm
Matrix_DrawMatrixScreen(Screen2,20,20,0) ;Malt einen MatrixScreen auf den Bildschirm
Color 250,0,0:rect 20,20,200,500,0 ;Rahmt den 2. Screen ein

Flip
SetBuffer BackBuffer()
wend
[/code:1:cc7d664286]

Falls noch irgendwer verbesserungsvorschläge hat, bitte posten



Suche:
(unterstützt mySQL Wildcards ala %)
Titel:
Text:
Autor: