dbLounge
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
Remstart
  
  Newton DBPro Wrapper v1.30
  
  by Walaber
  
  walaber.com
  
  demo 01 - THE BASICS!!!
  
  
  Dies ist die erste und einfachste demo mit dem Newton wrapper.
  Wenn du nicht weißt was Newton ist, es ist ein system zur simulation
  von festen(soliden)körpern in Echtzeit. Du kannst Newton benutzen um
  realistische physik in deine DBP spiele und aplikationen einzubauen.
  
  Viele Leute haben mich nach einfachereren demos gefragt als die, die in
  vorigen Versionen enthalten waren. Also mache ich diese demo so einfach
  wie möglich um Dir zu zeigen wie Newton funktioniert, ohne verwirrend
  Befehle zu benutzen
  
  Fortgeschrittene Benutzer sollten direkt zu demo 02 übergehen da diese
  viel mehr Informationen enthält.
  
  Wenn du das erste mal DBPro benutzt wirst du möglicherweise den berühmten
  "Drehenden Würfel" als Beispielprogramm ausprobieren. Das würde in etwa so
  aussehen:
    Make object cube 1,100
    Do
      Yrotate object 1,Object angle y(1)+0.1
    Loop
    Ich habe mich dazu entschieden, als einführung in Newton, ein "Newton Version"
    von diesem Programm zu machen. Ich werde jeden Befehl kommentieren.
  Remend
  
  `------------------------------------------------------
  ` CODE STARTET HIER
  `------------------------------------------------------
  `Dieser erste Befehl initialisiert die Newton Welt und muss vor allen anderen
  `Newton befehlen aufgerufen werden. Um Newton wieder zu entfernen, benutze NDB_NewtonDestroy
  Ndb_newtoncreate
  
  `Gut, nun haben wir die Newton welt. Nun machen wir einen Cube.
  `Zuerst machen wir einen DBPro Cube wie immer.
  Make object cube 1, 100
  
  `Nun müssen wir einen Cube wie diesen erstellen der dann in der Newton Welt existieren wird.
  `Dieser Befehl macht ein "Kollisions Objekt" welches Newton die Form eines Objekts
  `beschreibt. In Newton gibt es keine cubes also machen wir eine Box, dessen größe 100 in
  `jeder dimension ist (Länge, Breite, Höhe).
  Col = NDB_NewtonCreateBox( 100.0, 100.0, 100.0 )
  
  `Gut, die Variable Col enthält nun den index zu dieser Kollision. Wir benutzen diese um einen
  `"festen Körper" zu erstellen, welcher dann ein Objekt in der Newton Welt darstellt (so wie der DBPro
  `cube in der sichtbaren welt von DBPro).
  Cube = NDB_NewtonCreateBody( Col )
  
  `Als nächstes müssen wir dem Objekt eine Masse zuweisen, anderenfalls würde Newton denken das es ein
  `statisches Objekt wäre.Zum jetzigen Zeitpunkt musst du dir noch nicht so viele Gadenken über die
  `andren werte machen. Sie sind dafür da um die Rotation um die verschiedenen Achsen zu verändern.
  Ndb_newtonbodysetmassmatrix Cube, 10.0, 1.0, 1.0, 1.0
  
  `Nun enthält "Cube" den index zu unsrem "festen körper" mit der Form von "Col" (Die wir oben
  `als eine box 100x100x100 beschrieben haben)
  `Als nächstes müssen wir das Newton Objekt mit dem DBPro Cube verbinden. Dadurch kann Newton
  `dann die Position und die Rotation des DBPro Objekts steuern, basiert auf den
  `Physikalsischen berchnungen von Newton.
  Ndb_bodysetdbprodata Cube, 1
  
  `Dies ordnet das DBPro Objekt# 1 dem Newton Objekt mit dem Index "Cube" zu.
  `Schlussendlich wollen wir ja noch das der Cube sich dreht also initialisieren
  `wir "Omega", was nur ein anderer Name für "Drehung" ist. Dieser Befehl ist ein
  `gutes Beispiel wie man so etwas mit Newton macht. Weil viele Befehle 3D Vektoren
  `nutzen und manchmal auch wieder ausgeben, musste ich mir etwas einfallen
  `lassen um Vektoren in und aus Newton zu bekommen. Wie du weißt kann eine Funktion
  `in DBPro nur einen Wert zurückgeben, also musst ich auf das "Temp Vector" System
  `zurückgreifen. Es werden im Wraper intern 4 "temporäre" Vektoren gespeichert für
  `die temporäre Daten. Beispielsweise möchte der Omega befehl 3 Werte von dir, die
  `Drehung um die jeweilige Achse angeben. Anstatt nun dies zu tun.
  `   NDB_NewtonBodySetOmega Body, x#, y#, z#
  `Musst du bei Newton so vorgehen:
  `   NDB_SetVector x#, y#, z#
  `   NDB_NewtonBodySetOmega Cube
  `
  `Das macht das system saberer, ich versichere es. Egal, du musst ich halt dran gewöhnen.
  `Also lass uns den Anfangswert für "Omega" setzen.
  Ndb_setvector 0.0, 100.0, 0.0
  Ndb_newtonbodysetomega Cube
  
  `du wirst bemerkt haben das ich nur einen wert für die Y Achse eingetragen hab .. als wird
  `der Cube sich nur um die Y achse drehen, so wie in der einfachen DBPro Demo.
  
  `Gut das war alles das wir an setup benötigen, nun zur Hauptschleife.
  Do
    `Liefert die Zeit zurück die seit dem letzten aufruf der Funktion verganen ist
    time# = NDB_GetElapsedTimeInSec()
    
    `Dann der große Befehl der die ganze Physik Welt aktualisiert. Du sagst ihm
    `wie viel Zeit vergangen ist und er aktualisiert demnach.
    Ndb_newtonupdate time#
    
  Loop
  
  `Und das wars! Es sind nur ein paar Befehle und dieses Beispiel ist ziemlich stupide da es nicht die
  `coolen Teile von Newton zeigt (wie körper interagieren wenn sie kollidieren), aber es gibt dir einen
  `Einblick wie der Wraper funktioniert. Vergewissere dich das du alles verstanden hast und mach dann mit
  `der 2. Demo weiter, welche viel umfangreicher ist!!