[B2d,B+] Transparenz

Übersicht BlitzBasic Codearchiv

Neue Antwort erstellen

ShadowJumper

Betreff: [B2d,B+] Transparenz

 BeitragSo, Jul 08, 2007 17:44
Antworten mit Zitat
Benutzer-Profile anzeigen
ich hab mich mal daran versucht, transparenz mit BlitzPlus umzusetzen und es ist mir (mehr oder weniger) gelungen (falls ihr noch n paar stellen zum verbessern/beschleunigen findet sagt ma bescheid Very Happy )
Code: [AUSKLAPPEN]
Graphics 640, 480, 16, 2
bilda=LoadImage("bilda.png")
bildb=LoadImage("bildb.png")
bildc=CreateImage(80, 80)
Color 0, 0, 0
Repeat
zeit=MilliSecs()
x=MouseX()
y=MouseY()
SetBuffer ImageBuffer(bildc)
Cls
DrawImage bilda, 0, 0
For a = 79 To 0 Step -1
   For b = 79 To 0 Step -1
      If a-x>=0 And b-y>=0 Then
         SetBuffer ImageBuffer(bilda)
         LockBuffer ImageBuffer(bilda)
         rgba=ReadPixelFast (a, b)
         UnlockBuffer ImageBuffer(bilda)
         SetBuffer ImageBuffer(bildb)
         LockBuffer ImageBuffer(bildb)
         rgbb=ReadPixelFast (a-x, b-y)
         UnlockBuffer ImageBuffer(bildb)
         SetBuffer ImageBuffer(bildc)
         LockBuffer ImageBuffer(bildc)
         If (rgbb And $FF0000)/$10000=0 And (rgbb And $FF00)/$100=0 And (rgbb And $FF)=0 Then
            rgbc=(0 And $FF0000)*$10000+(0 And $FF00)*$100+(0 And $FF)
         Else
            rgbc=((rgba And $FF0000)/$10000+(rgbb And $FF0000)/$10000)/2*$10000+((rgba And $FF00)/$100+(rgbb And $FF00)/$100)/2*$100+((rgba And $FF)+(rgbb And $FF))/2
         EndIf
         WritePixelFast a, b, rgbc
         UnlockBuffer ImageBuffer(bildc)
      EndIf
   Next
Next
SetBuffer BackBuffer()
Cls
DrawImage bilda, 0, 0
DrawImage bildb, x, y
DrawImage bildc, 0, 0
Color 255, 255, 255
Text 80, 0, MilliSecs()-zeit
Flip
Until KeyHit(1)
End

die Bilder (nicht die Qualität bemängeln Mr. Green ):
user posted imageuser posted image
und für die mit ner Demo in *.bmp:
user posted imageuser posted image

dies ist zwar nur bedingt Echtzeit fähig, aber man kann damit z.B. eine bestimmte Transparenz erzeugen (z.B. 25%, 75%, etc.) (bevor ihr fragt, probiert es leiber erstmal aus)
wenn man nur auf kleinen Flächen eine Transparenz berechnet lässt es sich in Echtzeit nutzen
zudem ist es auch devon abhängig wie schnell der Computer ist (meiner: CPU=800MHz)
neben dem Bild wird eine weiße Zahl ausgegeben, welche für die Millisekunden für einen durchlauf der Schleife stehen, bitte das un eure Taktfrequenz posten
bei mir ist diese (bei keiner Transparenzberechnung) knapp 0 und bei voller schwank sie zwischen 110 und 120

Ps: mit n bissl rumspielen gibts vlt. noch mehr Möglicheiten
Bilder kostenlos hosten
lest und weint:
RAM - 512 MB; GrafikRAM - 32 MB; CPU - 800 MHz
Ps: ... und weint (vor lachen)
 

