FlyWithLua

When porting code from X11 to GLUT for Win32, be aware of the following behavioral differences:

Command Line Options

The following glutInit options are ignored in Win32:

• -display
• -indirect
• -direct
• -sync

Window Positioning

• glutPositionWindow(0, 0): Places the window client area at 0,0. This often results in window decorations (title bar/edges) being off-screen.
• glutInitWindowPosition(0, 0): Places the window relative to the entire window space (including decorations), typically opening the window in the upper-left corner.

Titles and Cursors

• Titles: There is no distinction between Icon title and Window title in Win32; glutSetIconTitle has no effect.
• Cursors: While most cursors match by meaning, GLUT_CURSOR_INFO and GLUT_CURSOR_SPRAY use the crosshair, and GLUT_CURSOR_CYCLE uses the 'no' or 'destroy' cursor.

Visibility and Focus

• Visibility: glutVisibilityFunc only reflects the Iconic, Hidden, or Shown state. A window is considered "visible" even if it is fully obscured by another window.
• Focus: Win32 uses a "click to focus" policy. To change this to "focus follows mouse", you can use the Microsoft utility Tweak UI.

Menus and Idle Functions

• Menus: Menú operations are modal. The glutIdleFunc will not be called while a menu is active. However, timer functions will still fire.
• Mouse Buttons: glutAttachMenu works best with left and right mouse buttons. If attached to the middle mouse button, the left button must be used to select items.

While not recommended over native builds or GitHub Actions, you can cross-compile from Ubuntu.

1. Install Toolchains

Install MinGW for Windows and Clang/osxcross for OS X:

# Windows toolchain
sudo apt-get install -y --no-install-recommends mingw-w64 g++-mingw-w64

# OS X toolchain
apt-get install -y --no-install-recommends clang curl
# (Follow the detailed osxcross build steps in the source to set up /usr/osxcross)

2. Build for Windows

Use the provided MinGW toolchain file:

cmake -S ./src -B ./build-win -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_TOOLCHAIN_FILE=src/Toolchain-mingw-w64-x86-64.cmake
cmake --build ./build-win

3. Build for OS X

Use the provided osxcross toolchain file:

cmake -S ./src -B ./build-mac -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_TOOLCHAIN_FILE=src/Toolchain-ubuntu-osxcross-10.11.cmake -DCMAKE_FIND_ROOT_PATH=/usr/osxcross/SDK/MacOSX10.11.sdk/
cmake --build ./build-mac

# Example: Building for Windows from Ubuntu
cmake -S ./src -B ./build-win -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_TOOLCHAIN_FILE=src/Toolchain-mingw-w64-x86-64.cmake
cmake --build ./build-win

To use Arcaze USB hardware for custom flight simulator controls (like radios, switches, or displays), you must first include the arcaze module. The workflow involves:

1. Loading the module: Use require "arcaze".
2. Opening the device: Use arcaze.open_first_device() to find and connect to the hardware. This function returns nil if no device is found, so always check for nil to prevent script crashes.
3. Initializing displays: Use arcaze.init_display(device, connector, brightness) to set up 7-segment displays. Brightness is typically mapped from X-Plane DataRefs (0.0-1.0) to an integer range (e.g., 0-15).
4. Reading inputs: Use arcaze.read_encoders(device) for rotary encoders and arcaze.read_pins(device) for digital buttons/switches.
5. Updating displays: Use arcaze.show(device, connector, mode, string) to send text to the displays.

Always wrap your logic in a function and register it with do_every_frame("function_name()") to ensure hardware state is polled and displays are updated continuously.

require "arcaze"

local my_arcaze = arcaze.open_first_device()

if my_arcaze ~= nil then
    -- Initialize displays
    arcaze.init_display(my_arcaze, "1b", 15)
    
    function my_hardware_loop()
        -- Read inputs
        local big_wheel, small_wheel = arcaze.read_encoders(my_arcaze)
        local _, _, _, _, button = arcaze.read_pins(my_arcaze)
        
        -- Update displays
        arcaze.show(my_arcaze, "1b", 0xff, "123.456")
    end
    
    do_every_frame("my_hardware_loop()")
end

To create a command that increases a value continuously while a button is held (rather than just once per press), use the on_hold argument (the 4th argument) combined with os.clock() to calculate elapsed time.

Because the on_hold code runs every frame, you should store the initial state (like the starting time and value) in the on_start argument (the 3rd argument) to avoid resetting the calculation every frame. Use \n to separate multiple lines of code within the string arguments.

require("radio")
local obs_up_time = 1
local ops_up_value = 1

create_command("FlyWithLua/testing/increase_OBS",
               "This command increases the OBS value by one degree.",
               "obs_up_time = os.clock() + 2\n
	    obs_up_value = OBS1\n
	    OBS1 = obs_up_value + 1",
               "if os.clock() > obs_up_time then\n
	      OBS1 = 10 * (os.clock() - obs_up_time) + obs_up_value\n
	end",
               "OBS1 = OBS1 % 360")