Visualisations (e.g. bounding boxes, kinematics states, grid, timer,...) should be enabled or disabled from configuration or via lua script.

In the latest version, the simulation time as well as the other timers are not shown in the window.

Currently, the path for xml files is, where the program is executed. Instead, if an xml file imports another file, the import path should be relative to to the first xml file.

PW behaves strange (object is not drawn, zooming is not possible) if mass or inertia is set to zero.
See example https://github.com/planeworld/examples/tree/master/sunlight and set mass of sunlight to zero.

As Planeworld simulates an universe and not necessarily our universe, the gravity constant should be readable from Lua.
Proposal: pw.universe.G

As mentioned in #35, in some cases the graphical output is not important. Thus, it would be helpful to completely deactivate the window from command line:

planeworld --no-graphics example.xml

The Lua interface should be extended by functions for creating objects and setting other variables. This would make Lua scripts a full replacement for xml configuration files.

A proposal how the interface might look is shown here:
https://gist.github.com/avanc/9107c2a9c862d31f195852a4cb78df95
Comments are appreciated.

To configure the initial view of the camera, the zoom level should be configurable. Or the usage of viewport might be adapted.

Xml configuration expects a lowercase object type

<object type="rigidbody"> instead of the old <object type="Rigidbody">.

The same applies for new identifiers for shapes and visuals, e.g.:

<shape type="shape_circle"> instead of <shape type="Circle"> and
<visuals type="shape_visuals_circle"> instead of <visuals type="Circle">.

Compile under MS Windows and provide dependency free package.

If the grid is shown in the gridtest.xml.txt example, the grid resolution is changed shortly from 1m to 0.1m every 180°.

The current grid is bound to world coordinates. Thus, it is hard to use the grid when the camera is hooked to a moving object, especially when zooming in close to this particular object. Alternativaly, a camera bound grid should be implemented. Activation can be done by pressing the accordant key a second time, hence toggling the different states.

It is possible to set the origin of the local coordinate system in the core section of the xml file using

origin_x
origin_y

However, it is not possible to rotate the local coordinate system.

In Lua, pw is a table which points to universe, etc. The table can be extended as expected:

pw.myvar=42;

However, pw.universe is an VarAccessMetaTable. Thus, the following fails:

pw.universe.myvar=42;   --[warning] Physics Manager: Unknown variable myvar.

The same behaviour for pw.sim and pw.system.

The problem was observed, as I wanted to extend the functionality as mentioned in https://gist.github.com/avanc/9107c2a9c862d31f195852a4cb78df95#file-example-lua-L110

pw.universe.get_object = function(object_name)
  local object = {};
  object.mass = pw.universe.get_mass(object_name);
  object.inertia = pw.universe.get_inertia(object_name);

  object.get_position = function()
    return pw.universe.get_position(object_name);
  end

  object.get_velocity = function()
    return pw.universe.get_velocity(object_name);
  end

  object.get_angle = function()
    return pw.universe.get_angle(object_name);
  end

  object.get_angle_vel = function()
    return pw.universe.get_angle_vel(object_name);
  end

  return object;
end

A warning would be helpful when an xml contains an unknown tag. Otherwise it is hard to find errors within the file.

The mass moment of inertia and the center of mass should be automatically calculated by default. This should be done considering a homogeneous density distribution per shape, thus, calculation is based on objects geometry.

Currently, if a thruster is defined in XML, it is activated with the maximum force on startup. However, if used within lua, it should be deactivated on startup and activated in lua. Thus, an XML parameter "activated=false" would be helpfull.

If the object orbiting the earth is defined in xml before earth, the earth has no gravity effect on the object.
This can be tested with https://github.com/planeworld/examples/blob/master/sputnik_example.xml by changing it to

<object file="sputnik/sputnik.xml"/>
<object file="sputnik/earth.xml" />

It seems that http://appimage.org/ is a good choice.

Documentation for creating an AppImage on Arch Linux can be found here:

• https://github.com/RazZziel/PortableLinuxGames/wiki/Creating-appimages-from-archlinux-packages
• https://github.com/RazZziel/PortableLinuxGames/blob/master/pacman2appDir

The following example should rotate 360° within one day. This means, it should take 24_60_60/8192=10,5s if accelerated 8192 times. However, if measured it takes 14 seconds. CPU load ist below 20%.

timetest.xml.txt

If changing the frequencies as follows, PW aborts with an exception:

physics_frequency="100.0"
lua_frequency="100.0"

If the lua script is not available, PW fails with an error message:

File ./sputnik/physics_interface.lua could not be loaded.

However, if no script is defined in the config section of the xml, the program should run normally.

As the maximum thrust is limited, the function activate_thruster should return the actual thrust. Using this, the lua script can detect if the requested force is to high.

In addition, if the object is not found, an error should be raised:
http://www.lua.org/pil/8.4.html

Gravity Turn as in example https://github.com/planeworld/examples/tree/gravityturn/gravityturn reacts very sensible to the delta time of each physic calculation. The result for the achieved height changes depending on the acceleration.
Thus, it would be helpful to decrease/increase the physics frequency without changing the delta time. This would result in more or less processor usage.