Marek

 BeitragSo, Jul 08, 2007 18:33
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich finds geil^^
(Die Kästchenzahl bezeiht sich auf die Anzahl der Kästchenvon bildb, die mit bilda überlappen)
1 Kästchen = 50MS
2 Kästchen = 100MS
3 Kästchen = 150MS
4 Kästchen = 200MS
5 Kästchen = 250MS
10 Kästchen = 500MS
16 Kästchen =800MS
Sprich: Pro Kästchen (mehr oder weniger) genau 50MS^^
Wer lesen kann ist klar im Vorteil...

ShadowJumper

 BeitragSo, Jul 08, 2007 19:34
Antworten mit Zitat
Benutzer-Profile anzeigen
@Marek: hast du den Debugger an?
das wirkt sich auch darauf aus
welche Taktfrequenz hat eigentlich dein Prozessor?

@all: ein Kästchen is 20x20 groß

werd dann später aber selbst nochmal testen (Opera leif während dessen, glaub ich^^)
Bilder kostenlos hosten
lest und weint:
RAM - 512 MB; GrafikRAM - 32 MB; CPU - 800 MHz
Ps: ... und weint (vor lachen)
 

Marek

 BeitragSo, Jul 08, 2007 20:39
Antworten mit Zitat
Benutzer-Profile anzeigen
Naja, ohne Debugger: 720 bei 16 Kästchen^^
Mein Prozessor: 3.00 GHz
MfG
Wer lesen kann ist klar im Vorteil...
 

$tankY

 BeitragSo, Jul 08, 2007 22:59
Antworten mit Zitat
Benutzer-Profile anzeigen
LOL, wenn bei mir BildA und BildB voll übereinanderlappen, braucht der gerade mal 60 ms pro durchlauf o_O
 

Marek

 BeitragSo, Jul 08, 2007 23:06
Antworten mit Zitat
Benutzer-Profile anzeigen
Liegt wohl an meinen Programmen, die (absichtlich) im Hintergrund laufen...^^
Wer lesen kann ist klar im Vorteil...
 

Matthias

Betreff: 10mal so schnell

 BeitragMo, Jul 09, 2007 15:40
Antworten mit Zitat
Benutzer-Profile anzeigen
Hay. Ich glaube nicht das es an deine Hintergrund Programme liegt. Es liegt mehr daran das du den ImageBuffer in der Schleife dauernt schliest und öffnest.

Habe dazu mal ein Kleines Beispiel gemacht wie es richtig schnell geht. Mann könnte es sicherlich noch schneller machen aber das reicht voll aus.

Volle Überblendung bei 50% Transparenz bei 1,87GHz CPU
Dein Beispiel 16Bit 1000-1100ms 32Bit 1050-1200ms
Mein Beispiel 16Bit 10-11ms 32Bit 12-13ms

Code: [AUSKLAPPEN]


Graphics 640, 480, 16, 2
bilda=LoadImage("bilda.png")
bildb=LoadImage("bildb.png")
SetBuffer BackBuffer()


Repeat
Zeit=MilliSecs()

Cls
DrawBlock BildA,0,0
TransImage(BildB,MouseX(),MouseY(),50)


FPSz=FPSz+1:Select MilliSecs()>FPSt+999:Case 1
FPSt=MilliSecs():FPS=FPSz:FPSz=0:End Select
Color 255, 255, 255
Text 100, 0, MilliSecs()-zeit+"  "+FPS

Flip
Until KeyDown(1)=1
End



Function TransImage(Img,MX,MY,Alpha)
TrA=64-Alpha*.64:TrB=Alpha*.64
Gr_W=GraphicsWidth()
Gr_H=GraphicsHeight()
Img_W=ImageWidth(Img)-1:Img_H=ImageHeight(Img)-1
ImgHan=ImageBuffer(Img):LockBuffer:LockBuffer ImgHan

