Das OFFIZIELLE PROFAN SUPPORT FORUM
Einsteigerfragen
PROFAN-Programmierung
Helfer & Tools
Anregungen & Vorschläge
PROFAN-NEWS
Die Regeln!
2 - PROFAN-Programmierung

 Neues Thema  |  Zur Übersicht  |  Suchen  |  Einloggen   Neuerer Beitrag  |  Älteres Thema 
 Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Markus Barkholz (---.hsi16.unitymediagroup.de)
Datum:   14.07.21 20:02

Hallo,

Ich habe mal einen Versuch gestartet und suche eine elegantere Lösung. Ich möchte die einzelnen Boxen mit Bildern füllen. Das ist aber nicht mein Problem. Jede "oGL("Quad", 1, 1)" soll genau in Bildschirmmitte anhalten (im Moment per "Sleep 3000"), hinein Zoomen auf Bildschirmgröße, wieder auf den Ausgangszustand zurück und danach zum nächsten Fenster laufen und wieder für 3Sek anhalten usw.

Der Sleep Befehl wird später ersetzt durch Zuladen von weiteren Bildern. Vorab werden 30 Bilder bei Programmstart geladen. (Es werden genau 600 Bilder geladen) Dieser Absatz ist aber nur zur Info.

Und ja, im Moment sind es 31 statt 30 Bilder. Das ist mir schon aufgefallen ;-)

Jemand eine Idee?

