Messages

bestätigt, geht jetzt auch bei 32 Bit Farbtiefe.

Jetzt ist mir allerdings was anderes aufgefallen und zwar im Zusammenhang mit ZOOMSPRITE und ROTOZOOMSPRITE.
In diesem Beispiel http://www.glbasic.com/forum/viewtopic.php?id=905 wird ein einzelnes Objekt 1000 mal dargestellt und sollte eigentlich immer gleich aussehen (zumindest die Farbe). Die korrekte Farbe wird jedoch nur gezeigt, wenn das Objekt in Originalgröße gezeigt wird. Wird es mit ZOOMSPRITE oder ROTOZOOMSPRITE um einen bestimmten Faktor verkleinert, ist die Farbe anders. Sieht mir dann fast nach der Transparenzfarbe aus.

also so

Code (glbasic) Select Expand

 FILLRECT 0, 0, 10, 10, RGB(255, 0, 128)
  DRAWLINE 0, 5, 10, 5, RGB(RND(255), 255, 255)
  DRAWLINE 5, 0, 5, 10, RGB(RND(255), 255, 255)
  DRAWLINE 1, 1, 9, 9, RGB(RND(255), 255, 255)
  DRAWLINE 9, 1, 1, 9, RGB(RND(255), 255, 255)gibts bei Verkleinerungen andere Farben. Sollte doch auch nicht sein denke ich.

Ohne FILLRECT sehen alle Objekte gleichfarbig aus.

*kopfkratz* hoffe ich habe nicht schon Halos

Fein, dann stehe ich zumindest nicht alleine da

Was heißt hier scheiß Geforce Karten. Sieht für mich nach einem eindeutigen Käfer in GRABSPRITE aus. Wobei es natürlich eine feine Sache wäre, wenn SETSCREEN einen Parameter für die Farbtiefe hätte.

Der Hinweis mit der Farbtiefe war gut. Bei 16 Bit geht, bei 32 Bit nicht. Seltsam ist nur, daß, wenn ich z.B. die Transparenzfarbe in einer BMP-Datei verwende und als Sprite lade, es auch bei 32 Bit einwandfrei funktioniert.

Hat also vielleicht nur Grabsprite damit ein Problemchen?

Achja, Graka ist übrigens eine GeForce Go 7600

jo genau so dachte ich mir das auch. Betriebssystem ist WinXP Pro. Graka muss ich heute abend mal nachsehen.

Aber Farbtiefe ist ein guter Hinweis. Da probier ich noch mal ein wenig aus und geb Laut.

Danke schon mal.

Schranz0r hatte beim Schneegestöber empholen, den Hintergrund der angezeigten Grafik mit der Transparenzfarbe RGB(255, 0, 128) zu hinterlegen.

Code (glbasic) Select Expand

 FILLRECT 0,0,10,10, RGB(0xff, 0x00, 0x80)
  DRAWLINE 0, 5, 10, 5, RGB(RND(255), 255, 255)
  GRABSPRITE 0, 0, 0, 10, 10Nun habe ich jedoch das Problem, wenn ich das Sprite anzeigen will, die Transparenzfarbe alles andere als transparent ist. In einem Beispiel von Gernot hab ich mal gesehen, daß er die Grafik dann erst als BMP speichert und gleich wieder lädt.

Gehört das so? Warum funzt das nicht gleich mit GRABSPRITE?
Oder habe ich etwas Grundlegendes übersehen?

hmmm habe jetzt nicht wirklich Ahnung, wie Zeilenvorschübe für GP2X aussehen, aber könntest es mal mit einem Editor versuchen, der als Zeilenvorschub nur LF statt CRLF setzt, z.B. mit WinVI

http://www.winvi.de/de/

bei einer Installation unter Windows ist glaube ich standardmäßig CRLF eingestellt. Das kannst du unter "Optionen - Einstellungen - Dateityp" ändern.

Gefällt mir gut! Gibt's das auch in 3D? hehehe

yep, sobald ich einen Schimmer von 3D in GLBasic hab ;-)