For ZX=0 To Img_W:PX=ZX+MX:Select PX<Gr_W:Case 1
For ZY=0 To Img_H:Select ZY+MY<Gr_H:Case 1

  rgbA=ReadPixelFast(PX,ZY+MY)
  rgbB=ReadPixelFast(ZX,ZY,ImgHan)
    R=(rgbA Shl 8 Shr 24)*TrA+(rgbB Shl 8 Shr 24)*TrB
    G=(rgbA Shl 16 Shr 24)*TrA+(rgbB Shl 16 Shr 24)*TrB
    B=(rgbA Shl 24 Shr 24)*TrA+(rgbB Shl 24 Shr 24)*TrB
WritePixelFast PX,ZY+MY,(r Shr 6) Shl 16+(g Shr 6) Shl 8+(b Shr 6)

End Select:Next:End Select:Next:UnlockBuffer :UnlockBuffer ImgHan
End Function


Mfg Matthias
 

$tankY

 BeitragMo, Jul 09, 2007 17:46
Antworten mit Zitat
Benutzer-Profile anzeigen
Hm, deins hat sogar richtige Transparenz, das andere war ja nur beim Überlappen transparent. (12ms pro Schleifendurchlauf)
 

BIG BUG

 BeitragMo, Jul 09, 2007 23:24
Antworten mit Zitat
Benutzer-Profile anzeigen
Sorry ShadowJumper, aber solch eine Routine wie Deine, hat im Codearchiv nix verloren. Viel zu langsam(da ohne die hierfür notwendigen Kenntnisse programmiert), kaum Praxistauglichkeit(z.b. nicht gekapselt) sowie unkommentiert und unübersichtlich. Zudem gibt es sowieso schon ein paar Transparenzroutinen.

Hier eine nochmal schnellere Variante für berechnete 50% Transparenz(Ich denke mal, das dürfte dann die schnellste Plain B2D-Variante im Archiv sein):

Code: [AUSKLAPPEN]
Graphics 640, 480, 16, 2
bilda=LoadImage("bilda.png")
bildb=LoadImageBank("bildb.png")
SetBuffer BackBuffer()


Repeat
Zeit=MilliSecs()

Cls
DrawBlock BildA,0,0
DrawTranspImage(BildB,MouseX()-40,MouseY()-40)


FPSz=FPSz+1:Select MilliSecs()>FPSt+999:Case 1
FPSt=MilliSecs():FPS=FPSz:FPSz=0:End Select
Color 255, 255, 255
Text 100, 0, MilliSecs()-zeit+"  "+FPS

Flip 0
Until KeyDown(1)=1
End


;Läd ein Bild in eine Bank
Function LoadImageBank(file$)
 
  Local img, bank
  img  = LoadImage(file$)
  bank = CreateImageBank(img)
  FreeImage img
  Return bank

End Function


;Speichert ein Bild in einer Bank
Function CreateImageBank(image)

  Local bank
  Local offset
  Local hx
  Local hy

  bank = CreateBank(ImageWidth(image) * ImageHeight(image) * 4 + 4)

; Bildinformationen
  PokeShort bank, 0, ImageWidth(image)
  PokeShort bank, 2, ImageHeight(image)

; Bilddaten
  offset = 4
  For hy = 0 To ImageHeight(image) - 1
      For hx = 0 To ImageWidth(image) - 1
          PokeInt bank, offset, ReadPixel(hx, hy, ImageBuffer(image)) And $FFFFFF
          offset = offset + 4
      Next
  Next
  Return bank

End Function


