Topics

[#include "xxx.h"]

zwei Verständnisfragen:

1. Gilt #include "xxx.h" für INLINE .. ENDINLINE ?

2. was steckt hinter libPNG und gilt das nur für OS-X?

Block kommentieren arbeitet falsch, wenn die erste Zeile ein Kommentar ist.

Beispiel:

Code (glbasic) Select Expand


// Kommentar
FOR i = 1 TO 9
 PRINT i, 0, i * 20
NEXT


Daraus wird nach STRG + K

Code (glbasic) Select Expand


Kommentar
R i = 1 TO 9
 int i, 0, i * 20
XT


Drei GLBasic-Programmier werden von den bösen C++-Jüngern gefangen genommen und sollen gezwungen werden, Lochkarten zu stanzen. Der C++ - Häuptling gibt den dreien eine Chance, diesem Schicksal zu entgehen.

Er hat 5 Federn, 3 weiße und 2 rote. Die drei GLBasic-Programmierer werden hintereinander an drei Pfähle gebunden, sodaß der 3. die beiden vorderen sieht, der zweite noch den 1. und der 1. natürlich keinen. Jeder bekommt per Zufall eine Feder ins Haar gesteckt.

Wenn einer der drei sagen kann, welche Farbe seine Feder hat, so sind sie wieder frei.

Es dauert geschlagene 15 Minuten, bis einer antwortet ... und richtig antwortet.


Frage:
Wer von den dreien antwortet und welche Farbe hat seine Feder?


Wer das schon kennt, bitte nicht ausplärren. Ich habs eben erst gehört und fand das eine ganz nette Knobelei

Zum Verständnis:

Kann ich bei X_CAMERAUP einen beliebigen Vektor angeben? Also z.B.

X_CAMERAUP 0.5, -0.7, 2*pi

Oder immer nur genau eine Achse in pos. oder neg. Richtung?

jaja ich habs noch nicht ganz aufgegeben. Trotz rudimentärem Verständnis für Trigonometrie und ähnliche Schweinereien versuche ich mich immer noch mal in 3D durch den Weltraum zu bewegen, der ja bekanntlich keinen Boden hat. Somit sollte ich meine Kamera ja auch in alle Richtungen frei bewegen können.

Habe mir die Formeln, die hier im Forum dazu geschrieben wurden, immer wieder inhaliert und scheinbar doch nicht wirklich verstanden.

Im folgenden Beispiel ist die Kamera erst einmal auf 0,0,0 gesetzt. Um die Kamera hab ich willkürlich 50 Kuben verstreut (3Dprimitives.gbas aus Common-Ordner einbinden). Nun will ich mit den Cursortasten die Kamera frei bewegen können.

Links - rechts für Bewegung auf X-Z
Oben- unten für Bewegung auf Y-Z

bewege ich nach dem Programmstart die Kamera links-rechts, klappt das wunderbar. Bei oben-unten nur bis Winkel 90 (bzw. 270). dann wird dort die Bewegungsrichtung umgekehrt.

Weiterhin, wenn ich die Kamera z.B. ein wenig nach oben oder unten bewege und dann wieder links-rechts drehe, scheint die Bewegung einer Kurve zu folgen und nicht mehr einer Geraden.

Ich bin ehrlich verwirrt.
Helft einem armen Nicht-Mathematiker.

Code (glbasic) Select Expand

TYPE t_vertex
  x; y; z
ENDTYPE


TYPE t_camera
  pos AS t_vertex
  delta AS t_vertex
  phi                  // angle x-z
  psi                  // angle y-z
ENDTYPE
GLOBAL cam AS t_camera

TYPE t_3dobj
  pos AS t_vertex
  object
  texture
  rotate AS t_vertex
  angle AS t_vertex
ENDTYPE
GLOBAL new3dobj AS t_3dobj
GLOBAL d3dobj[] AS t_3dobj

TYPE t_ship
  speed
  max_speed = 5
ENDTYPE
GLOBAL ship AS t_ship


LOADSPRITE "lava01.bmp", 0

FOR i = 0 TO 50
  CreateCube(i, RAND(20, 50), RGB(128, 128, 128))
  new3dobj.pos.x = RAND(-500, 500)
  new3dobj.pos.y = RAND(-400, 400)
  new3dobj.pos.z = RAND(-400, 500)
  new3dobj.object = i
  new3dobj.texture = 0
  new3dobj.rotate.x = RAND(-10, 10) / 10
  new3dobj.rotate.y = RAND(-10, 10) / 10
  new3dobj.rotate.z = RAND(-10, 10) / 10
  DIMPUSH d3dobj[], new3dobj
NEXT


GLOBAL KEY_LEFT = 203
GLOBAL KEY_RIGHT = 205
GLOBAL KEY_UP = 200
GLOBAL KEY_DOWN = 208
GLOBAL KEY_W = 17          //accellarate
GLOBAL KEY_S = 31          //break

needcalc = TRUE

WHILE TRUE

  WHILE cam.phi > 360; DEC cam.phi, 360; WEND
  WHILE cam.phi < 0; INC cam.phi, 360; WEND
  WHILE cam.psi > 360; DEC cam.psi, 360; WEND
  WHILE cam.psi < 0; INC cam.psi, 360; WEND

  IF KEY(KEY_LEFT)
    DEC cam.phi, 1
    needcalc = TRUE
  ENDIF

  IF KEY(KEY_RIGHT)
    INC cam.phi, 1
    needcalc = TRUE
  ENDIF

  IF KEY(KEY_UP)
    DEC cam.psi, 1
    needcalc = TRUE
  ENDIF

  IF KEY(KEY_DOWN)
    INC cam.psi, 1
    needcalc = TRUE
  ENDIF

  IF needcalc = TRUE
//    IF cam.psi >= 90 AND cam.psi < 270
//      cam.delta.x = COS(cam.phi) * -COS(cam.psi)
//      cam.delta.y = -SIN(cam.psi)
//      cam.delta.z = -SIN(cam.phi) * -COS(cam.psi)
//    ELSE
      cam.delta.x = COS(cam.phi) * COS(cam.psi)
      cam.delta.y = SIN(cam.psi)
      cam.delta.z = -SIN(cam.phi) * COS(cam.psi)
//    ENDIF
    needcalc = FALSE
  ENDIF

  IF KEY(KEY_W)
    INC ship.speed, 0.01
    IF ship.speed > ship.max_speed THEN ship.speed = ship.max_speed
  ENDIF

  IF KEY(KEY_S)
    DEC ship.speed, 0.01
    IF ship.speed < 0 THEN ship.speed = 0
  ENDIF

  INC cam.pos.x, cam.delta.x * ship.speed
  INC cam.pos.y, cam.delta.y * ship.speed
  INC cam.pos.z, cam.delta.z * ship.speed

  X_MAKE3D 1, 1000, 45
  X_CAMERA cam.pos.x, cam.pos.y, cam.pos.z, cam.pos.x+cam.delta.x, cam.pos.y+cam.delta.y, cam.pos.z+cam.delta.z

  FOREACH obj IN d3dobj[]
    X_MOVEMENT obj.pos.x, obj.pos.y, obj.pos.z
    X_ROTATION obj.angle.x, 1, 0, 0
    INC obj.angle.x, obj.rotate.x
    X_ROTATION obj.angle.y, 0, 1, 0
    INC obj.angle.y, obj.rotate.y
    X_ROTATION obj.angle.z, 0, 0, 1
    INC obj.angle.z, obj.rotate.z
    X_SETTEXTURE obj.texture, -1
    X_DRAWOBJ obj.object, 0
  NEXT
  //X_DRAWAXES 0, 0, 0
  X_MAKE2D
  PRINT "Speed: " + (INTEGER(ship.speed * 100)), 0, 0
  PRINT "PHI:   " + cam.phi, 0, 20
  PRINT "PSI:   " + cam.psi, 0, 40
  SHOWSCREEN

WEND


// ------------------------------------------------------------- //
// ---  RAND  ---
// ------------------------------------------------------------- //
FUNCTION RAND: minimum, maximum
  RETURN minimum + RND(-minimum + maximum)
ENDFUNCTION // RAND

Ich wünsche mir zu Weihnachten verkettete Listen in GLBasic.

Klar sind Arrays in GL einfach zu handhaben und mit REDIM/DIMPUSH auch sehr schön dynamisch zu verwalten. Auch die Performance ist in Ordnung, solange man nur einige hundert Elemente darin verwaltet. Werden es jedoch einige Tausend, geht der Rechner schnell in die Knie, vor allem wenn man während der Hauptschleife mit REDIM & Co arbeitet.

Wenn ich das richtig verstanden habe, wird bei jedem REDIM/DIMPUHS das komplette Array umgeschaufelt, also Speicher für die neue Größe allokieren, Daten umschaufeln, Speicher für das alte Array freigeben. Je größer das Array umso mehr Zeit wird dafür benötigt.

nun ja, irgendwie komme ich über das Space-Shooter-Stadium nicht so richtig hinaus. Jetzt habe ich mich gefragt, wie die das bei den alten Shooter-Spielen so hinbekommen haben, daß die Gegner nicht einfach plump auf einen zufliegen, sondern mehr oder minder kunstvolle Flugfiguren darstellen.

Nach etlichem probieren ist das hier rausgekommen, was ich jetzt mal als Grundlage für meine weiteren "Forschungen" auf diesem Gebiet nehme

Dargestellt werden 10 "Raumschiffe", die auf einer kreisförmigen Bahn in den Bildschirm einfliegen, dann dort dreimal im Kreis fliegen und den Bildschirm wieder verlassen. Vielleicht hat ja jemand einen Tip, wie man das eleganter lösen könnte.

Code (glbasic) Select Expand

// flight course
TYPE t_course
  x
  y
ENDTYPE
LOCAL newcourse AS t_course
LOCAL course[] AS t_course

// the enemies
TYPE t_enemy
  sprite
  course_index
ENDTYPE
LOCAL newenemy AS t_enemy
LOCAL enemy[] AS t_enemy


LOCAL scx, scy
GETSCREENSIZE scx, scy

// create a new course
LOCAL i
FOR i = 0 TO 89 STEP 2           // flight into the screen
  newcourse.x = scx / 2 * SIN(i+270) + scx / 2
  newcourse.y = scy / 2 * COS(i+270) + scy / 4
  DIMPUSH course[], newcourse
NEXT

LOCAL count
FOR count = 0 TO 2               // then do a circle three times
  FOR i = 0 TO 359 STEP 3        // in the center of the screen
    newcourse.x = scy / 4 * SIN(i) + scx / 2
    newcourse.y = scy / 4 * COS(i) + scy / 2
    DIMPUSH course[], newcourse
  NEXT
NEXT

FOR i = 0 TO 89 STEP 2           // and say good bye
  newcourse.x = scx / 2 * SIN(i) + scx / 2
  newcourse.y = scy / 2 * COS(i) + scy / 4
  DIMPUSH course[], newcourse
NEXT

// simple enemy sprite
DRAWRECT 0, 0, 20, 20, RGB(196, 196, 196)
GRABSPRITE 0, 0, 0, 20, 20

LOCAL index = 0, delay
LOCAL max_idx = LEN(course[]) - 1
LOCAL max_enemy = 10, count_enemy = 0

// mail loop
WHILE TRUE

  // create a new enemy every 350 ms but not more than 10 totally
  IF GETTIMERALL() > delay AND count_enemy <= max_enemy
    INC count_enemy, 1
    newenemy.sprite = 0
    newenemy.course_index = 0
    DIMPUSH enemy[], newenemy
    delay = GETTIMERALL() + 350
  ENDIF

  // display enemy sprites
  FOREACH e IN enemy[]
    DRAWSPRITE e.sprite, course[e.course_index].x, course[e.course_index].y
    INC e.course_index, 1
    IF e.course_index > max_idx THEN DELETE e
  NEXT

  // start again if all enemies of the previos wave have left
  IF LEN(enemy[]) = 0 THEN count_enemy = 0

  SHOWSCREEN

WEND

Gibt es zu diesem Tool eine etwas ausführlichere Beschreibung. In der Hilfe ist das leider nur mit einem nicht sehr hilfreichen Satz dokumentiert.

- müssen alle Dateien manuell eingebunden werden? Ganze Verzeichnisse scheinen nicht möglich zu sein
- wie füge ein Desktop-Icon hinzu? Einfach durch Auswahl der entsprechenden ICO-Datei aus der Liste?

Eine kurze Doku wäre super.

Nach einem Internet-Update wird ja zunächst die Datei log.gbas angezeigt. Wenn ich dann ein bestehendes Projekt öffnen will, werde ich gefragt, ob ich die bestehende Datei überschreiben will

Erst nach einem Neustart von GLBaisc funktioniert alles wie gewünscht.

Code (glbasic) Select Expand

LIMITFPS 20
fac = 50
WHILE TRUE
  FOR i = 0 TO 359
    x = fac * SIN(i) + 320
    y = fac * COS(i) + 240
    SETPIXEL x + RAND(-5, 5), y + RAND(-5, 5), RGB(128, 128, 128)
    SETPIXEL x + RAND(-10, 10), y + RAND(-10, 10), RGB(176, 176, 176)
    SETPIXEL x + RAND(-20, 20), y + RAND(-20, 20), RGB(208, 208, 208)
    SETPIXEL x + RAND(-30, 30), y + RAND(-30, 30), RGB(240, 240, 240)
    SETPIXEL x + RAND(-40, 40), y + RAND(-40, 40), RGB(255, 255, 255)
  NEXT
  INC fac, 10
  IF fac > 500 THEN fac = 10
  SHOWSCREEN
WEND


FUNCTION RAND: minimum, maximum
  RETURN minimum + RND(-minimum + maximum)
ENDFUNCTION

mich interessiert, wie man ohne Sprite mehr oder minder realistische Flammeneffekte auf dem Bildschirm zaubern kann.
Das hier habe ich bei

http://www.blitzbase.de/quellcode/feuer.bb

abgekupfert, wobei ich zugeben muss, daß ich weder den Ablauf gänzlich verstehe noch mit dem Ergebnis sonderlich zufrieden bin. Aber immerhin ein Anfang.

Code (glbasic) Select Expand

// --------------------------------- //
// Project: fire
// Start: Wednesday, January 02, 2008
// IDE Version: 5.110


height = 100
width = 100
startx = 270
starty = 190


DIM fire[width][height]
maxcolor = 127

FOR i = 0 TO width - 1
  fire[i][height-1] = 70
NEXT

WHILE TRUE
  Kamin()
  FOR i = 0 TO height - 2
    FOR k = 0 TO width - 1
      fire[k][i] = fire[k][i+1] - 2
      IF fire[k][i] > 0 THEN SETPIXEL startx + k, starty + i, fire[k][i]
    NEXT
  NEXT
  FOR i = 0 TO width - 1
    INC fire[i][height-1], RND(20) - 10
  NEXT
  FOR i = 1 TO width - 2
    fire[i][height-1] = (fire[i-1][height-1] + fire[i][height-1] * 3 + fire[i+1][height-1]) / 5
  NEXT
  FOR i = 0 TO width - 1
    IF fire[i][height-1] > maxcolor THEN fire[i][height-1] = maxcolor
    IF fire[i][height-1] > 0 THEN SETPIXEL startx + i, starty + height-1 * 2, fire[i][height-1]
  NEXT
  SHOWSCREEN
WEND


// ------------------------------------------------------------- //
// ---  KAMIN  ---
// ------------------------------------------------------------- //
FUNCTION Kamin:
 
  DRAWRECT 0, 0, 680, 480, RGB(255, 255, 255)
  DRAWRECT 260, 180, 120, 200, RGB(0, 0, 255)
  DRAWRECT startx, starty, width, height, RGB(0, 0, 0)

ENDFUNCTION // KAMIN

Grundlage ist ein PureBasic-Listing von http://www.purearea.net/pb/CodeArchiv/Graphics/Image/GradientImage.pb

Code (glbasic) Select Expand

// --------------------------------- //
// Project: Farbverlauf
// Start: Monday, December 31, 2007
// IDE Version: 5.110



color1 = RGB(255, 0, 10)
color2 = RGB(60, 255, 255)

WHILE TRUE
  Farbverlauf(100, 0, 500, 200, color1, color2, 0)
  Farbverlauf(100, 220, 500, 450, color2, color1, 1)
  SHOWSCREEN
WEND

// ------------------------------------------------------------- //
// ---  FARBVERLAUF  ---
// x1, y1, x2, y2    --- Koordinaten des Rechteckes für den
//                       Farbverlauf
// co1, col2         --- Farben für den Farbverlauf (von .. bis)
// direction         --- 0 = horizontaler Verlauf
//                       <> 0 = vertikaler Verlauf
// ------------------------------------------------------------- //
FUNCTION Farbverlauf: x1, y1, x2, y2, col1, col2, direction

  LOCAL i
  LOCAL cr1, cg1, cb1
  LOCAL cr2, cg2, cb2
  LOCAL dr, dg, db
  LOCAL red, green, blue
  LOCAL count

  SplitColor(col1, cr1, cg1, cb1)
  SplitColor(col2, cr2, cg2, cb2)

  IF direction = 0
    count = x2 - x1 + 1
  ELSE
    count = y2 - y1 + 1
  ENDIF
 
  dr = (cr1 - cr2) / count
  dg = (cg1 - cg2) / count
  db = (cb1 - cb2) / count

  FOR i = 0 TO count
    red = cr1 - i * dr
    green = cg1 - i * dg
    blue = cb1 - i * db
    IF direction = 0
      DRAWLINE x1 + i, y1, x1 + i, y2, RGB(red, green, blue)
    ELSE
      DRAWLINE x1, y1 + i, x2, y1 + i, RGB(red, green, blue)
    ENDIF
  NEXT

ENDFUNCTION // FARBVERLAUF


// ------------------------------------------------------------- //
// ---  SPLITCOLOR  ---
// ------------------------------------------------------------- //
FUNCTION SplitColor: color, BYREF red, BYREF green, BYREF blue

  red = bAND(color, 255)
  green = bAND(color / 256, 255)
  blue = bAND(color / POW(256, 2), 255)

ENDFUNCTION // SPLITCOLOR

[Texture mapping]

Man stolpert beim Surfen ja immer mal wieder über ganz interessante Sachen wie z.B. Diplomarbeiten o.?. die sich mit dem Thema Spieleentwicklung befassen. Vielleicht k?nnte solche Sachen in diesem Thread mal sammeln.


Hier z.B. eine Diplomarbeit, die sich mit der Erstellung eines 3D-Strategiespieles befasst:
http://augustus.awx.at/Augustus_DA_Dokumentation.pdf

Noch eine Arbeit. Beispiel für ein 3D-Partikelsystem am Beispiel eines Wasserfalles
http://www.gup.uni-linz.ac.at/thesis/practical/stephan_gsoellpointner/waterfall.pdf

recht interessanter Beitrag über Partikelsysteme allgemein mit weiterführenden Quellenangaben am Ende des Beitrages.
http://medien.informatik.uni-ulm.de/lehre/courses/ss02/Computergrafik/JohannesHein.pdf

3D-Pathfinding:
http://wwwcg.in.tum.de/Teaching/SS2006/HauptSem/Workouts/Topic05/DATA/3dpf-doc-final.pdf

Diplomarbeit zum Thema "Fraktale Planetengenerierung"
http://publikationen.ub.uni-frankfurt.de/volltexte/2006/2797/pdf/Diplomarbeit_jhomann.pdf

Vorlesung Computergrafik der Uni Osnabrück
http://www-lehre.informatik.uni-osnabrueck.de/~cg/2000/skript/index.html

Schöne und anschauliche Beschreibung zum Thema Skybox, Skysphere etc.
http://enter.diehlsworld.de/ogl/skyboxartikel/skybox.htm

Was man schon immer über Texture mapping mit OpenGL wissen wollte:
http://www.gup.uni-linz.ac.at/cgue/oglIntro5.pdf

Super Seite mit einigen Video-Tutorials zum neuen Blender 2.5x. Sogar ich habs verstanden
http://blenderhilfe.de/

hab mal versucht, so eine Art Wabbel-Effekt für 2D-Grafiken hinzukommen.

Code (glbasic) Select Expand

// Beispielsprite erstellen
FOR i = 0 TO 19
  DRAWRECT i * 5, i * 5, 200 - i * 10, 200 - i * 10, RGB(RND(255), RND(255), RND(255))
NEXT

// Bild in Zeilen aufteilen
DIM wabbel[100]

FOR i = 0 TO 99
  GRABSPRITE i, 0, 2 * i, 200, 2
  wabbel[i] = i
NEXT

// Hauptprogramm
WHILE TRUE
  INC faktor, 1
  FOR i = 0 TO 99
    DRAWSPRITE wabbel[i], 100 + SIN(faktor + i) * 50, 100 + 2 * i
  NEXT
  SHOWSCREEN
WENDWenn man die SIN-Funktion durch TAN-Funktion ersetzt, ergibt sich ein weiterer ganz netter Effekt.
okok ist ziemlich hirnlos, hat mich aber mal interessiert

Habe heute morgen in unserer Tageszeitung gelesen, daß die Bundesregierung 2008 einen Computerspiele-Preis verleiht. Insgesamt soll es Preisgelder von 300.000 Euro geben. Ballerspiele werden hier wohl kaum eine Chance haben. Die teilnehmenden Spiele sollen

qualitativ hochwertig, pädagogisch wertvoll und gesellschaftlich erwünscht

sein. Was man darunter genau zu verstehen hat, wird wohl erst im neuen Jahr konkretisiert.

Nachtrag nach Forum-Umzug

Anm.: Seit SORTARRAY eigentlich überflüssig

Code (glbasic) Select Expand


DIM a[1000]

FOR i = 0 TO 999
  a[i] = RND(1000)
NEXT

t1 = GETTIMERALL()
bubblesort(a[])
t2 = GETTIMERALL()

t3 = t2 - t1
PRINT "Zeit für Bubble Sort: " + FORMAT$(10, 2, t3) + " Millisekunden", 0 ,0
SHOWSCREEN
KEYWAIT

WHILE TRUE
  x = 0
  y = 0
  FOR i = 0 TO 999
    PRINT a[i], x, y
    INC y, 10
    IF y > 470
      y = 0
      INC x, 30
    ENDIF
  NEXT
  SHOWSCREEN
WEND


// ------------------------------------------------------------- //
// -=#  BUBBLESORT  #=-
// ------------------------------------------------------------- //
FUNCTION bubblesort: array[]

  LOCAL count = BOUNDS(array[], 0) - 1
  LOCAL notsorted = TRUE
  LOCAL i, t
 
  WHILE notsorted
    notsorted = FALSE
    FOR i = 0 TO count - 1
      IF array[i] > array[i+1]
        t = array[i]
        array[i] = array[i+1]
        array[i+1] = t
        notsorted = TRUE
      ENDIF
    NEXT
  WEND

ENDFUNCTION // BUBBLESORT


hab heute morgen im ZDF-Dokukanal einen interessanten Beitrag über die Game-Academy gesehen. Anschließend kamen noch einige Beiträge über einige Entwickler (Fifa) und andere. War ganz interessant.

ok,ok zu spät für heute, aber die Sachen werden auf diesen Sendern ja auch häufig wiederholt

Mein Arbeitgeber hat sich erdreistet, den Internetzugang zu www.glbasic.com zu sperren (Kategorie Games). Sinnigerweise sind Seiten wie www.spieleprogrammierer.de nicht gesperrt ;((((

wie könnte man so etwas angehen. Bräuchte da mal einen Denkanstoss, da mir hierzu jegliche Inspiration fliehet ....

das finde ich mal wirklich eine klasse Erfindung. mal sehen, was sich daraus entwickelt.

http://www.golem.de/0708/54119.html