@S.O.P.M
ich würde trotzdem ein Update vorziehen. In der Regel werden damit (zumindest bei den kleinen Ups) selten neue Funktionalitäten hinzugefügt bzw. bestehde geändert, sondern Fehler behoben. Könntest ja auch eine Sicherungskopie des GLBasic-Ordners machen.

sitmmt auf Transparenz hab ich hierbei gar nicht geachtet, ist mir aber bei dem Gewimmel auch nicht aufgefallen. Thx für den Hinweis.

Wieso DIM statt TYPEs? Sind die Geschwindigkeitsunterschiede wirklich so enorm? Hier war mir aber auch die bessere Lesbarkeit wichtiger als das letzte Quentchen Performance.
In BlitzMax hatte ich aber auch schon etliche hundert Ojbkete gleichzeitig über den Bildschirm bewegt (mit TYPEs). Konnte keine Geschwindigkeitsprobleme sehen, wobei ich zugeben muss, daß ich auch keine genauen Messungen vorgenommen habe.

Ehrlich gesagt so ganz verstanden habe ich das auch noch nicht, warum man nicht gleich mit DIM hier arbeiten kann oder mache noch etwas falsch. Auf jeden Fall kann man mit DIMPUSH neue Einträge in ein Array einfügen, benötigt dazu allerdings eine Hilfsvariable vom gleichen Typ.

Folgendes kleine Beispiel kann das vielleicht verdeutlichen

Code (glbasic) Select Expand

TYPE ObjectProperties
  PosX
  PosY
  Mode
  State
ENDTYPE

GLOBAL Object[] AS ObjectProperties   // Array
GLOBAL newObject AS ObjectProperties  // Hilfsvariable zum Einfügen in das Array

// 1. Eintrag erzeugen und mit DIMPUSH ins Array eintragen
newObject.PosX = 10
newObject.PosY = 10
newObject.Mode = 1
newObject.State = 0
DIMPUSH Object[], newObject  

// 2. Eintrag
newObject.PosX = 20
newObject.PosY = 30
newObject.Mode = 0
newObject.State = 1
DIMPUSH Object[], newObject

// .... weitere Einträge ...

// zur Kontrolle am Bildschirm ausgeben
FOREACH newObject IN Object[]
  PRINT newObject.PosX, 0, y
  INC y, 15
  PRINT newObject.PosY, 0, y
  INC y, 15
  PRINT newObject.Mode, 0, y
  INC y, 15
  PRINT newObject.State, 0, y
  INC y, 25
NEXT

SHOWSCREEN
MOUSEWAIT
END

I just started in programming in GLBasic and I'm surprised how easy it is to create nice effects. This simple example shows a snow flurry which should be more or less realistic ;-)))

Code (glbasic) Select Expand

// --------------------------------- //
// Project: schnee
// Start: Friday, June 15, 2007
// IDE Version: 4.218

// a simple snow flurry

// TYPE declaration for a snowflake
TYPE tSnowFlake
  x            // X - position
  y            // Y - position
  size         // size of a snowflake
  speed        // speed with which the flakes fall to to ground
  rotate       // flag if a flake will rotate while falling
  angle        // value for the libration of the snowflakes
ENDTYPE

GLOBAL SnowFlakes[] AS tSnowFlake   // an array for our snowflakes
GLOBAL newFlake AS tSnowFlake       // a single flake to insert into the array

GLOBAL screen_width, screen_height  // current screen size

// Konstanten
MAX_SNOWFLAKES = 1000               // maximum count of the flakes


// Hauptprogramm
Init_Snow()                         // initialisation
WHILE TRUE
  Update_Snow()                     // show the snow flurry
  SHOWSCREEN
WEND