;Zeichnet eine Imagebank halbtransparent(mit Clipping und Maskcolor)
Function DrawTranspImage(imagebank, posX, posY, maskcolor=$000000)

   Local startX, startY, endX, endY
   Local minX, minY, maxX, maxY
   Local imgWidth, imgHeight
   Local x, y, offX, offY, offset,lineSize, pixel

   ;clipping area (view port)
   minX = 0
   minY = 0 
   maxX = GraphicsWidth()  - 1
   maxY = GraphicsHeight() - 1
 
   ;image size   
   imgWidth  = PeekShort(imagebank, 0)
   imgHeight = PeekShort(imagebank, 2)
 
   ;calculate size of one line in the bank
   lineSize = imgWidth * 4

   ;bounding box
   startX = posX
   startY = posY
   endX   = posX + imgWidth - 1
   endY   = posY + imgHeight - 1

   If startX < minX Then offX = (minX-startX) * 4        : startX = minX
   If startY < minY Then offY = (minY-startY) * lineSize : startY = minY
   If endX   > maxX Then endX = maxX
   If endY   > maxY Then endY = maxY

   ;skip image width and height information
   offY = offY + 4

   ;lets start finally with the doing
   LockBuffer
   For y = startY To endY

      offset = offY + offX
      For x = startX To endX

         pixel = PeekInt(imagebank, offset) And $FFFFFF
         If pixel <> maskcolor Then
         ;mix color and write back
            pixel = (pixel And $FEFEFE) Shr 1 + (ReadPixelFast(x, y) And $FEFEFE) Shr 1
            WritePixelFast x, y, pixel
         EndIf

       offset = offset + 4
     Next
     offY = offY + lineSize

   Next
   UnlockBuffer

End Function
B3D-Exporter für Cinema4D!(V1.4)
MD2-Exporter für Cinema4D!(final)
  • Zuletzt bearbeitet von BIG BUG am Di, Jul 17, 2007 21:17, insgesamt einmal bearbeitet
 

Weazle25

 BeitragMo, Jul 16, 2007 20:50
Antworten mit Zitat
Benutzer-Profile anzeigen
BIG BUG hat Folgendes geschrieben:
[..](Ich denke mal, das dürfte dann die schnellste Plain B2D-Variante im Archiv sein):


Jetzt nicht mehr. Wink

Code: [AUSKLAPPEN]

;*** Zeichnet Bilder mit Transparenz
;*** 14.10.2005 by Triton, verbessert 18.08.2006 by Triton
;*** http://www.silizium-net.de
;*** überarbeitet 16.07.2007 by Weazle25

Const GfxWidth = 1024
Const GfxHeight = 768
Const GfxDepth = 32
Const GfxMode = 1

Graphics( GfxWidth, GfxHeight, GfxDepth, GfxMode )
SetBuffer( BackBuffer() )
HidePointer()
Global fpsrate,loops, fpstime

Type Image
   Field Width, Height, Bank
End Type

Local bild.Image = LoadImage2( ".\Test.bmp" )
Local bg.Image = LoadImage2( ".\Background.bmp" )
Global BankBuffer = CreateBank( GfxWidth * GfxHeight * 4 )

Color 255,255,255
SetBuffer BackBuffer()
Local a = 255
Local Mode = 0

While Not KeyDown(1)
   ;Cls2( $FF8080FF )
   drawalphaimage( bg, 0, 0, 255 )
   If MouseDown(1) Then a=a+5
   If MouseDown(2) Then a=a-5
   If a < 0 Then a = 0
   If a > 255 Then a = 255
   
   If KeyHit( 57 ) = 1 Then
      Mode = Mode + 1
      If Mode > 2 Then Mode = 0
   EndIf
   
   drawalphaimage( bild, MouseX(), MouseY(), a, Mode )
   Flip2()
   Color( 0, 0, 255 )
   
   Text 10,10, "Maustaste L/R zur Änderung der Deckung: "+a
   Text 10, 25, "Colormode: " + Mode
   Text 10, 40, fps()+" FPS"
   Flip 0
   ;Cls
Wend

End

;---
Function fps()
   loops = loops+1
   If MilliSecs() - fpstime > 1000 Then
      fpsrate = loops
      loops = 0
      fpstime = MilliSecs()
   End If
   Return fpsrate
   
End Function

Function Cls2( col )
   If BankBuffer = 0 Then RuntimeError( "BankBuffer = 0!" )
   Local X, Y
   For Y = 0 To GfxHeight - 1
      For X = 0 To GfxWidth - 1
         PokeInt( BankBuffer, ( ( Y * GfxWidth ) + X ) * 4, col )
      Next
   Next