Das Programm sieht im Moment so aus:

 Declare fps%, tmr&, frm%
 Declare rX!, rY!, rZ!
 Declare xFps&, yFps&
 
 CLS
 oGL("Init", %hWnd, 0, 0, 0, 0)
 Set("TrueColor", 1)
 Set("oGLDepth", 512)
 
 xFps& = create("Font", "Curier", 12, 0, 0, 0, 0)
 yFps& = oGL("OutlineFont", xFps&, 0.0)
 DeleteObject xFps&, yFps&
 
 
 SetTimer 20
      While 1
           If &GetTickCount - tmr& >= 1000
                fps% = frm%
                tmr& = &GetTickCount
                frm% = 0
           EndIf
           
           rX! = rX! + 0.002 : If rX! >=90 : rX! = 0 : EndIf
           rY! = rX! + 0.002 : If rY! >=90 : rY! = 0 : EndIf
           rZ! = rX! + 0.002 : If rZ! >=90 : rZ! = 0 : EndIf
 
           oGL("Clear")
           oGL("PosMode", 1)
           
           oGL("Origin", 50, 40, -100)
           oGL("Print", yFps&, str$(rX!))
           'Sleep 250
           
           oGL("push")
           oGL("Fog", 2, 0.04, 0)
             oGL("BlendMode",0)
             oGL("Texture", "", 1)
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(0*0.203)), 0, 17*cos(rZ!+(0*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(1*0.203)), 0, 17*cos(rZ!+(1*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(2*0.203)), 0, 17*cos(rZ!+(2*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(3*0.203)), 0, 17*cos(rZ!+(3*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(4*0.203)), 0, 17*cos(rZ!+(4*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(5*0.203)), 0, 17*cos(rZ!+(5*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(6*0.203)), 0, 17*cos(rZ!+(6*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(7*0.203)), 0, 17*cos(rZ!+(7*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(8*0.203)), 0, 17*cos(rZ!+(8*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(9*0.203)), 0, 17*cos(rZ!+(9*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(10*0.203)), 0, 17*cos(rZ!+(10*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(11*0.203)), 0, 17*cos(rZ!+(11*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(12*0.203)), 0, 17*cos(rZ!+(12*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(13*0.203)), 0, 17*cos(rZ!+(13*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(14*0.203)), 0, 17*cos(rZ!+(14*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(15*0.203)), 0, 17*cos(rZ!+(15*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(16*0.203)), 0, 17*cos(rZ!+(16*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(17*0.203)), 0, 17*cos(rZ!+(17*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(18*0.203)), 0, 17*cos(rZ!+(18*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(19*0.203)), 0, 17*cos(rZ!+(19*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(20*0.203)), 0, 17*cos(rZ!+(20*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(21*0.203)), 0, 17*cos(rZ!+(21*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(22*0.203)), 0, 17*cos(rZ!+(22*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(23*0.203)), 0, 17*cos(rZ!+(23*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(24*0.203)), 0, 17*cos(rZ!+(24*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(25*0.203)), 0, 17*cos(rZ!+(25*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(26*0.203)), 0, 17*cos(rZ!+(26*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(27*0.203)), 0, 17*cos(rZ!+(27*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(28*0.203)), 0, 17*cos(rZ!+(28*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(29*0.203)), 0, 17*cos(rZ!+(29*0.2)))
             oGL("Quad", 1, 1)
             
             oGL("Origin", 0, 0, -30)
             oGL("Move", 10.1*sin(rX!+(30*0.203)), 0, 17*cos(rZ!+(30*0.2)))
             oGL("Quad", 1, 1)
           oGL("pop")
 
           oGL("Show")
           
           If IsKey(27)
             End
           EndIf
      EndWhile
 KillTimer
 End
 




Nachricht bearbeitet (14.07.21 20:03)

Beitrag beantworten
 
 Re: Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Heinz Brill (---.dip0.t-ipconnect.de)
Datum:   15.07.21 08:19

Ich habe jetzt zwar nicht viel Ahnung von OGL, aber evtl.
könnte man das doch etwas umorganisieren. Wie ich das
sehe, wird in der Schleife jedesmal neu gezeichnet.

Mein Vorschlag wäre :

Die Quads in einer Liste zu zeichnen -> OGL("StartList", N) ... OGL("EndList")
und dann mit OGL("DrawList", N ) auf den Bildschirm bringen.
Dann mit oGL("Rotate", WX, WY, WZ) das Koordinatensystem
rotieren lassen. Das wäre weniger Rechnerei mit den Koordinaten.

Oder so ähnlich, wie in dem Beispiel mit mit den Planeten in den
mitgelieferten Demos.

Ich denke, daß es dann auch nicht mehr ruckelt.

Hier noch was zum Anschauen :
https://xprofan.net/intl/de/quelltexte/album-ogl/

oder sowas :
 declare st%, btn1%, btn2%, btn3%
 declare rtri!, rquad!
  
  proc DrawGLScene
    oGL("Clear")
    oGL("Origin", 0, 0, -6) 
    oGL("Color", 1, 0, 0, 1) 
    oGL("Rotate", 0, rtri!, 0)
    oGL("Rotate", rquad!, 0, 0)
    oGL("Quad", 2, 3)
    oGL("Show")
    rtri! = rtri! + 9
    rquad! = rquad! - 5
  endproc
  
  ' Hauptprogramm
  
  ' -------------
  
  declare ende%
  Window 600, 400
  st%    = @Create("Static", %HWnd, 300, 50, 200, 100)
  btn1%  = @Create("Button", %HWnd, "Start", 10, 10, 60, 25)
  btn2%  = @Create("Button", %HWnd, "Stop", 80, 10, 60, 25)
  btn3%  = @Create("Button", %Hwnd, "Ende", 150, 10, 60, 25)
  
   
  oGL("Init", st%, 0, 0, 0, 0)
  oGL("PosMode", 1)
  
  
  ende%   = 0
  
 setTimer 50 ' max 50 Frames /sek.
  
  WhileNot ende%
    WaitInput
    if isKey(27)
      ende% = 1
    endif
  	If @Clicked(btn1%)
  	   ShowWindow(st%, 1)
  	ElseIf @Clicked(btn2%)
  	    ShowWindow(st%, 0)
  	ElseIf @Clicked(btn3%)
  	   ende% = 1
  	EndIf
  	Case %Key = 2 : ende% = 1
    DrawGLScene()
  EndWhile
  
 killTimer
  
 end
 


H.Brill
XProfan X4 + FreeProfan

Nachricht bearbeitet (15.07.21 09:48)

Beitrag beantworten
 
 Re: Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Markus Barkholz (---.hsi16.unitymediagroup.de)
Datum:   15.07.21 20:09

Okay, habe mir die Planeten-Geschichte grade angesehen. Sicher kann ich das auch so machen wie in dem Beispiel. Mit den oGL-Listen habe ich noch nicht gearbeitet. Bekommt man damit auch Animationen hin wenn ich das alles in Listen packe? Gibt es da irgendwo ein Beispiel wie man damit umgeht?

Beitrag beantworten
 
 Re: Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Heinz Brill (---.dip0.t-ipconnect.de)
Datum:   16.07.21 07:06

Ich denke mal, so eine Liste ist wie ein Makrorecorder, wie man ihn
z.B. in Excel kennt.

Vielleicht braucht man das auch nicht, wenn nur einmal gezeichnet wird.

Evtl. Könnte man ja auch die Quads in eine Elypse setzen und diese
sich dann drehen lassen. Die Elypse selber kann man ja wieder mit
der Farbe des Hintergrunds (schwarz ?) einfärben, damit man sie
beim Programmlauf nicht sehen kann.

Da kann man bestimmt mehrere Ansätze verfolgen.

H.Brill
XProfan X4 + FreeProfan

Beitrag beantworten
 
 Re: Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Markus Barkholz (---.hsi16.unitymediagroup.de)
Datum:   02.08.21 21:17

Ich habe mein kleines Prog mal umgeschrieben. Verhält sich aber nicht so wie ich es mir wünsche. Mein Bildkreisel wird im ganzen größer. Ich möchte aber nur das vorderste Quad auf Vollbild zoomen lassen und natürlich zurück.

Was mache ich da falsch?

Seht selbst:


 Declare fps%, tmr&, frm%, rT!, xFps&, yFps&, x&, y&, count&
 Var dist! = 0.21
 Count& = -30
 
 CLS
 oGL("Init", %hWnd, 0, 0, 0, 0)
 Set("TrueColor", 1)
 Set("oGLDepth", 512)
 
 xFps& = create("Font", "Curier", 12, 0, 0, 0, 0)
 yFps& = oGL("OutlineFont", xFps&, 0.0)
 DeleteObject xFps&, yFps&
 
 
 SetTimer 20
      While 1
           If &GetTickCount - tmr& >= 1000
                fps% = frm%
                tmr& = &GetTickCount
                frm% = 0
           EndIf
 
           rT! = rT! + 0.001 : If rT! >=6.28: rT! = 0.0 : EndIf
 
           oGL("Clear")
           oGL("PosMode", 1)
 
           oGL("Origin", 50, 40, -100)
           oGL("Print", yFps&, str$(y&))
 
           For x&,0,29
             oGL("push")
               oGL("Fog", 2, 0.04, 0)
               oGL("BlendMode",2)
               oGL("Texture", "", 1)
               oGL("Origin", 0, 0, count&)
               oGL("Move", 10.1*sin(rT!+(x&*dist!)+0.194), 0, 17*cos(rT!+(x&*dist!)+0.194))
               oGL("Quad", 1.6, 1)
             oGL("pop")
           EndFor
 
           For x&,0,29
             oGL("push")
               oGL("Fog", 2, 0.04, 0)
               oGL("BlendMode",2)
               oGL("Texture", "", 1)
               oGL("Origin", 0, 0, -30)
               oGL("Move", 0, 9.1*sin(rT!+(x&*dist!)+0.194), 17*cos(rT!+(x&*dist!)+0.194))
               oGL("Quad", 1, 1.6)
             oGL("pop")
           EndFor
 
           If (rT!*1000) MOD (dist!*1000) = 0.0
           'inc y& : if y& = 29 : y& = 0 : EndIf
           sleep 500                                                                                     'Hier kommt die Ladeprozedur hin!!! Sleep ist nur ein Ersatz!!!
           count& = count& + 0.11
           EndIf
 
           oGL("Show")
 
           If IsKey(27)
             End
           EndIf
      EndWhile
 KillTimer
 End
 


Beitrag beantworten
 
 Re: Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Heinz Brill (---.dip0.t-ipconnect.de)
Datum:   03.08.21 07:25

Vielleicht mal mit Between(x,y,z,x1,y1,z1,x2,y2,z2) (3. Variante) probieren.
Wenn sich x/y/z innerhalt der Koordinaten befindet,
Bild für eine gewisse Zeit groß machen und dann wieder
verkleinern.

H.Brill
XProfan X4 + FreeProfan

Nachricht bearbeitet (03.08.21 07:26)

Beitrag beantworten
 
 Re: Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Markus Barkholz (---.hsi16.unitymediagroup.de)
Datum:   06.08.21 22:12

Hallo Heinz,

Between würde mir nur die Modulo-Abfrage ersparen. Was ich erreichen möchte ist, dass sich ein einzelnes Element der oGL["Quad",x,y) aus dem rotierenden Kreis löst, das ich dann in den Vordergrund hole, einige Zeit dort bleibt (diese Anzeigezeit soll dann zum weiteren Nachladen von Bildern genutzt werden, der einen zweiten Kreisel mit Bildern füllt) und sich dann wieder in den Rotierenden Bilderkreisel einfügt.
Ich weis nicht wo mein Fehler ist. Sehe ihn einfach nicht.
Hole ich ein Einzelbild nach vorne, vergrößert sich dabei nur der komplette Radius des Bilderringes. Natürlich ginge das auch, war aber nicht mein Plan. Oder anders gesagt, das gefällt mir so nicht.

Kannst Du da im Code sehen warum sich das so verhält?


M.Barkholz
XProfan X4

Beitrag beantworten
 
 Re: Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Heinz Brill (---.dip0.t-ipconnect.de)
Datum:   07.08.21 07:24

Wie schon gesagt, kenne ich micht mit opengl nicht so aus.
Ich kann mir das nur so vorstellen :
Das liegt wahrscheinlich daran, daß es keine einzelne Handle's
für die Objekte (Sphere, Quad, usw.) gibt. Somit wird dann alles
größer. Da müßtest du schon beim Erstellen der Objekte die
Koordinaten abfragen und je nachdem reagieren.

Hast du es schon mal mit
oGL("2D", X, Y, Z, SX, SY)
und
oGL("Scale", N)
versucht ?
Evtl. kann man die einzelnen Objekte auch mit
oGL("SetName", N)
kennzeichnen.

Vielleicht wäre es auch eine Option, diese Kreisel nur als Simulation
laufen zu lassen. Und wenn ein Objekt zum Mittelpunkt kommt,
einfach ein Static mit dem Bild anzuzeigen und nach einer Pause
wieder mit SchowWindow() verschwinden zu lassen.

H.Brill
XProfan X4 + FreeProfan

Beitrag beantworten
 
 Re: Hat jemand eine elegantere Lösung zu diesem oGL-Thema??
Autor: Sven Bader (---.versanet.de)
Datum:   06.09.21 13:48

Hallo Markus,
falls es für dich noch relevant ist, hier ein funktionierender Code.
Ich habe die Frames zwischen den Bildwechseln berchnet sodass ich mit einem einfachen Modulo arbeiten kann. Dann stoppt die Rotation per if/elseif und die Animation des gewünschten Bildes erfolgt.

Etwas vorsichtig musst du sein bei einer evnetuellen Framerate Anpassung, da zumindest die "Physik" nun darauf angewiesen ist, dass du keinen Frame auslässt.

  Declare fps%, tmr&, frm%, rT!, xFps&, yFps&, x&, y&, count&,x!,y!,z!,pics%,step!,frame&,framesperpic&,zoom&,animate%
  
 
  CLS
  oGL("Init", %hWnd, 0, 0, 0, 0)
  Set("oGLDepth", 512)
  oGL("PosMode", 1)
  xFps& = create("Font", "Curier", 12, 0, 0, 0, 0)
  yFps& = oGL("OutlineFont", xFps&, 0.0)
  DeleteObject xFps&, yFps&
  pics% = 30
  framesperpic& = 10 
  step! = 2*Pi()/ pics% * (1/framesperpic&)
  zoom& = -1
  
  SetTimer 20
  While 1
    
    If &GetTickCount - tmr& >= 1000
      fps% = frm%
      tmr& = &GetTickCount
      frm% = 0
    EndIf
    
    if zoom& = -1
      'nur drehen, wenn gerade kein Bild gezoomt wird
      inc frame&
      rT! = rT! + step! : If rT! >=(Pi()*2): rT! = 0.0 : EndIf
    endif
    oGL("Clear")
    oGL("Origin", 50, 40, -100)
    oGL("Print", yFps&, str$(y&))
    oGL("Fog", 2, 0.04, 0)
    oGL("BlendMode",2)
    oGL("Origin", 0, 0, -30)
    For x&,0,pics%-1
    oGL("push")
      
      oGL("Texture", 0, 1)
      
      x! = 10.1*sin(rT!+(x&*(2*Pi()/pics%)))
      if (x& = zoom&)
        inc animate%
        z! = 17*cos(rT!+(x&*(2*Pi()/pics%))) + (sin(animate%*(Pi()*0.01)) * 11)
      else
        z! = 17*cos(rT!+(x&*(2*Pi()/pics%)))
      endif
      
      oGL("Move", x! , 0, z!)
      oGL("Quad", 1.6, 1)
    oGL("pop")
 
    
  EndFor
     
    if (animate% = 100)
      animate% = 0
      zoom& = -1
    elseif (zoom& = -1) AND (frame& MOD framesperpic& = 0)
      inc y& : if y& = pics% : y& = 0 : EndIf
      zoom& = pics% -y&
    endif
  
  
  oGL("Show")
  
  If IsKey(27)
    End
  EndIf
 EndWhile
 KillTimer
 End
 
 
 



Grüße
Sven

Beitrag beantworten
 Foren-Liste  |  Baumstruktur   Neuerer Beitrag  |  Älteres Thema 


 Foren-Liste  |  Zur Registrierung 
 Benutzerlogin
 Benutzername:
 Passwort:
 Login-Daten speichern:
   
 Passwort vergessen?
E-Mail-Adresse oder Username unten eingeben. Dann wird Dir per e-Mail ein neues Passwort zugeschickt.

phorum.org