The shortcut might be [shift]-a and [shift]-d

The working directory of Lua is set to the directory, where planeworld was started instead of the directory, where physics_interface.lua is located.
This can be easily tested with

io.open("testfile.txt", "w")

which creates a new file.

The major problem is, that the Lua function require searches in the working directory. This results in similar problems as in #14

Following functions are missing in lua:

• get_angle and get_angle_ref
• get_angle_velocity and get_angle_velocity_ref
• get_time

In addition, functions to get static parameters of objects would be very helpful:

• get_mass
• get_inertia

Numeric calculation (2-body, 3-body) of orbit and its parameters like apoapsis and periapsis.

In the sputnik example, the sputnik is not drawn as small dot at a zoom level of about 10km. This is far to early. The small dot should be visible at least until the earth comes into the screen.

If the Lua file is not configured using

<config
    physics_interface="../physics_interface.lua"
/>

planeworld complains that the Lua file couldn't be loaded. However, some examples like Sputnik do not need a Lua file. Thus, defining physics_interface should be optional.

Update graphics from fixed function pipeline to shader based processing using the core profile.

SFML does only recognize the plus key from the key pad. Thus, it is not possible to accelerate time if key pad is not available (e.g. laptop keyboard).
An alternative key is needed.

pw.universe.get_time() returns 0.3 on first run. This means that simulation has already started.
However, if something has to be initialised on startup, it would be helpful if Lua is run before first physics calculation.

When moving the camera out of the initial cell, it's bounding box doesn't follow but jumps back to cell(0,0). Cells probably also won't work for objects. This is related to the introduction of kinematics states. Cell information should be implemented there.

In Lua, functions are grouped in so called packages: http://www.lua.org/pil/15.html
An example is the package math, which contains among other functions math.pow() and math.sin().
I imagine a similar packaging of planeworld related functions:

• pw: Main namespace for all planeworld related functions
• pw.system: Package for system related functions like set_frequency(), pause(), save()
• pw.universe: Package for all functions related to the internal universe like get_position(), get_velocity()

Split up planeworld engine into physics simulation and external control / visualisation, roughly following the model-view-controller pattern.

One polyline is not drawn if body_core->angle is set. This happens also, if angle is set to zero. However, the line is shown if the configuration is removed from the xml.

earth.xml.txt
satellite_example.xml.txt
sputnik.xml.txt

Another interesting observation is, that the line is also drawn if the object definition is within the main xml and not as separate file.

Similar to Lua modules https://github.com/planeworld/examples/issues/16

I get the warning above, although I don't use apply_force in Lua.

Replace the lua in component_thruster example:
physics_interface.lua

The simulation time (the time that runs faster if accelerated) should be shown on the graphics window. Maybe activated with a key input.

Extend dynamic simulation by implementing collision detection and collision response using constraints.

The following example reads two files as expected:

<object file="foo.xml" />
<object file="folder/bar.xml"/>

However, if the lines are switched:

<object file="folder/bar.xml"/>
<object file="foo.xml" />

foo.xml is searched at folder/foo.xml.

[warning]     []        XML Importer: XML file ./folder/foo.xml parsed with errors.                                                                                  
[warning]     []        XML Importer: Error description: File was not found

If hooked to an object, an x and y offset can be add to the camera (position_x, position_y). However, this is not available for the angle.

To create an interactive tutorial as described in planeworld/examples#3, a function to show text on the graphics window is needed. In addition, the parameters of the camera also need to be accessible. With this, a lua script can be written which gives instructions to the user depending on the viewport.

Following lua functions are needed:
* show text / clear text
* get camera position (relative or absolute)
* get camera viewport (m_per_px)

Following lua functions would be nice to have:
* set camera position
* set camera viewport (m_per_px)
* set object to which the camera is hooked

First, the xml importer sets a default value for inertia, if no value is found.
But then, the importer complains, that the value is no longer needed:

[notice]      []        XML Importer: Attribute inertia not found. Using default value 0.
[notice]      [var]     XML Importer: Inertia is be calculated automatically now, value 0 ignored.

This output was done using sunlight example.

As I use pw also to simulate the simulation a function like

pw.system.quit()

would be helpful, as I'm only interested in the text output.

In addition, a function to set the acceleration:

pw.system.set_acceleration(1024, false);

The second Boolean parameter can be used to change also accuracy (similar to Strg+a).

Implement a server-side camera representation to allow for simulation queries and optimisations based on camera viewport. This might include a "physical scope" which defines the area where objects are fully simulated.

Units of parameters like angle and angle velocity should rad and rad/s, respectively.

For Lua debugging it would be helpful that planeworld exits errors in the Lua code.
However, this behaviour is not desired, as an error in Lua should not exit the universe :-) Thus, this behaviour should be configurable.

For 2-body problems, the satellite orbits can be represented as conic sections (circle, ellipse, parabola, hyperbola).
A function should be provided, which calculates the following orbit parameters:

• eccentricity vector e (vector with length of the eccentricity pointing into direction of the semi-major axis)
• semi-latus rectum l
• position of main focal point f
  The IDs of the two bodies are given to the function as input parameters.

In a second step, this information can be used by the graphics engine to show orbits.