End Function

Function Flip2()
   If BankBuffer = 0 Then RuntimeError( "BankBuffer = 0!" )
   Local X, Y
   ;SetBuffer( BackBuffer() )
   LockBuffer( BackBuffer() )
   For Y = 0 To GfxHeight - 1
      For X = 0 To GfxWidth - 1
         WritePixelFast( X, Y, PeekInt( BankBuffer, ( ( Y * GfxWidth ) + X ) * 4 ) )
      Next
   Next
   UnlockBuffer( BackBuffer() )
   ;SetBuffer( BackBuffer() )
End Function

Function LoadImage2.Image( FileName$ )
   Local oImg = LoadImage( FileName$ )
   If oImg = 0 Then Return
   Local nImg.Image = New Image
   nImg\Width = ImageWidth( oImg )
   nImg\Height = ImageHeight( oImg )
   nImg\Bank = CreateBank( nImg\Width * nImg\Height * 4 )
   SetBuffer( ImageBuffer( oImg ) )
   LockBuffer( ImageBuffer( oImg ) )
   Local X, Y, RGB
   For Y = 0 To nImg\Height - 1
      For X = 0 To nImg\Width - 1
         PokeInt( nImg\Bank, ( ( ( Y * nImg\Width ) + X ) * 4 ) + 0, ReadPixelFast( X, Y ) )
      Next
   Next
   UnlockBuffer( ImageBuffer( oImg ) )
   SetBuffer( BackBuffer() )
   FreeImage( oImg )
   Return nImg
End Function

;---
Function drawalphaimage( Img.Image, x, y, a, m = 0 )
   If a <= 0 Then Return
   If Img = Null Then Return
   Local scanx, scany, rgb, rgb2, rbg, gbg, bbg, rpic, gpic, bpic, rneu, gneu, bneu, rgbneu
   For scany = 0 To Img\Height-1
      For scanx= 0 To Img\Width-1
         If ( x + scanx ) < GfxWidth And ( y + scany ) < GfxHeight Then
            Select m
               Case 0
                  If a = 255 Then
                     rgb = PeekInt( Img\Bank, ( ( ( scany * Img\Width ) + scanx ) * 4 ) + 0 )
                     PokeInt( BankBuffer, ( ( ( scany + y ) * GfxWidth ) + ( scanx + x ) ) * 4, rgb )
                  Else
                     rgb2=PeekInt( BankBuffer, ( ( ( scany + y ) * GfxWidth ) + ( scanx + x ) ) * 4 )
                     rgb = PeekInt( Img\Bank, ( ( ( scany * Img\Width ) + scanx ) * 4 ) + 0 )
                     
                     rbg=(rgb2 And $FF0000)/$10000
                     gbg=(rgb2 And $FF00)/$100
                     bbg=rgb2 And $FF
                     
                     rpic = ( rgb And $FF0000 ) / $10000
                     gpic = ( rgb And $FF00 ) / $100
                     bpic = rgb And $FF
                     
                     rneu=rbg*(1.0-(a/255.0))+rpic*a/255.0
                     gneu=gbg*(1.0-(a/255.0))+gpic*a/255.0
                     bneu=bbg*(1.0-(a/255.0))+bpic*a/255.0
                     rgbneu=255*$1000000 + rneu*$10000 + gneu*$100 + bneu
                     
                     PokeInt( BankBuffer, ( ( ( scany + y ) * GfxWidth ) + ( scanx + x ) ) * 4, rgbneu )
                  EndIf
               Case 1
                  rgb2=PeekInt( BankBuffer, ( ( ( scany + y ) * GfxWidth ) + ( scanx + x ) ) * 4 )
                  rgb = PeekInt( Img\Bank, ( ( ( scany * Img\Width ) + scanx ) * 4 ) + 0 )
                  
                  rbg=(rgb2 And $FF0000)/$10000
                  gbg=(rgb2 And $FF00)/$100
                  bbg=rgb2 And $FF
                  
                  rpic = ( rgb And $FF0000 ) / $10000
                  gpic = ( rgb And $FF00 ) / $100
                  bpic = rgb And $FF
                  
                  rneu=rbg*(1.0-(a/255.0))+rpic*a/255.0
                  gneu=gbg*(1.0-(a/255.0))+gpic*a/255.0
                  bneu=bbg*(1.0-(a/255.0))+bpic*a/255.0
                  rgbneu=255*$1000000 + rneu*$10000 + gneu*$100 + bneu
                  
                  rgbneu = rgb2 Xor rgbneu
                  
                  PokeInt( BankBuffer, ( ( ( scany + y ) * GfxWidth ) + ( scanx + x ) ) * 4, rgbneu )
               Case 2
                  rgb2=PeekInt( BankBuffer, ( ( ( scany + y ) * GfxWidth ) + ( scanx + x ) ) * 4 )
                  rgb = PeekInt( Img\Bank, ( ( ( scany * Img\Width ) + scanx ) * 4 ) + 0 )
                  
                  rgbneu = rgb2 And rgb
                  
                  PokeInt( BankBuffer, ( ( ( scany + y ) * GfxWidth ) + ( scanx + x ) ) * 4, rgbneu )
            End Select
         EndIf
      Next
   Next
   ;UnlockBuffer BackBuffer()