// ------------------------------------------------------------- //
// -=#  INIT_SNOW  #=-
// ------------------------------------------------------------- //
FUNCTION Init_Snow:

  LOCAL i

  // draw the snow flake
  DRAWLINE 0, 5, 10, 5, RGB(RND(255), 255, 255)
  DRAWLINE 5, 0, 5, 10, RGB(RND(255), 255, 255)
  DRAWLINE 1, 1, 9, 9, RGB(RND(255), 255, 255)
  DRAWLINE 9, 1, 1, 9, RGB(RND(255), 255, 255)

  // store the "artwork" in a sprite
  GRABSPRITE 0, 0, 0, 10, 10

  // get the current screen size
  GETSCREENSIZE screen_width, screen_height

  // now draw the snow flakes
  // - the position is randomized all over the screen
  // - the falling speed should be 0.1 to 1.5 pixels per cycle
  //   in case the RND() function returns a Null we will set
  //   the speed to 0.5
  // - the size should be 0.1 to 1 of the original sprite
  // - the field "rotate" will tell us if a snowflake will rotate or not
  //   function RND(1) will return a 0 = not rotate or 1 = rotate
  // - for the libration of the flakes we will use the SIN() function
  //   see function Update_Snow()
  // - last we store the new snowflake the the array SnowFlakes[]
  FOR i = 1 TO MAX_SNOWFLAKES
    newFlake.x = RND(screen_width)
    newFlake.y = RND(screen_height)
    newFlake.speed = RND(150) / 100
    IF newFlake.speed = 0
      newFlake.speed = 0.5
    ENDIF
    newFlake.size = RND(10) / 10
    newFlake.rotate = RND(1)
    newFlake.angle = RND(360)
    DIMPUSH SnowFlakes[], newFlake
  NEXT

ENDFUNCTION // INIT_SNOW


// ------------------------------------------------------------- //
// -=#  UPDATE_SNOW  #=-
// ------------------------------------------------------------- //
FUNCTION Update_Snow:

  LOCAL lsnow AS tSnowFlake

  FOREACH lsnow IN SnowFlakes[]

    // rotate or not?
    IF lsnow.rotate
      // if rotate then increase the rotation for the next cycle by one
      ROTOZOOMSPRITE 0, lsnow.x, lsnow.y, lsnow.rotate, lsnow.size
      INC lsnow.rotate, 1
    ELSE
      // otherwise only display the flake in the given size
      ZOOMSPRITE 0, lsnow.x, lsnow.y, lsnow.size, lsnow.size
    ENDIF

    INC lsnow.y, lsnow.speed         // calculate new Y position
    INC lsnow.angle, 2               // increase value for libration
    INC lsnow.x, SIN(lsnow.angle)    // and add it to the X position
    IF lsnow.y > screen_height       // if a flake will disappear on the ground of the screen
      lsnow.y = 0                    // then we show it again at the top
      lsnow.x = RND(screen_width)
    ENDIF

  NEXT

ENDFUNCTION // UPDATE_SNOW

Auweia, übersetzen, na mal sehen.

@Antidote
seltsam, hast das neueste Update gezogen? Ansonsten versuch vielleicht mal in der Funktion Update_Snow() statt

Code (glbasic) Select Expand

LOCAL lsnow

LOCAL lsnow AS tSnowFlakezu schreiben, vielleicht hilfts

Neuauflage: Die meisten Beiträge sind leider leer

Gehe ich recht in der Annahme, daß die RND()-Funktion immer nur Ganzzahlen zurückliefert? Oder habe ich irgend etwas übersehen?

Ich kann mir zwar behelfen, indem ich statt "RND(3)" mit "RND(30) / 10" rechne, hätte es aber trotzdem gerne bestätigt.

Merci beaucoup

Tach auch,

eben erst Freischaltcode erhalten *freu*.

Vorschlag: Diesen Thread fixieren.

Wünsche:

- wurde glaube ich schon gesagt: erzwungene Variablendeklaration (explicit, strict oder ähnliches), erleichtert einem das Leben vor allem bei etwas größeren Sachen ungemein

- was Slayer mit den Funktionen in Types angedacht hat (so in der Art wie in BlitzMax) fände ich auch toll. Ich sehe es zwar nicht unbedingt als lebensnotwendig an, GLBasis mit OOP auszustatten, aber es lässt sich ungemein elegant damit arbeiten. Also Gernot, wenn du mal ein ordentliches Stück Zeit hast .... ;-)

Ansonsten: Großes Lob an GLBasic, hat mich bis jetzt sehr beeindruckt.