End Function


Der Code stammt ursprünglich von Triton und wurde von mir überarbeitet.
( Der Original-Code ist auch irgendwo hier im Codearchiv. )

Ich habe den Code mit folgenden Einstellungen getestet:
Auflösung: 1024, 768, 32, 1
Background-Image: 1024x768 Pixel
Overlay-Image: 100x100 Pixel
Rechner: Laptop
CPU: P 1,6 GHz Dual Core
RAM: 2 GB
GraKa: ATI Radeon Xpress 1250 ( 256 MB )
OS: Vista HP

Ergebnis: 20-25 FPS
( andere getestete Codes schafften es mit viel Glück und Rückenwind noch auf 15 FPS )
Leider reicht das immer noch nicht für Realtime. Confused

Übrigens könnte man noch ein paar FPS mehr rauskitzeln in dem man den Code von Banks auf statische Arrays umstellt.
Bei B+ könnte man bei der Funktion Flip2() vielleicht noch etwas Speed rausholen in dem man die Pixel mit LockedPixels(), LockedFormat(), LockedPitch und Bank-Funktionen direkt einzeichnet.
Allerdings habe ich kein B+ weshalb ich das auch nicht testen konnte.

Viel Spass beim Testen


Gruss
Weazle

PS: Welche FPS-Raten habt ihr? Kennt ihr schnellere Codes?
( Ich glaube ich habe mal irgendwo was von ner DLL für 2D-Alpha gelesen aber vielleicht hab ich mich auch getäuscht.)
 

BIG BUG

 BeitragDi, Jul 17, 2007 21:32
Antworten mit Zitat
Benutzer-Profile anzeigen
Weazle25 hat Folgendes geschrieben:
BIG BUG hat Folgendes geschrieben:
[..](Ich denke mal, das dürfte dann die schnellste Plain B2D-Variante im Archiv sein):


Jetzt nicht mehr. Wink

Wenn Du da mal nicht irrst Razz

Vermutlich hast Du bei Deinen Messungen vergessen das FLIP2 auszukommentieren.

Hier mal die FPS, wie es bei mir aussah(mit den obigen Bildern):
Deins: 25 FPS
Matthias seins: 91 FPS
Meins: 185 FPS

Ansonsten sind Banks auch nicht bemerkenswert langsamer als Dims, aber dafür halt wesentlich flexibler. Eine Umstellung macht hier keinen Sinn.
Durch dieses Locked-Zeugs in BlitzPlus wäre aber vermutlich eine enorme Geschwindigkeitssteigerung möglich.

Habe bei meinem Code oben noch ein LoadImageBank hinzugefügt und den Break-Point herausgenommen.
B3D-Exporter für Cinema4D!(V1.4)
MD2-Exporter für Cinema4D!(final)
 

Weazle25

 BeitragMi, Jul 18, 2007 20:10
Antworten mit Zitat
Benutzer-Profile anzeigen
BIG BUG hat Folgendes geschrieben:

Vermutlich hast Du bei Deinen Messungen vergessen das FLIP2 auszukommentieren.


Flip2() zeichnet den BankBuffer auf den BackBuffer().
Wenn man also Flip2() auskommentiert ist gar nichts zu sehen.

BIG BUG hat Folgendes geschrieben:

Hier mal die FPS, wie es bei mir aussah(mit den obigen Bildern):
Deins: 25 FPS
Matthias seins: 91 FPS
Meins: 185 FPS


Ok wenn du SO testest dann muss dein Code schneller sein.
Ich bin allerdings davon ausgegangen das die Alphaimages auf ein grosses Hintergrundbild gezeichnet werden sollen.
So wie man es bei 2D Spielen (z.B. Jump&Run) machen würde.
Daher wird bei meinem Code immer ein 1024x768 Image in BankBuffer gespeichert.
Flip2() zeichnet daher auch immer den kompletten BankBuffer auf den BackBuffer().

Nachteil: Es wird immer der komplette BankBuffer auf den BackBuffer() gezeichnet egal ob irgendwelche Pixel geändert wurden oder nicht.

Vorteil: Auch bei mehreren Alphaimages bleibt die FPS nahezu stabil.
So konnte ich mit 40 Alphaimages immer noch 10 FPS erzielen und 40 Alphaimages sind ja nicht gerade wenig.

Man könnte aber noch ein paar FPS rausholen in dem man das Hintergrundbild weiterhin mit DrawBlock() zeichnet und dann nur die geänderten Pixel aus dem BankBuffer ausliesst und in den BackBuffer() schreibt.

BIG BUG hat Folgendes geschrieben:

Habe bei meinem Code oben noch ein LoadImageBank hinzugefügt und den Break-Point herausgenommen.


Werd deinen Code morgen mal testen. Heute habe ich keine Zeit mehr.


Gruss
Weazle
 

BIG BUG

 BeitragMi, Jul 18, 2007 22:24
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich hatte das schon auch über einem bildschirmfüllenden Hintergrund gezeichnet.
Der Vorteil Deiner Routine ist aber natürlich, dass diese bei vielen großen transparenten Bildern eben schneller ist. Für GUIs oder Retroauflösung 320x200 ist das sicherlich gut brauchbar, für z.B. ein JumpNRun leider noch zu langsam.
Mit Matthias oder meiner Routine könnte man da zumindest vereinzelte transparente Geister zeichnen.

Die allerschnellste Lösung wäre dann wie Du ja auch schon angedeutet hast eine Kombination, also dass alle Zeichenbefehle zweimal ausgeführt werden, einmal innerhalb der Banks und einmal als Grafik und somit nur noch die transparenten Pixel neu gezeichnet werden müssen...
B3D-Exporter für Cinema4D!(V1.4)
MD2-Exporter für Cinema4D!(final)

TimBo

 BeitragSa, Jan 05, 2008 14:08
Antworten mit Zitat
Benutzer-Profile anzeigen
*Edit*
mfg Tim Borowski // CPU: Ryzen 2700x GPU: Nvidia RTX 2070 OC (Gigabyte) Ram: 16GB DDR4 @ 3000MHz OS: Windows 10
Stolzer Gewinner des BCC 25 & BCC 31
hat einen ersten Preis in der 1. Runde beim BWInf 2010/2011 & 2011/12 mit BlitzBasic erreicht.

Neue Antwort erstellen


Übersicht BlitzBasic Codearchiv

Nach Oben

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group