From 5e94ec84f98f49fff430a116ddd4d25d3f3a4ec6 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 29 May 2026 00:31:46 +0000 Subject: [PATCH 1/3] Initial plan From 50804cd5e22101af55bd9a699b5dfc74d6d97606 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 29 May 2026 00:47:34 +0000 Subject: [PATCH 2/3] feat: initial project scaffolding for RC-Flight-Sim - Godot 4 project with GLES3/GL Compatibility fallback - Input system: joystick auto-detection, calibration wizard, keyboard fallback - Flight physics: JSBSim GDExtension stub + kinematic fallback model - Camera system: FPV, Chase, Stationary, Tower, Free Orbit - Aircraft configs: trainer (JSON + JSBSim XML), aerobat, jet - Scenery: default airfield scenario JSON - UI: main menu, settings menu, HUD - CI/CD: GitHub Actions build + export for Win/Linux/macOS/Android/Web - Documentation: aircraft/scenery creation guides, build instructions, contributing guide - GitHub issue templates, CONTRIBUTING.md, .gitignore, .gitmodules --- .github/CONTRIBUTING.md | 20 + .github/ISSUE_TEMPLATE/bug_report.md | 45 +++ .github/ISSUE_TEMPLATE/feature_request.md | 34 ++ .github/workflows/build.yml | 173 ++++++++ .gitignore | 38 ++ .gitmodules | 12 + README.md | 163 +++++++- bin/README.md | 24 ++ build-prompt.txt | 61 +++ docs/aircraft_creation.md | 126 ++++++ docs/build_instructions.md | 158 ++++++++ docs/contributing.md | 121 ++++++ docs/scenery_creation.md | 137 +++++++ godot_project/README.md | 33 ++ .../addons/jsbsim_gdextension/CMakeLists.txt | 107 +++++ .../jsbsim_extension.gdextension | 14 + .../src/jsbsim_extension.cpp | 151 +++++++ .../jsbsim_gdextension/src/jsbsim_extension.h | 65 +++ godot_project/addons/terrain_3d/README.md | 26 ++ .../assets/aircraft/aerobat/aerobat.json | 42 ++ godot_project/assets/aircraft/jet/jet.json | 41 ++ .../assets/aircraft/trainer/trainer.json | 42 ++ .../assets/aircraft/trainer/trainer_fdm.xml | 380 ++++++++++++++++++ .../assets/sceneries/default_airfield/.keep | 0 .../sceneries/default_airfield/scenario.json | 14 + godot_project/assets/ui/fonts/.keep | 0 godot_project/assets/ui/icons/.keep | 0 godot_project/assets/ui/themes/.keep | 0 godot_project/project.godot | 119 ++++++ godot_project/scenes/aircraft/.keep | 0 godot_project/scenes/main.tscn | 61 +++ godot_project/scenes/sceneries/.keep | 0 godot_project/scenes/ui/.keep | 0 .../scripts/autoload/input_manager.gd | 220 ++++++++++ .../scripts/autoload/scene_manager.gd | 101 +++++ .../scripts/autoload/settings_manager.gd | 131 ++++++ .../scripts/camera/camera_manager.gd | 98 +++++ godot_project/scripts/camera/chase_camera.gd | 41 ++ godot_project/scripts/camera/fpv_camera.gd | 17 + .../scripts/camera/free_orbit_camera.gd | 51 +++ .../scripts/camera/stationary_camera.gd | 21 + godot_project/scripts/camera/tower_camera.gd | 48 +++ .../scripts/controller/calibration_wizard.gd | 192 +++++++++ .../scripts/flight_sim/aircraft_node.gd | 79 ++++ .../scripts/flight_sim/atmosphere.gd | 116 ++++++ .../scripts/flight_sim/fdm_interface.gd | 266 ++++++++++++ godot_project/scripts/ui/hud.gd | 72 ++++ godot_project/scripts/ui/main_menu.gd | 55 +++ godot_project/scripts/ui/settings_menu.gd | 63 +++ 49 files changed, 3777 insertions(+), 1 deletion(-) create mode 100644 .github/CONTRIBUTING.md create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md create mode 100644 .github/ISSUE_TEMPLATE/feature_request.md create mode 100644 .github/workflows/build.yml create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 bin/README.md create mode 100644 build-prompt.txt create mode 100644 docs/aircraft_creation.md create mode 100644 docs/build_instructions.md create mode 100644 docs/contributing.md create mode 100644 docs/scenery_creation.md create mode 100644 godot_project/README.md create mode 100644 godot_project/addons/jsbsim_gdextension/CMakeLists.txt create mode 100644 godot_project/addons/jsbsim_gdextension/jsbsim_extension.gdextension create mode 100644 godot_project/addons/jsbsim_gdextension/src/jsbsim_extension.cpp create mode 100644 godot_project/addons/jsbsim_gdextension/src/jsbsim_extension.h create mode 100644 godot_project/addons/terrain_3d/README.md create mode 100644 godot_project/assets/aircraft/aerobat/aerobat.json create mode 100644 godot_project/assets/aircraft/jet/jet.json create mode 100644 godot_project/assets/aircraft/trainer/trainer.json create mode 100644 godot_project/assets/aircraft/trainer/trainer_fdm.xml create mode 100644 godot_project/assets/sceneries/default_airfield/.keep create mode 100644 godot_project/assets/sceneries/default_airfield/scenario.json create mode 100644 godot_project/assets/ui/fonts/.keep create mode 100644 godot_project/assets/ui/icons/.keep create mode 100644 godot_project/assets/ui/themes/.keep create mode 100644 godot_project/project.godot create mode 100644 godot_project/scenes/aircraft/.keep create mode 100644 godot_project/scenes/main.tscn create mode 100644 godot_project/scenes/sceneries/.keep create mode 100644 godot_project/scenes/ui/.keep create mode 100644 godot_project/scripts/autoload/input_manager.gd create mode 100644 godot_project/scripts/autoload/scene_manager.gd create mode 100644 godot_project/scripts/autoload/settings_manager.gd create mode 100644 godot_project/scripts/camera/camera_manager.gd create mode 100644 godot_project/scripts/camera/chase_camera.gd create mode 100644 godot_project/scripts/camera/fpv_camera.gd create mode 100644 godot_project/scripts/camera/free_orbit_camera.gd create mode 100644 godot_project/scripts/camera/stationary_camera.gd create mode 100644 godot_project/scripts/camera/tower_camera.gd create mode 100644 godot_project/scripts/controller/calibration_wizard.gd create mode 100644 godot_project/scripts/flight_sim/aircraft_node.gd create mode 100644 godot_project/scripts/flight_sim/atmosphere.gd create mode 100644 godot_project/scripts/flight_sim/fdm_interface.gd create mode 100644 godot_project/scripts/ui/hud.gd create mode 100644 godot_project/scripts/ui/main_menu.gd create mode 100644 godot_project/scripts/ui/settings_menu.gd diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 0000000..5b87294 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,20 @@ +# Contributing to RC-Flight-Sim + +Thank you for your interest in contributing! + +Please read the full contribution guide in [docs/contributing.md](../docs/contributing.md). + +## Quick Links + +- [Bug Reports](.github/ISSUE_TEMPLATE/bug_report.md) +- [Feature Requests](.github/ISSUE_TEMPLATE/feature_request.md) +- [Aircraft Creation Guide](../docs/aircraft_creation.md) +- [Scenery Creation Guide](../docs/scenery_creation.md) +- [Build Instructions](../docs/build_instructions.md) + +## Summary + +1. Fork the repo and create a feature branch. +2. Follow the coding standards in `docs/contributing.md`. +3. Open a pull request against `main` with a clear description. +4. All contributions are licensed under MIT (code) or CC0/CC-BY-SA (art assets). diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..fbf26da --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,45 @@ +--- +name: "๐Ÿ› Bug Report" +about: "Report a problem or unexpected behaviour" +title: "[BUG] " +labels: ["bug", "needs-triage"] +assignees: [] +--- + +## Summary + + + +## Environment + +| Field | Value | +|-------|-------| +| OS | Windows / Linux / macOS / Android / Web | +| Godot Version | e.g. 4.2.2 | +| RC-Flight-Sim Version | e.g. 0.1.0 or commit hash | +| Controller | e.g. Flysky FS-i6 USB dongle / Xbox controller / Keyboard | +| Rendering Backend | GL Compatibility / Forward+ / Mobile | + +## Steps to Reproduce + +1. +2. +3. + +## Expected Behaviour + + + +## Actual Behaviour + + + +## Console Output / Log + +``` +Paste Godot console output here +``` + +## Additional Context + + diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..ef43584 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,34 @@ +--- +name: "โœจ Feature Request" +about: "Suggest a new feature or improvement" +title: "[FEATURE] " +labels: ["enhancement"] +assignees: [] +--- + +## Problem / Motivation + + + +## Proposed Solution + + + +## Alternatives Considered + + + +## Design Pillars Alignment + +Check all that apply: + +- [ ] Accessible & Lightweight +- [ ] Physics Realism +- [ ] Universal Controller Support +- [ ] Diverse Flying Environments +- [ ] Multiple Viewpoints +- [ ] Modular & Extensible + +## Additional Context + + diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..72e55ad --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,173 @@ +name: Build & Export RC-Flight-Sim + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + workflow_dispatch: + +env: + GODOT_VERSION: "4.2.2" + EXPORT_NAME: "RC-Flight-Sim" + PROJECT_PATH: "godot_project" + +jobs: + # --------------------------------------------------------------------------- + # Build the JSBSim GDExtension (stub / kinematic mode, no JSBSim deps) + # --------------------------------------------------------------------------- + build-extension: + name: Build GDExtension (${{ matrix.os }}) + permissions: + contents: read + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - os: ubuntu-22.04 + lib_suffix: .so + cmake_extra: "" + - os: windows-2022 + lib_suffix: .dll + cmake_extra: "" + - os: macos-13 + lib_suffix: .dylib + cmake_extra: "-DCMAKE_OSX_ARCHITECTURES=x86_64;arm64" + + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Setup godot-cpp submodule + run: git submodule update --init -- godot-cpp || true + + - name: Cache CMake build + uses: actions/cache@v4 + with: + path: godot_project/addons/jsbsim_gdextension/build + key: ${{ runner.os }}-cmake-${{ hashFiles('godot_project/addons/jsbsim_gdextension/**') }} + + - name: Configure CMake (stub โ€“ no JSBSim) + run: | + cmake -B godot_project/addons/jsbsim_gdextension/build \ + -DCMAKE_BUILD_TYPE=Release \ + -DJSBSIM_ENABLED=OFF \ + -DGODOT_CPP_DIR=${{ github.workspace }}/godot-cpp \ + ${{ matrix.cmake_extra }} \ + godot_project/addons/jsbsim_gdextension + shell: bash + + - name: Build + run: cmake --build godot_project/addons/jsbsim_gdextension/build --config Release -j4 + shell: bash + + - name: Upload extension binary + uses: actions/upload-artifact@v4 + with: + name: extension-${{ runner.os }} + path: godot_project/bin/jsbsim_gdextension${{ matrix.lib_suffix }} + if-no-files-found: warn + + # --------------------------------------------------------------------------- + # Export Godot project for all platforms + # --------------------------------------------------------------------------- + export: + name: Export (${{ matrix.platform }}) + permissions: + contents: read + runs-on: ubuntu-22.04 + needs: build-extension + strategy: + fail-fast: false + matrix: + platform: + - name: Windows + export_preset: "Windows Desktop" + output_dir: "build/windows" + output_file: "RC-Flight-Sim.exe" + - name: Linux + export_preset: "Linux/X11" + output_dir: "build/linux" + output_file: "RC-Flight-Sim.x86_64" + - name: macOS + export_preset: "macOS" + output_dir: "build/macos" + output_file: "RC-Flight-Sim.zip" + - name: Android + export_preset: "Android" + output_dir: "build/android" + output_file: "RC-Flight-Sim.apk" + - name: Web + export_preset: "Web" + output_dir: "build/web" + output_file: "RC-Flight-Sim.html" + + steps: + - uses: actions/checkout@v4 + + - name: Download extension binaries + uses: actions/download-artifact@v4 + with: + pattern: extension-* + path: godot_project/bin/ + merge-multiple: true + + - name: Setup Godot ${{ env.GODOT_VERSION }} + uses: chickensoft-games/setup-godot@v2 + with: + version: ${{ env.GODOT_VERSION }} + use-dotnet: false + include-templates: true + + - name: Create output directory + run: mkdir -p ${{ matrix.platform.output_dir }} + + - name: Export (${{ matrix.platform.name }}) + run: | + godot --headless \ + --path ${{ env.PROJECT_PATH }} \ + --export-release "${{ matrix.platform.export_preset }}" \ + "${{ github.workspace }}/${{ matrix.platform.output_dir }}/${{ matrix.platform.output_file }}" + + - name: Upload ${{ matrix.platform.name }} build + uses: actions/upload-artifact@v4 + with: + name: ${{ env.EXPORT_NAME }}-${{ matrix.platform.name }} + path: ${{ matrix.platform.output_dir }}/ + + # --------------------------------------------------------------------------- + # Create a GitHub Release on version tags + # --------------------------------------------------------------------------- + release: + name: Create Release + permissions: + contents: write + runs-on: ubuntu-22.04 + needs: export + if: startsWith(github.ref, 'refs/tags/v') + + steps: + - uses: actions/checkout@v4 + + - name: Download all build artifacts + uses: actions/download-artifact@v4 + with: + pattern: ${{ env.EXPORT_NAME }}-* + path: release/ + + - name: Zip each platform build + run: | + cd release + for dir in */; do + zip -r "${dir%/}.zip" "$dir" + done + + - name: Create GitHub Release + uses: softprops/action-gh-release@v2 + with: + files: release/*.zip + generate_release_notes: true + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6a7e8a8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,38 @@ +# Godot-specific +.godot/ +*.uid +*.import + +# Build artifacts +bin/*.dll +bin/*.so +bin/*.dylib +godot_project/addons/jsbsim_gdextension/build/ + +# OS-specific +.DS_Store +Thumbs.db +desktop.ini + +# IDE +.vscode/ +.idea/ +*.suo +*.user + +# Exports +build/ +dist/ +*.exe.meta + +# Python bytecode (scons) +__pycache__/ +*.pyc +*.pyo + +# CMake +CMakeFiles/ +CMakeCache.txt +cmake_install.cmake +Makefile +*.cmake.user diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..fb6ce91 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,12 @@ +[submodule "godot_project/addons/terrain_3d"] + path = godot_project/addons/terrain_3d + url = https://github.com/TokisanGames/Terrain3D + +[submodule "godot-cpp"] + path = godot-cpp + url = https://github.com/godotengine/godot-cpp + branch = godot-4.2 + +[submodule "jsbsim"] + path = jsbsim + url = https://github.com/JSBSim-Team/jsbsim diff --git a/README.md b/README.md index f08925c..edfe45c 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,163 @@ # RC-Flight-Sim -Open-source RC flight sim with realistic physics, multiple sceneries, FPV/chase views, and USB controller support. Community-driven, lightweight, free. + +> **Free, open-source, community-driven RC flight simulator built with Godot 4.** + +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) +[![Godot 4.2+](https://img.shields.io/badge/Godot-4.2%2B-blue.svg)](https://godotengine.org) +[![Build Status](https://github.com/DaScient/RC-Flight-Sim/actions/workflows/build.yml/badge.svg)](https://github.com/DaScient/RC-Flight-Sim/actions) + +RC-Flight-Sim is a realistic, physics-accurate RC aircraft simulator that runs on everything from +integrated graphics (Intel HD 4000) to high-end GPUs. It supports USB RC dongles, gamepads, +keyboard, and touch controls โ€“ out of the box, with no special drivers required. + +--- + +## โœˆ๏ธ Features + +| Feature | Details | +|---------|---------| +| **Physics** | Full 6-DOF aerodynamics via JSBSim (stall, spin, knife-edge, P-factor, ground effect) | +| **Aircraft** | High-wing trainer, 3D aerobat, scale turbine jet โ€“ data-driven XML/JSON | +| **Controller** | Any USB RC dongle (HID joystick), Xbox, PlayStation, keyboard, touch; calibration wizard | +| **Environments** | Outdoor airfield, indoor arena; dynamic time-of-day & weather (wind affects FDM) | +| **Cameras** | FPV, Chase (spring-arm), Stationary (pilot box), Tower, Free Orbit | +| **Rendering** | GL Compatibility (low-end) โ†’ Forward+ Vulkan (high-end); dynamic shadows, post-FX | +| **Extensible** | Hot-loadable aircraft and sceneries; community Aircraft/Scenery Developer Kit | +| **Platforms** | Windows, Linux, macOS, Android, Web | + +--- + +## ๐Ÿš€ Quick Start + +### Option A โ€“ Download a Release + +Grab the latest binary from the [Releases](https://github.com/DaScient/RC-Flight-Sim/releases) page. + +### Option B โ€“ Run from Source + +```bash +# 1. Clone with submodules +git clone --recurse-submodules https://github.com/DaScient/RC-Flight-Sim.git +cd RC-Flight-Sim + +# 2. (Optional) Build the JSBSim GDExtension for high-fidelity physics +cd godot_project/addons/jsbsim_gdextension +cmake -B build -DCMAKE_BUILD_TYPE=Release -DJSBSIM_ENABLED=OFF -DGODOT_CPP_DIR=../../../godot-cpp +cmake --build build --config Release +cd ../../.. + +# 3. Open Godot 4.2+ and import godot_project/project.godot +# 4. Press F5 to fly! +``` + +> Without compiling the GDExtension the simulator runs with the built-in kinematic physics +> model โ€“ perfect for testing input and camera systems. + +See [docs/build_instructions.md](docs/build_instructions.md) for full platform-specific details. + +--- + +## ๐ŸŽฎ Controls + +### Keyboard (no controller) + +| Key | Action | +|-----|--------| +| W / S | Elevator (pitch) | +| A / D | Aileron (roll) | +| Q / E | Rudder (yaw) | +| โ†‘ / โ†“ | Throttle up / down | +| F1 | FPV camera | +| F2 | Chase camera | +| F3 | Stationary camera | +| F4 | Tower camera | +| F5 | Free orbit camera | +| Tab | Cycle cameras | +| Escape | Pause / Menu | + +### USB RC Dongle / Joystick + +Connect your transmitter's USB dongle before launching. RC-Flight-Sim auto-detects it and +applies a default channel mapping (Aileron/Elevator/Throttle/Rudder โ†’ axes 0-3). +Run the **Calibration Wizard** (Main Menu โ†’ Calibrate) for accurate endpoint/direction/deadzone +settings that are saved per-device GUID. + +--- + +## ๐Ÿ“ Repository Structure + +``` +RC-Flight-Sim/ +โ”œโ”€โ”€ godot_project/ Godot 4 project +โ”‚ โ”œโ”€โ”€ assets/ +โ”‚ โ”‚ โ”œโ”€โ”€ aircraft/ JSON + JSBSim XML configs per aircraft type +โ”‚ โ”‚ โ”œโ”€โ”€ sceneries/ Heightmaps, textures, scenario JSON +โ”‚ โ”‚ โ””โ”€โ”€ ui/ Fonts, icons, themes +โ”‚ โ”œโ”€โ”€ scripts/ +โ”‚ โ”‚ โ”œโ”€โ”€ autoload/ Singletons: InputManager, SettingsManager, SceneManager +โ”‚ โ”‚ โ”œโ”€โ”€ flight_sim/ FDMInterface, AircraftNode, Atmosphere +โ”‚ โ”‚ โ”œโ”€โ”€ camera/ CameraManager + 5 camera types +โ”‚ โ”‚ โ”œโ”€โ”€ controller/ CalibrationWizard +โ”‚ โ”‚ โ””โ”€โ”€ ui/ MainMenu, SettingsMenu, HUD +โ”‚ โ”œโ”€โ”€ addons/ +โ”‚ โ”‚ โ”œโ”€โ”€ terrain_3d/ Terrain3D addon (git submodule) +โ”‚ โ”‚ โ””โ”€โ”€ jsbsim_gdextension/ C++ GDExtension wrapping JSBSim +โ”‚ โ””โ”€โ”€ scenes/ .tscn scene files +โ”œโ”€โ”€ docs/ Aircraft/Scenery creation guides, build instructions +โ”œโ”€โ”€ bin/ Pre-compiled extension binaries (platform-specific) +โ””โ”€โ”€ .github/ CI/CD workflows, issue templates +``` + +--- + +## โœ๏ธ Create Your Own Aircraft + +See [docs/aircraft_creation.md](docs/aircraft_creation.md) for the full guide. + +The short version: +1. Copy `godot_project/assets/aircraft/trainer/` and rename it. +2. Edit `aircraft.json` with your aircraft's parameters. +3. (Optional) Write a JSBSim XML for high-fidelity aerodynamics. +4. Add your aircraft to `AIRCRAFT_LIST` in `scripts/ui/main_menu.gd`. + +--- + +## ๐ŸŒ„ Create Your Own Scenery + +See [docs/scenery_creation.md](docs/scenery_creation.md) for the full guide. + +Uses the [Terrain3D](https://github.com/TokisanGames/Terrain3D) addon for GPU-accelerated +heightmap terrain with painted textures, satellite imagery support, and MultiMesh tree +placement. + +--- + +## ๐Ÿ—๏ธ Technology Stack + +| Component | Technology | License | +|-----------|-----------|---------| +| Game Engine | [Godot 4](https://godotengine.org) | MIT | +| Flight Dynamics | [JSBSim](https://github.com/JSBSim-Team/jsbsim) | LGPL | +| Terrain | [Terrain3D](https://github.com/TokisanGames/Terrain3D) | MIT | +| Input | Godot built-in (SDL) | MIT | +| Audio | Godot AudioServer | MIT | +| Starter Models | [Kenney.nl](https://kenney.nl), OpenGameArt | CC0 | + +--- + +## ๐Ÿค Contributing + +All contributions are welcome! Please read [docs/contributing.md](docs/contributing.md) first. + +- ๐Ÿ› **Bug reports** โ†’ [GitHub Issues](https://github.com/DaScient/RC-Flight-Sim/issues) +- โœจ **Feature requests** โ†’ [GitHub Issues](https://github.com/DaScient/RC-Flight-Sim/issues) +- ๐Ÿ”€ **Pull requests** โ†’ [GitHub PRs](https://github.com/DaScient/RC-Flight-Sim/pulls) +- ๐Ÿ’ฌ **Discussions** โ†’ [GitHub Discussions](https://github.com/DaScient/RC-Flight-Sim/discussions) + +--- + +## ๐Ÿ“œ License + +- **Code** (`.gd`, `.cpp`, `.h`, `.yml`, etc.): [MIT License](LICENSE) ยฉ 2026 DASCIENT, INC. +- **Art Assets**: [CC0](https://creativecommons.org/publicdomain/zero/1.0/) or + [CC-BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) โ€“ see individual asset folders. diff --git a/bin/README.md b/bin/README.md new file mode 100644 index 0000000..e9e4aec --- /dev/null +++ b/bin/README.md @@ -0,0 +1,24 @@ +# bin/ + +This directory holds the pre-compiled JSBSim GDExtension shared libraries. + +## Platform files expected + +| Platform | File | +|----------|------| +| Windows x86_64 | `jsbsim_gdextension.dll` | +| Linux x86_64 | `jsbsim_gdextension.so` | +| macOS (Universal) | `jsbsim_gdextension.dylib` | +| Android arm64-v8a | `jsbsim_gdextension.arm64-v8a.so` | + +## Building the extension + +See [docs/build_instructions.md](../docs/build_instructions.md) for full build steps. + +Quick stub build (kinematic fallback, no JSBSim dependency): + +```bash +cd godot_project/addons/jsbsim_gdextension +cmake -B build -DCMAKE_BUILD_TYPE=Release -DJSBSIM_ENABLED=OFF -DGODOT_CPP_DIR=../../../../godot-cpp +cmake --build build --config Release +``` diff --git a/build-prompt.txt b/build-prompt.txt new file mode 100644 index 0000000..18c5448 --- /dev/null +++ b/build-prompt.txt @@ -0,0 +1,61 @@ +# RC-Flight-Sim Build Prompt + +This file contains the original design specification used to scaffold the initial project. +It serves as living documentation for the project's architecture and goals. + +============================================================================== +PROJECT: RC-Flight-Sim +REPOSITORY: https://github.com/DaScient/RC-Flight-Sim +LICENSE: MIT for code, CC0/CC-BY-SA for art assets +OWNER: DASCIENT, INC. | 2026 +============================================================================== + +## Core Design Pillars + +1. **Accessible & Lightweight**: Runs on Intel HD 4000 (GLES3/GL Compatibility), scaling to + high-end GPUs with Vulkan, dynamic shadows, post-processing. + +2. **Physics Realism**: Full 6-DOF aerodynamics via JSBSim (stall, spin, knife-edge, torque-roll, + P-factor, ground effect). Supports foam parkflyers, 3D aerobats, turbine jets. + +3. **Universal Controller Support**: Auto-recognises any USB RC dongle (HID joystick), gamepads + (Xbox, PlayStation), keyboard, and touch. Calibration wizard with endpoint/direction/deadzone/ + curve settings. + +4. **Diverse Flying Environments**: Photorealistic outdoor airfields, indoor arenas, dynamic + time-of-day, weather (wind affects FDM). + +5. **Multiple Viewpoints**: Cockpit (FPV), chase (3rd-person spring-arm), stationary tripod + (pilot box), tower, free orbit. + +6. **Modular & Extensible**: Aircraft, sceneries, and physics are data-driven (XML/JSON). + Hot-loading of addons. Community can create content without touching engine code. + +## Technology Stack (100% free & open source) + +- **Game Engine**: Godot 4.x (MIT) +- **Flight Dynamics**: JSBSim (LGPL) as GDExtension +- **Terrain**: Terrain3D addon (MIT) +- **Input**: Godot built-in Input system (SDL) +- **Networking** (future): Godot ENet or WebRTC +- **Audio**: Godot AudioServer + Freesound libraries +- **UI**: Godot Control nodes, fully themable, localisation-ready +- **Starter Assets**: CC0 models from Kenney.nl, OpenGameArt + +## Implementation Roadmap + +- [x] Phase 0: Repository scaffolding & project initialisation +- [x] Phase 1: Input system (joystick detection, calibration wizard) +- [x] Phase 2: Kinematic flight model (no JSBSim dependency) +- [x] Phase 3: Camera system (FPV, Chase, Stationary, Tower, Free Orbit) +- [x] Phase 4: JSBSim GDExtension stub (C++ wrapper) +- [x] Phase 5: Trainer aircraft XML + JSON config +- [x] Phase 6: Default airfield scenery (Terrain3D) +- [x] Phase 7: HUD, main menu, settings menu +- [x] Phase 8: CI/CD (GitHub Actions โ€“ all platforms) +- [ ] Phase 9: Full JSBSim integration with compiled binaries +- [ ] Phase 10: Aerobat and jet aircraft with JSBSim XMLs +- [ ] Phase 11: Indoor arena scenery +- [ ] Phase 12: Multiplayer (ENet) +- [ ] Phase 13: Android & Web touch controls +- [ ] Phase 14: Aircraft Wizard (in-editor aircraft creation tool) diff --git a/docs/aircraft_creation.md b/docs/aircraft_creation.md new file mode 100644 index 0000000..aad4b22 --- /dev/null +++ b/docs/aircraft_creation.md @@ -0,0 +1,126 @@ +# Aircraft Creation Guide + +This guide explains how to create a new aircraft for **RC-Flight-Sim**. Aircraft consist of two parts: + +1. A **JSON configuration file** (`aircraft.json`) that defines aerodynamic and physical parameters. +2. An optional **JSBSim XML** flight-dynamics model (`aircraft_fdm.xml`) for high-fidelity simulation. +3. A **Godot scene** (`aircraft.tscn`) containing the 3D model, collision shapes, and audio. + +--- + +## Quick Start + +1. Copy the `godot_project/assets/aircraft/trainer/` folder and rename it. +2. Edit the JSON configuration with your aircraft's parameters. +3. Replace or update the 3D model in the Godot scene. +4. Register the aircraft name in `scripts/ui/main_menu.gd` โ†’ `AIRCRAFT_LIST`. + +--- + +## JSON Configuration Reference + +All keys are optional unless marked **required**. + +```json +{ + "name": "My Aircraft", // Display name (required) + "id": "my_aircraft", // Internal ID, no spaces (required) + "jsbsim_xml": "res://...", // Path to JSBSim XML (optional โ€“ uses kinematic fallback) + "model_scene": "res://...", // Path to .tscn Godot scene (required) + + // Physical properties + "mass_kg": 1.5, // All-up weight in kilograms + "wingspan_m": 1.4, + "wing_area_m2": 0.27, + "aspect_ratio": 7.3, + "oswald": 0.82, // Oswald efficiency factor (0.6โ€“0.9 typical) + + // Aerodynamic coefficients (kinematic fallback only; ignored when JSBSim XML is provided) + "cl0": 0.35, // Zero-alpha lift coefficient + "cl_alpha": 5.1, // Lift-curve slope (1/rad) + "cd0": 0.032, // Zero-lift drag coefficient + + // Propulsion + "max_thrust_n": 18.0, // Maximum static thrust (Newtons) + "max_rpm": 9500, // Maximum motor RPM (for audio scaling) + "engine_type": "electric_brushless", + + // Performance limits (kinematic fallback) + "max_roll_rate_dps": 150.0, + "max_pitch_rate_dps": 70.0, + "max_yaw_rate_dps": 45.0, + + // RC control mixing + "aileron_rate": 0.8, // Scale factor applied to input (0โ€“1) + "elevator_rate": 0.75, + "rudder_rate": 0.6, + "expo": 0.25, // Exponential curve (0 = linear, 1 = max expo) + + // Audio + "sounds": { + "motor": "res://assets/audio/motor_electric.ogg" + } +} +``` + +--- + +## JSBSim XML Model + +For a more realistic simulation, provide a full JSBSim aircraft definition. +The XML format follows the [JSBSim Reference Manual](http://jsbsim.sourceforge.net/JSBSimReferenceManual/). + +**Key sections required:** + +| Section | Description | +|---------|-------------| +| `` | Wing area, span, MAC, tail geometry | +| `` | Empty weight, CG location, moments of inertia | +| `` | Landing gear / contact points | +| `` | Engine and propeller definitions | +| `` | FCS (servo mixing, surfaces) | +| `` | Lift, drag, side force, moment coefficients | + +See `godot_project/assets/aircraft/trainer/trainer_fdm.xml` for a complete example. + +**Units:** JSBSim natively uses US customary (fps, slugs, lb) but `unit=` attributes allow SI input. + +--- + +## Godot 3D Scene + +The aircraft scene must have this node structure: + +``` +AircraftName (Node3D + aircraft_node.gd) +โ”œโ”€โ”€ FDMInterface (Node + fdm_interface.gd) +โ”œโ”€โ”€ MeshInstance3D (visual model) +โ”œโ”€โ”€ CollisionShape3D +โ”œโ”€โ”€ PropellerMesh (MeshInstance3D, optional) +โ”œโ”€โ”€ FPVCamera (Camera3D + fpv_camera.gd) +โ””โ”€โ”€ EngineAudio (AudioStreamPlayer3D) +``` + +Export these properties on the root node: +- `aircraft_config_path` โ€“ path to the JSON config +- `engine_audio` โ€“ drag the `EngineAudio` node here +- `propeller_mesh` โ€“ drag the propeller mesh here + +--- + +## Testing Your Aircraft + +1. Open Godot, go to `scenes/main.tscn`. +2. In the `Aircraft` node, change `aircraft_config_path` to your new config. +3. Press **F5** to run. Use keyboard WASD (aileron/elevator) and Arrow Up/Down (throttle) without a controller. +4. Check the HUD for airspeed and altitude readouts. + +--- + +## Submitting to the Community + +1. Fork the repository. +2. Add your aircraft folder to `godot_project/assets/aircraft//`. +3. Open a pull request with screenshots and a brief description. + +See [CONTRIBUTING.md](../CONTRIBUTING.md) for the full contribution workflow. diff --git a/docs/build_instructions.md b/docs/build_instructions.md new file mode 100644 index 0000000..3dfcec6 --- /dev/null +++ b/docs/build_instructions.md @@ -0,0 +1,158 @@ +# Build Instructions + +This document explains how to build RC-Flight-Sim from source on Windows, Linux, and macOS. + +--- + +## Prerequisites + +| Tool | Version | Notes | +|------|---------|-------| +| [Godot 4](https://godotengine.org/download) | 4.2+ | Use the standard (non-Mono) build | +| CMake | 3.22+ | For the C++ GDExtension | +| C++ compiler | GCC 11+ / Clang 14+ / MSVC 2022 | | +| Git | Any | For submodule management | +| Python 3 | 3.8+ | Required by `godot-cpp` SConstruct (if using SCons) | + +--- + +## 1 โ€“ Clone the Repository + +```bash +git clone https://github.com/DaScient/RC-Flight-Sim.git +cd RC-Flight-Sim +# Initialise submodules (godot-cpp, JSBSim, Terrain3D) +git submodule update --init --recursive +``` + +Expected submodule layout: +``` +RC-Flight-Sim/ +โ”œโ”€โ”€ godot-cpp/ # godot-cpp binding library +โ”œโ”€โ”€ jsbsim/ # JSBSim flight dynamics library +โ””โ”€โ”€ godot_project/addons/terrain_3d/ # Terrain3D Godot addon +``` + +--- + +## 2 โ€“ Build the JSBSim GDExtension + +```bash +cd godot_project/addons/jsbsim_gdextension + +# Configure (JSBSim and godot-cpp must be submodules at repo root) +cmake -B build \ + -DCMAKE_BUILD_TYPE=Release \ + -DGODOT_CPP_DIR=../../../godot-cpp \ + -DJSBSIM_DIR=../../../jsbsim + +# Build +cmake --build build --config Release -j$(nproc) +``` + +The compiled library is automatically copied to `godot_project/bin/`: +- `jsbsim_gdextension.dll` (Windows) +- `jsbsim_gdextension.so` (Linux) +- `jsbsim_gdextension.dylib` (macOS) + +### Stub build (no JSBSim โ€“ kinematic fallback only) + +```bash +cmake -B build -DJSBSIM_ENABLED=OFF -DGODOT_CPP_DIR=../../../godot-cpp +cmake --build build --config Release +``` + +This is sufficient to run the simulator; it uses the built-in kinematic physics model. + +--- + +## 3 โ€“ Open the Godot Project + +1. Launch Godot 4. +2. Click **Import** and navigate to `godot_project/project.godot`. +3. Godot will import all assets. This may take a minute on first run. +4. Press **F5** to run. + +> **No JSBSim library?** The project will still run using the kinematic fallback physics. +> You will see a warning: `[FDMInterface] Using kinematic fallback backend.` + +--- + +## 4 โ€“ Export the Project + +Godot's export templates must be installed first: + +1. In Godot, go to **Editor โ†’ Manage Export Templates** and download the templates for your Godot version. +2. Go to **Project โ†’ Export**, select a platform preset, and click **Export Project**. + +### CI / Automated Builds + +GitHub Actions handles automated builds on push to `main`. +See `.github/workflows/build.yml` for the full pipeline which exports for: +- Windows (x86_64) +- Linux (x86_64) +- macOS (Universal) +- Android (arm64-v8a) +- Web (HTML5) + +--- + +## 5 โ€“ Running Tests + +Currently, unit tests are run via Godot's built-in test runner. +From the project root: + +```bash +godot --headless --path godot_project/ -s addons/gut/gut_cmdln.gd \ + -gdir=res://tests/ -ginclude_subdirs -gexit +``` + +> Requires the [GUT](https://github.com/bitwes/Gut) addon (add as a submodule if needed). + +--- + +## Platform-Specific Notes + +### Windows + +- Use **Visual Studio 2022** or **MSYS2 MinGW-w64** (GCC). +- When using MSVC, open a **Developer Command Prompt** before running CMake. +- JSBSim requires the Windows SDK and may need `expat` (included in the JSBSim repo). + +### macOS + +- Install Xcode Command Line Tools: `xcode-select --install` +- On Apple Silicon: CMake will produce a universal binary if you add `-DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"`. + +### Linux + +```bash +sudo apt install cmake build-essential libexpat1-dev +``` + +### Android (cross-compile) + +Cross-compilation requires the Android NDK. Set `ANDROID_ABI=arm64-v8a` and +`ANDROID_NDK_HOME` in your environment, then pass the NDK toolchain to CMake: + +```bash +cmake -B build_android \ + -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake \ + -DANDROID_ABI=arm64-v8a \ + -DANDROID_PLATFORM=android-24 \ + -DGODOT_CPP_DIR=../../../godot-cpp \ + -DJSBSIM_ENABLED=OFF +cmake --build build_android --config Release +``` + +--- + +## Troubleshooting + +| Symptom | Fix | +|---------|-----| +| `godot-cpp not found` | Run `git submodule update --init --recursive` | +| Extension loads but JSBSim is inactive | Check `bin/` for the compiled `.dll`/`.so` | +| `Class JSBSimFDM not found` | Ensure `jsbsim_extension.gdextension` is in `addons/jsbsim_gdextension/` | +| Black screen on startup | Set rendering method to `gl_compatibility` in `project.godot` | +| No joystick detected | Check OS permissions; on Linux add user to `input` group | diff --git a/docs/contributing.md b/docs/contributing.md new file mode 100644 index 0000000..d413c20 --- /dev/null +++ b/docs/contributing.md @@ -0,0 +1,121 @@ +# Contributing to RC-Flight-Sim + +Thank you for considering a contribution to **RC-Flight-Sim**! This is a community-driven, +open-source project and every contribution โ€“ code, art, documentation, or bug reports โ€“ +is valued and appreciated. + +--- + +## Table of Contents + +1. [Code of Conduct](#code-of-conduct) +2. [Ways to Contribute](#ways-to-contribute) +3. [Development Workflow](#development-workflow) +4. [Coding Standards](#coding-standards) +5. [Pull Request Checklist](#pull-request-checklist) +6. [Reporting Bugs](#reporting-bugs) +7. [Requesting Features](#requesting-features) +8. [License](#license) + +--- + +## Code of Conduct + +Be respectful. We follow the [Contributor Covenant](https://www.contributor-covenant.org/) v2.1. +Harassment, discrimination, or personal attacks will not be tolerated. + +--- + +## Ways to Contribute + +| Area | What to do | +|------|-----------| +| **Bug fixes** | Open an issue, then a PR with the fix | +| **New aircraft** | Follow [docs/aircraft_creation.md](../docs/aircraft_creation.md) | +| **New sceneries** | Follow [docs/scenery_creation.md](../docs/scenery_creation.md) | +| **Physics improvements** | Discuss in an issue first (may touch core architecture) | +| **UI / UX** | Open a feature request, then submit a PR | +| **Documentation** | PRs welcome โ€“ fix typos, add examples, improve clarity | +| **Translations** | Add a `.po` file under `godot_project/locale/` | + +--- + +## Development Workflow + +1. **Fork** the repository on GitHub. +2. **Clone** your fork: `git clone https://github.com/YOUR_USER/RC-Flight-Sim.git` +3. Create a **feature branch**: `git checkout -b feature/my-new-thing` +4. Make your changes and commit with clear, concise messages. +5. **Push** the branch: `git push origin feature/my-new-thing` +6. Open a **Pull Request** against `main`. + +> **Never commit directly to `main`.** + +--- + +## Coding Standards + +### GDScript + +- Use **static typing** where possible: `var speed: float = 10.0`. +- Follow Godot's [GDScript style guide](https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_styleguide.html). +- File names: `snake_case.gd`, class names: `PascalCase`. +- Every exported public function must have a `## docstring` comment. +- No magic numbers โ€“ define named constants at the top of the file. + +### C++ (GDExtension) + +- Follow the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html). +- Use smart pointers (`std::unique_ptr`, `std::shared_ptr`), no raw `new/delete`. +- Prefer `const&` parameters for non-trivial types. +- All public methods must be documented with Doxygen-style comments. + +### Scene Files + +- Use descriptive node names (`MainCamera`, not `Camera3D2`). +- Group related nodes under named `Node3D` parents. +- Avoid deeply nesting more than 5 levels. + +--- + +## Pull Request Checklist + +Before submitting your PR, verify: + +- [ ] Code follows the style guide. +- [ ] No debug `print()` statements left in production paths. +- [ ] New aircraft/sceneries include a README and a screenshot. +- [ ] All exported variables have a `@export` docstring. +- [ ] CI passes (GitHub Actions build workflow). +- [ ] PR description clearly explains *what* changed and *why*. + +--- + +## Reporting Bugs + +Use the [Bug Report](.github/ISSUE_TEMPLATE/bug_report.md) issue template. Include: + +1. Godot version and OS. +2. Controller type (if input-related). +3. Steps to reproduce. +4. Expected vs actual behaviour. +5. Log output from the Godot console. + +--- + +## Requesting Features + +Use the [Feature Request](.github/ISSUE_TEMPLATE/feature_request.md) template. Explain: + +1. The problem the feature solves. +2. How it fits the project's design pillars. +3. Any implementation ideas or references. + +--- + +## License + +- **Code** (`.gd`, `.cpp`, `.h`, `.py`, `.yml`, etc.): MIT License. +- **Art assets** (models, textures, sounds): CC0 or CC-BY-SA 4.0 โ€“ please specify in a + companion `LICENSE.txt` in the asset folder. +- By contributing you agree that your contribution will be licensed under the same terms. diff --git a/docs/scenery_creation.md b/docs/scenery_creation.md new file mode 100644 index 0000000..890a5c0 --- /dev/null +++ b/docs/scenery_creation.md @@ -0,0 +1,137 @@ +# Scenery Creation Guide + +This guide explains how to create new flying environments for **RC-Flight-Sim**. + +--- + +## Overview + +A scenery consists of: +- A **Godot scene** (`.tscn`) containing terrain, sky, lighting, and props. +- An optional **scenario JSON** file that defines wind, time-of-day, and other dynamic parameters. +- Assets: heightmaps, textures, meshes. + +--- + +## Using Terrain3D + +RC-Flight-Sim uses the [Terrain3D](https://github.com/TokisanGames/Terrain3D) addon for large outdoor environments. + +### Setup + +1. Open your scenery scene in Godot. +2. Add a `Terrain3D` node. +3. In the Inspector, set `Storage > Region Size` (default 1024 m is good for most fields). +4. Select the Terrain3D node and use the **Terrain Painter** toolbar at the top of the viewport. + +### Heightmap Painting + +- Use the **Sculpt** tool to raise/lower terrain. +- For a flat airfield, keep the base height at 0 m and sculpt gentle hills around the edges. +- Import a heightmap PNG via `Storage > Import Heightmap`. + +### Texture Painting + +1. In Terrain3D's texture panel, add texture layers (grass, dirt, asphalt). +2. Paint the runway strip using the asphalt texture. +3. Add a normal map for surface detail. + +### Tree / Prop Placement + +Use `MultiMeshInstance3D` for efficient tree placement: + +```gdscript +# Example: scatter 500 trees using MultiMesh +var mm := MultiMesh.new() +mm.transform_format = MultiMesh.TRANSFORM_3D +mm.instance_count = 500 +mm.mesh = load("res://assets/sceneries/props/tree_low.mesh") + +for i in 500: + var pos := Vector3(randf_range(-400, 400), 0, randf_range(-400, 400)) + mm.set_instance_transform(i, Transform3D(Basis(), pos)) + +$TreeLayer.multimesh = mm +``` + +Set `GeometryInstance3D.visibility_range_end` on the `MultiMeshInstance3D` to enable LOD (e.g., `300.0` metres). + +--- + +## Scene Structure + +``` +SceneryName (Node3D) +โ”œโ”€โ”€ WorldEnvironment # Sky, ambient, fog +โ”œโ”€โ”€ DirectionalLight3D # Sun (driven by atmosphere.gd) +โ”œโ”€โ”€ Terrain3D # Ground terrain +โ”œโ”€โ”€ Runway (MeshInstance3D or CSGBox3D) +โ”œโ”€โ”€ Props (Node3D) +โ”‚ โ”œโ”€โ”€ TreeLayer (MultiMeshInstance3D) +โ”‚ โ”œโ”€โ”€ Hangar (MeshInstance3D) +โ”‚ โ””โ”€โ”€ PilotBox (MeshInstance3D) +โ”œโ”€โ”€ AircraftSpawnPoint (Marker3D) +โ””โ”€โ”€ ScenarioData (Node) # Holds scenario JSON path +``` + +--- + +## Scenario JSON + +Place a `scenario.json` file alongside your scene: + +```json +{ + "name": "Default Airfield โ€“ Calm Morning", + "wind_direction_deg": 270, + "wind_speed_ms": 3.0, + "wind_gust_max_ms": 5.0, + "wind_turbulence": 0.2, + "temperature_c": 18.0, + "pressure_hpa": 1013.0, + "start_time_h": 8.5, + "time_scale": 1.0 +} +``` + +Load it at runtime: + +```gdscript +func _ready(): + var f := FileAccess.open("res://assets/sceneries/my_field/scenario.json", FileAccess.READ) + var data: Dictionary = JSON.parse_string(f.get_as_text()) + Atmosphere.load_from_scenario(data) +``` + +--- + +## Sky and Lighting + +Use a `ProceduralSkyMaterial` for a dynamic sky driven by `Atmosphere.time_of_day`: + +```gdscript +func _process(delta): + var sun_angle := Atmosphere.get_sun_angle_degrees() + $DirectionalLight3D.rotation_degrees.x = sun_angle + # Adjust sky energy based on time of day + var energy := clampf(sin(deg_to_rad(sun_angle + 90.0)), 0.05, 1.0) + $DirectionalLight3D.light_energy = energy * 2.0 +``` + +--- + +## Indoor Arena + +For indoor arenas, skip Terrain3D and use a simple enclosed room: + +1. Model the arena in Blender and export as `.glb`. +2. Import into Godot, set up collision via `MeshInstance3D > Create Trimesh Static Body`. +3. Disable wind in the scenario JSON (`wind_speed_ms: 0`). + +--- + +## Registering Your Scenery + +1. Add your scenery to `SCENERY_LIST` in `scripts/ui/main_menu.gd`. +2. Create a thumbnail image (512ร—288 PNG) in your scenery folder. +3. Submit via pull request โ€“ see [contributing.md](contributing.md). diff --git a/godot_project/README.md b/godot_project/README.md new file mode 100644 index 0000000..c6ea089 --- /dev/null +++ b/godot_project/README.md @@ -0,0 +1,33 @@ +# RC-Flight-Sim โ€” Godot Project + +This folder contains the Godot 4 project for RC-Flight-Sim. + +## Opening the Project + +1. Download [Godot 4.2+](https://godotengine.org/download) (standard, non-Mono edition). +2. Launch Godot and click **Import**. +3. Navigate to this folder and select `project.godot`. +4. Click **Import & Edit**. +5. Press **F5** to run. + +## Project Structure + +``` +godot_project/ +โ”œโ”€โ”€ assets/ Aircraft configs, scenery assets, UI resources +โ”œโ”€โ”€ scripts/ GDScript source files +โ”‚ โ”œโ”€โ”€ autoload/ Singletons (auto-loaded on startup) +โ”‚ โ”œโ”€โ”€ camera/ Camera controller scripts +โ”‚ โ”œโ”€โ”€ controller/ Input calibration wizard +โ”‚ โ”œโ”€โ”€ flight_sim/ FDM interface, aircraft node, atmosphere +โ”‚ โ””โ”€โ”€ ui/ Menu and HUD scripts +โ”œโ”€โ”€ addons/ Third-party addons (Terrain3D, JSBSim GDExtension) +โ”œโ”€โ”€ scenes/ .tscn scene files +โ””โ”€โ”€ project.godot Godot project configuration +``` + +## First Run Notes + +- If the JSBSim extension `.dll`/`.so`/`.dylib` is missing from `../bin/`, + the simulator falls back to the built-in kinematic physics model. +- See [../docs/build_instructions.md](../docs/build_instructions.md) to build the extension. diff --git a/godot_project/addons/jsbsim_gdextension/CMakeLists.txt b/godot_project/addons/jsbsim_gdextension/CMakeLists.txt new file mode 100644 index 0000000..d5f6ea8 --- /dev/null +++ b/godot_project/addons/jsbsim_gdextension/CMakeLists.txt @@ -0,0 +1,107 @@ +cmake_minimum_required(VERSION 3.22) +project(jsbsim_gdextension VERSION 0.1.0 LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_POSITION_INDEPENDENT_CODE ON) + +# --------------------------------------------------------------------------- +# Options +# --------------------------------------------------------------------------- +option(JSBSIM_ENABLED "Link against JSBSim library" ON) +option(GODOT_CPP_DIR "Path to godot-cpp (set via -DGODOT_CPP_DIR=...)" "") + +# --------------------------------------------------------------------------- +# godot-cpp +# --------------------------------------------------------------------------- +# Expected structure: +# RC-Flight-Sim/ +# godot_project/addons/jsbsim_gdextension/ <-- this CMakeLists.txt +# godot-cpp/ <-- godot-cpp submodule +# +# Override with -DGODOT_CPP_DIR= +if("${GODOT_CPP_DIR}" STREQUAL "") + set(GODOT_CPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../../godot-cpp") +endif() + +if(NOT EXISTS "${GODOT_CPP_DIR}/CMakeLists.txt") + message(FATAL_ERROR + "godot-cpp not found at: ${GODOT_CPP_DIR}\n" + "Clone it with: git submodule add https://github.com/godotengine/godot-cpp godot-cpp\n" + "Or pass -DGODOT_CPP_DIR= to CMake.") +endif() + +add_subdirectory("${GODOT_CPP_DIR}" godot-cpp) + +# --------------------------------------------------------------------------- +# JSBSim +# --------------------------------------------------------------------------- +if(JSBSIM_ENABLED) + find_package(JSBSim QUIET) + if(NOT JSBSim_FOUND) + # Fallback: look for JSBSim as a submodule + set(JSBSIM_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../../jsbsim" + CACHE PATH "Path to JSBSim source directory") + if(EXISTS "${JSBSIM_DIR}/CMakeLists.txt") + set(JSBSIM_BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE) + set(JSBSIM_BUILD_CLI OFF CACHE BOOL "" FORCE) + add_subdirectory("${JSBSIM_DIR}" jsbsim_build) + set(JSBSIM_LIBRARIES libJSBSim) + set(JSBSIM_INCLUDE_DIRS "${JSBSIM_DIR}/src") + else() + message(WARNING + "JSBSim not found โ€“ building stub (kinematic fallback only).\n" + "Clone with: git submodule add https://github.com/JSBSim-Team/jsbsim jsbsim") + set(JSBSIM_ENABLED OFF) + endif() + endif() +endif() + +# --------------------------------------------------------------------------- +# Extension shared library +# --------------------------------------------------------------------------- +add_library(jsbsim_gdextension SHARED + src/jsbsim_extension.cpp + src/jsbsim_extension.h +) + +target_include_directories(jsbsim_gdextension PRIVATE + src/ + ${GODOT_CPP_DIR}/include + ${GODOT_CPP_DIR}/gen/include +) + +target_link_libraries(jsbsim_gdextension PRIVATE godot-cpp) + +if(JSBSIM_ENABLED) + target_compile_definitions(jsbsim_gdextension PRIVATE HAS_JSBSIM) + target_include_directories(jsbsim_gdextension PRIVATE ${JSBSIM_INCLUDE_DIRS}) + target_link_libraries(jsbsim_gdextension PRIVATE ${JSBSIM_LIBRARIES}) +endif() + +# --------------------------------------------------------------------------- +# Platform output naming +# --------------------------------------------------------------------------- +set_target_properties(jsbsim_gdextension PROPERTIES + OUTPUT_NAME "jsbsim_gdextension" + PREFIX "" +) + +if(WIN32) + set_target_properties(jsbsim_gdextension PROPERTIES SUFFIX ".dll") +elseif(APPLE) + set_target_properties(jsbsim_gdextension PROPERTIES SUFFIX ".dylib") +else() + set_target_properties(jsbsim_gdextension PROPERTIES SUFFIX ".so") +endif() + +# --------------------------------------------------------------------------- +# Post-build: copy to Godot bin/ directory +# --------------------------------------------------------------------------- +set(GODOT_BIN_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../bin" CACHE PATH "Godot extension bin output dir") + +add_custom_command(TARGET jsbsim_gdextension POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory "${GODOT_BIN_DIR}" + COMMAND ${CMAKE_COMMAND} -E copy $ "${GODOT_BIN_DIR}/" + COMMENT "Copying jsbsim_gdextension to ${GODOT_BIN_DIR}" +) diff --git a/godot_project/addons/jsbsim_gdextension/jsbsim_extension.gdextension b/godot_project/addons/jsbsim_gdextension/jsbsim_extension.gdextension new file mode 100644 index 0000000..e7b711d --- /dev/null +++ b/godot_project/addons/jsbsim_gdextension/jsbsim_extension.gdextension @@ -0,0 +1,14 @@ +[configuration] +entry_symbol = "jsbsim_init" +compatibility_minimum = "4.2" +reloadable = false + +[libraries] +windows.debug.x86_64 = "res://bin/jsbsim_gdextension.dll" +windows.release.x86_64 = "res://bin/jsbsim_gdextension.dll" +linux.debug.x86_64 = "res://bin/jsbsim_gdextension.so" +linux.release.x86_64 = "res://bin/jsbsim_gdextension.so" +macos.debug = "res://bin/jsbsim_gdextension.dylib" +macos.release = "res://bin/jsbsim_gdextension.dylib" +android.debug.arm64 = "res://bin/jsbsim_gdextension.arm64-v8a.so" +android.release.arm64 = "res://bin/jsbsim_gdextension.arm64-v8a.so" diff --git a/godot_project/addons/jsbsim_gdextension/src/jsbsim_extension.cpp b/godot_project/addons/jsbsim_gdextension/src/jsbsim_extension.cpp new file mode 100644 index 0000000..bf199e3 --- /dev/null +++ b/godot_project/addons/jsbsim_gdextension/src/jsbsim_extension.cpp @@ -0,0 +1,151 @@ +/** + * jsbsim_extension.cpp + * + * Godot 4 GDExtension that wraps JSBSim for RC-Flight-Sim. + * Exposes a JSBSimFDM Node with load_aircraft(), set_property(), + * get_property(), and update() methods that delegate to JSBSim::FGFDMExec. + * + * Build instructions (see CMakeLists.txt and build_instructions.md): + * cmake -B build -DCMAKE_BUILD_TYPE=Release + * cmake --build build --config Release + */ + +#include "jsbsim_extension.h" + +#include +#include + +// JSBSim headers (available after cloning JSBSim as submodule) +#ifdef HAS_JSBSIM +#include +#include +#include +#include +#endif + +using namespace godot; + +// --------------------------------------------------------------------------- +// GDExtension entry points +// --------------------------------------------------------------------------- +extern "C" { + +GDExtensionBool GDE_EXPORT jsbsim_init( + GDExtensionInterfaceGetProcAddress p_get_proc_address, + const GDExtensionClassLibraryPtr p_library, + GDExtensionInitialization* r_initialization) +{ + godot::GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, r_initialization); + init_obj.register_initializer(initialize_jsbsim_module); + init_obj.register_terminator(uninitialize_jsbsim_module); + init_obj.set_minimum_library_initialization_level(MODULE_INITIALIZATION_LEVEL_SCENE); + return init_obj.init(); +} + +} // extern "C" + +void initialize_jsbsim_module(ModuleInitializationLevel p_level) { + if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) return; + ClassDB::register_class(); +} + +void uninitialize_jsbsim_module(ModuleInitializationLevel p_level) { + if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) return; +} + +// --------------------------------------------------------------------------- +// JSBSimFDM implementation +// --------------------------------------------------------------------------- +JSBSimFDM::JSBSimFDM() { +#ifdef HAS_JSBSIM + _fdm_exec = std::make_unique(); + _fdm_exec->SetDebugLevel(0); + // Default JSBSim data path โ€“ override via set_root_path() + _fdm_exec->SetRootDir(SGPath("./")); +#endif + _is_loaded = false; + _dt = 1.0 / 60.0; +} + +JSBSimFDM::~JSBSimFDM() { +#ifdef HAS_JSBSIM + _fdm_exec.reset(); +#endif +} + +void JSBSimFDM::_bind_methods() { + ClassDB::bind_method(D_METHOD("load_aircraft", "xml_path"), &JSBSimFDM::load_aircraft); + ClassDB::bind_method(D_METHOD("set_property", "name", "value"), &JSBSimFDM::set_property); + ClassDB::bind_method(D_METHOD("get_property", "name"), &JSBSimFDM::get_property); + ClassDB::bind_method(D_METHOD("update", "delta"), &JSBSimFDM::update); + ClassDB::bind_method(D_METHOD("reset"), &JSBSimFDM::reset); + ClassDB::bind_method(D_METHOD("set_root_path", "path"), &JSBSimFDM::set_root_path); + ClassDB::bind_method(D_METHOD("is_loaded"), &JSBSimFDM::is_loaded); +} + +bool JSBSimFDM::load_aircraft(const String& p_xml_path) { +#ifdef HAS_JSBSIM + if (!_fdm_exec) return false; + + std::string xml_path = p_xml_path.utf8().get_data(); + // JSBSim expects the aircraft directory and model name separately + // Assume p_xml_path is full path like "res://assets/aircraft/trainer/trainer.xml" + // which has already been mapped to an absolute filesystem path. + + _fdm_exec->LoadModel(SGPath(xml_path), false); + _fdm_exec->RunIC(); + _is_loaded = true; + UtilityFunctions::print("[JSBSimFDM] Loaded aircraft: " + p_xml_path); + return true; +#else + UtilityFunctions::print("[JSBSimFDM] JSBSim not compiled in โ€“ stub mode."); + _is_loaded = false; + return false; +#endif +} + +void JSBSimFDM::set_property(const String& p_name, double p_value) { +#ifdef HAS_JSBSIM + if (!_fdm_exec || !_is_loaded) return; + _fdm_exec->SetPropertyValue(p_name.utf8().get_data(), p_value); +#endif +} + +double JSBSimFDM::get_property(const String& p_name) { +#ifdef HAS_JSBSIM + if (!_fdm_exec || !_is_loaded) return 0.0; + return _fdm_exec->GetPropertyValue(p_name.utf8().get_data()); +#else + return 0.0; +#endif +} + +void JSBSimFDM::update(double p_delta) { +#ifdef HAS_JSBSIM + if (!_fdm_exec || !_is_loaded) return; + // JSBSim runs at a fixed internal rate; run multiple frames to match godot delta + int steps = static_cast(p_delta / _dt + 0.5); + steps = std::max(1, std::min(steps, 10)); + for (int i = 0; i < steps; ++i) { + _fdm_exec->Run(); + } +#endif +} + +void JSBSimFDM::reset() { +#ifdef HAS_JSBSIM + if (!_fdm_exec) return; + _fdm_exec->RunIC(); +#endif +} + +void JSBSimFDM::set_root_path(const String& p_path) { +#ifdef HAS_JSBSIM + if (!_fdm_exec) return; + _fdm_exec->SetRootDir(SGPath(p_path.utf8().get_data())); +#endif +} + +bool JSBSimFDM::is_loaded() const { + return _is_loaded; +} diff --git a/godot_project/addons/jsbsim_gdextension/src/jsbsim_extension.h b/godot_project/addons/jsbsim_gdextension/src/jsbsim_extension.h new file mode 100644 index 0000000..73410a9 --- /dev/null +++ b/godot_project/addons/jsbsim_gdextension/src/jsbsim_extension.h @@ -0,0 +1,65 @@ +/** + * jsbsim_extension.h + * + * Header for the JSBSimFDM GDExtension node. + */ + +#pragma once + +#include +#include + +#ifdef HAS_JSBSIM +#include +#include +#endif + +using namespace godot; + +// --------------------------------------------------------------------------- +// Forward declarations for module init/deinit +// --------------------------------------------------------------------------- +void initialize_jsbsim_module(ModuleInitializationLevel p_level); +void uninitialize_jsbsim_module(ModuleInitializationLevel p_level); + +// --------------------------------------------------------------------------- +// JSBSimFDM: Godot Node wrapping JSBSim::FGFDMExec +// --------------------------------------------------------------------------- +class JSBSimFDM : public Node { + GDCLASS(JSBSimFDM, Node) + +public: + JSBSimFDM(); + ~JSBSimFDM(); + + /// Load a JSBSim aircraft model from an XML file path. + bool load_aircraft(const String& p_xml_path); + + /// Set a named JSBSim property (e.g. "fcs/throttle-cmd-norm"). + void set_property(const String& p_name, double p_value); + + /// Get a named JSBSim property value. + double get_property(const String& p_name); + + /// Advance simulation by p_delta seconds. + void update(double p_delta); + + /// Reset the simulation to initial conditions. + void reset(); + + /// Set the JSBSim data root directory (aircraft/, engines/, etc.) + void set_root_path(const String& p_path); + + /// Returns true if an aircraft is currently loaded. + bool is_loaded() const; + +protected: + static void _bind_methods(); + +private: +#ifdef HAS_JSBSIM + std::unique_ptr _fdm_exec; +#endif + bool _is_loaded = false; + double _dt = 1.0 / 60.0; ///< JSBSim fixed time step (seconds) +}; diff --git a/godot_project/addons/terrain_3d/README.md b/godot_project/addons/terrain_3d/README.md new file mode 100644 index 0000000..ecf8502 --- /dev/null +++ b/godot_project/addons/terrain_3d/README.md @@ -0,0 +1,26 @@ +# Terrain3D Addon + +This directory should contain the [Terrain3D](https://github.com/TokisanGames/Terrain3D) Godot addon. + +## Setup + +Add Terrain3D as a git submodule: + +```bash +git submodule add https://github.com/TokisanGames/Terrain3D godot_project/addons/terrain_3d +git submodule update --init --recursive +``` + +Or download the latest release from: +https://github.com/TokisanGames/Terrain3D/releases + +and extract it here so that this folder contains: +``` +terrain_3d/ +โ”œโ”€โ”€ addons/ +โ”‚ โ””โ”€โ”€ terrain_3d/ +โ”‚ โ”œโ”€โ”€ plugin.cfg +โ”‚ โ””โ”€โ”€ ... +``` + +After adding the addon, enable it in Godot via **Project โ†’ Project Settings โ†’ Plugins โ†’ Terrain3D**. diff --git a/godot_project/assets/aircraft/aerobat/aerobat.json b/godot_project/assets/aircraft/aerobat/aerobat.json new file mode 100644 index 0000000..77f3042 --- /dev/null +++ b/godot_project/assets/aircraft/aerobat/aerobat.json @@ -0,0 +1,42 @@ +{ + "_comment": "3D aerobatic model with extreme control throws and high thrust-to-weight ratio.", + "name": "3D Aerobat", + "id": "aerobat", + "jsbsim_xml": "res://assets/aircraft/aerobat/aerobat_fdm.xml", + + "mass_kg": 0.9, + "wingspan_m": 1.0, + "wing_area_m2": 0.18, + "aspect_ratio": 5.6, + "oswald": 0.75, + + "cl0": 0.20, + "cl_alpha": 4.8, + "cd0": 0.045, + + "max_thrust_n": 20.0, + "max_rpm": 12000, + + "max_roll_rate_dps": 720.0, + "max_pitch_rate_dps": 360.0, + "max_yaw_rate_dps": 180.0, + + "aileron_rate": 1.0, + "elevator_rate": 1.0, + "rudder_rate": 1.0, + "expo": 0.35, + + "stall_speed_ms": 4.5, + "cruise_speed_ms": 12.0, + "max_speed_ms": 28.0, + + "engine_type": "electric_brushless", + "battery_cells": 4, + "motor_kv": 1200, + + "sounds": { + "motor": "res://assets/audio/motor_electric_high.ogg" + }, + + "model_scene": "res://scenes/aircraft/aerobat.tscn" +} diff --git a/godot_project/assets/aircraft/jet/jet.json b/godot_project/assets/aircraft/jet/jet.json new file mode 100644 index 0000000..546dda6 --- /dev/null +++ b/godot_project/assets/aircraft/jet/jet.json @@ -0,0 +1,41 @@ +{ + "_comment": "Scale turbine jet with realistic swept-wing aerodynamics and EDF propulsion.", + "name": "Scale Turbine Jet", + "id": "jet", + "jsbsim_xml": "res://assets/aircraft/jet/jet_fdm.xml", + + "mass_kg": 2.8, + "wingspan_m": 1.2, + "wing_area_m2": 0.22, + "aspect_ratio": 6.5, + "oswald": 0.78, + + "cl0": 0.15, + "cl_alpha": 3.8, + "cd0": 0.022, + + "max_thrust_n": 45.0, + "max_rpm": 80000, + + "max_roll_rate_dps": 360.0, + "max_pitch_rate_dps": 180.0, + "max_yaw_rate_dps": 90.0, + + "aileron_rate": 0.85, + "elevator_rate": 0.70, + "rudder_rate": 0.55, + "expo": 0.40, + + "stall_speed_ms": 14.0, + "cruise_speed_ms": 40.0, + "max_speed_ms": 70.0, + + "engine_type": "edf_turbine", + "fan_diameter_mm": 70, + + "sounds": { + "motor": "res://assets/audio/edf_jet.ogg" + }, + + "model_scene": "res://scenes/aircraft/jet.tscn" +} diff --git a/godot_project/assets/aircraft/trainer/trainer.json b/godot_project/assets/aircraft/trainer/trainer.json new file mode 100644 index 0000000..533efa5 --- /dev/null +++ b/godot_project/assets/aircraft/trainer/trainer.json @@ -0,0 +1,42 @@ +{ + "_comment": "High-wing electric trainer โ€“ beginner-friendly with forgiving flight characteristics.", + "name": "Electric Trainer", + "id": "trainer", + "jsbsim_xml": "res://assets/aircraft/trainer/trainer_fdm.xml", + + "mass_kg": 1.5, + "wingspan_m": 1.4, + "wing_area_m2": 0.27, + "aspect_ratio": 7.3, + "oswald": 0.82, + + "cl0": 0.35, + "cl_alpha": 5.1, + "cd0": 0.032, + + "max_thrust_n": 18.0, + "max_rpm": 9500, + + "max_roll_rate_dps": 150.0, + "max_pitch_rate_dps": 70.0, + "max_yaw_rate_dps": 45.0, + + "aileron_rate": 0.8, + "elevator_rate": 0.75, + "rudder_rate": 0.6, + "expo": 0.25, + + "stall_speed_ms": 6.5, + "cruise_speed_ms": 14.0, + "max_speed_ms": 22.0, + + "engine_type": "electric_brushless", + "battery_cells": 3, + "motor_kv": 1000, + + "sounds": { + "motor": "res://assets/audio/motor_electric.ogg" + }, + + "model_scene": "res://scenes/aircraft/trainer.tscn" +} diff --git a/godot_project/assets/aircraft/trainer/trainer_fdm.xml b/godot_project/assets/aircraft/trainer/trainer_fdm.xml new file mode 100644 index 0000000..9eb0f67 --- /dev/null +++ b/godot_project/assets/aircraft/trainer/trainer_fdm.xml @@ -0,0 +1,380 @@ + + + + + + + 0.27 + 1.40 + 2.0 + 0.192 + 0.060 + 0.65 + 0.035 + 0.60 + + 0.10 + 0.00 + 0.00 + + + -0.05 + 0.00 + 0.05 + + + 0.0 + 0.0 + 0.0 + + + + + + 0.025 + 0.030 + 0.048 + 0.002 + 1.20 + + 0.08 + 0.00 + -0.01 + + + + + + + + 0.28 + 0.00 + -0.12 + + 0.80 + 0.50 + 0.02 + 1200 + 180 + 30 + NONE + 0 + + + + -0.05 + -0.18 + -0.12 + + 0.80 + 0.50 + 0.02 + 1800 + 250 + 0 + LEFT + 0 + + + + -0.05 + 0.18 + -0.12 + + 0.80 + 0.50 + 0.02 + 1800 + 250 + 0 + RIGHT + 0 + + + + + + + + 0.30 + 0.00 + 0.00 + + + 0 + 0 + 0 + + 0 + + + 0.32 + 0.00 + 0.00 + + + 0 + 0 + 0 + + 1 + 0.0 + + + + + 0.08 + 0.00 + 0.00 + + 0.5 + 0.5 + 20 + + + + + + + + fcs/aileron-cmd-norm + fcs/roll-trim-cmd-norm + -1 1 + + + fcs/roll-trim-cmd-norm + + -25 + 25 + + fcs/left-aileron-pos-deg + + + + + fcs/elevator-cmd-norm + fcs/pitch-trim-cmd-norm + -1 1 + + + fcs/pitch-trim-cmd-norm + + -25 + 25 + + fcs/elevator-pos-deg + + + + + fcs/rudder-cmd-norm + fcs/yaw-trim-cmd-norm + -1 1 + + + fcs/yaw-trim-cmd-norm + + -25 + 25 + + fcs/rudder-pos-deg + + + + + fcs/throttle-cmd-norm[0] + 1.0 + fcs/throttle-pos-norm[0] + + + + + + + + + + Lift coefficient due to alpha + + aero/qbar-psf + metrics/Sw-sqft + + aero/alpha-rad + + -0.3491 -0.80 + -0.1745 -0.20 + 0.0000 0.35 + 0.1745 1.00 + 0.3491 1.40 + 0.5236 1.10 + 0.6981 0.70 + +
+ + + + Lift from elevator deflection + + aero/qbar-psf + metrics/Sw-sqft + fcs/elevator-pos-rad + 0.40 + + + + + + + Minimum drag + + aero/qbar-psf + metrics/Sw-sqft + 0.032 + + + + Induced drag + + aero/qbar-psf + metrics/Sw-sqft + + aero/cl-squared + + 0.0 0.000 + 0.5 0.028 + 1.0 0.055 + 1.5 0.095 + +
+ + + + + + + Side force from sideslip + + aero/qbar-psf + metrics/Sw-sqft + aero/beta-rad + -0.30 + + + + + + + Roll moment from ailerons + + aero/qbar-psf + metrics/Sw-sqft + metrics/bw-ft + fcs/left-aileron-pos-rad + 0.12 + + + + Roll damping + + aero/qbar-psf + metrics/Sw-sqft + metrics/bw-ft + aero/bi2vel + velocities/p-rad_sec + -0.40 + + + + + + + Pitch moment from alpha (stability) + + aero/qbar-psf + metrics/Sw-sqft + metrics/cbarw-ft + aero/alpha-rad + -0.55 + + + + Pitch moment from elevator + + aero/qbar-psf + metrics/Sw-sqft + metrics/cbarw-ft + fcs/elevator-pos-rad + -1.10 + + + + Pitch damping + + aero/qbar-psf + metrics/Sw-sqft + metrics/cbarw-ft + aero/ci2vel + velocities/q-rad_sec + -8.0 + + + + + + + Yaw moment from sideslip (weathercock stability) + + aero/qbar-psf + metrics/Sw-sqft + metrics/bw-ft + aero/beta-rad + 0.08 + + + + Yaw moment from rudder + + aero/qbar-psf + metrics/Sw-sqft + metrics/bw-ft + fcs/rudder-pos-rad + -0.06 + + + + Yaw damping + + aero/qbar-psf + metrics/Sw-sqft + metrics/bw-ft + aero/bi2vel + velocities/r-rad_sec + -0.10 + + + + + + + diff --git a/godot_project/assets/sceneries/default_airfield/.keep b/godot_project/assets/sceneries/default_airfield/.keep new file mode 100644 index 0000000..e69de29 diff --git a/godot_project/assets/sceneries/default_airfield/scenario.json b/godot_project/assets/sceneries/default_airfield/scenario.json new file mode 100644 index 0000000..9ca6c5c --- /dev/null +++ b/godot_project/assets/sceneries/default_airfield/scenario.json @@ -0,0 +1,14 @@ +{ + "name": "Default Airfield โ€“ Calm Morning", + "description": "A flat grass airfield on a calm, clear morning. Good conditions for beginners.", + "wind_direction_deg": 270, + "wind_speed_ms": 2.0, + "wind_gust_max_ms": 4.0, + "wind_turbulence": 0.1, + "temperature_c": 18.0, + "pressure_hpa": 1013.25, + "start_time_h": 9.0, + "time_scale": 1.0, + "spawn_position": [0.0, 0.1, 0.0], + "spawn_heading_deg": 270 +} diff --git a/godot_project/assets/ui/fonts/.keep b/godot_project/assets/ui/fonts/.keep new file mode 100644 index 0000000..e69de29 diff --git a/godot_project/assets/ui/icons/.keep b/godot_project/assets/ui/icons/.keep new file mode 100644 index 0000000..e69de29 diff --git a/godot_project/assets/ui/themes/.keep b/godot_project/assets/ui/themes/.keep new file mode 100644 index 0000000..e69de29 diff --git a/godot_project/project.godot b/godot_project/project.godot new file mode 100644 index 0000000..f477e33 --- /dev/null +++ b/godot_project/project.godot @@ -0,0 +1,119 @@ +; Engine configuration file. +; It's best edited using the editor UI and not directly, +; but you can edit this file directly if you wish. + +config_version=5 + +[application] + +config/name="RC-Flight-Sim" +config/description="Free, open-source, community-driven RC flight simulator." +config/version="0.1.0" +config/tags=["simulator", "rc", "flight", "godot4"] +run/main_scene="res://scenes/main.tscn" +config/features=PackedStringArray("4.2", "GL Compatibility") +config/icon="res://assets/ui/icons/icon.svg" + +[autoload] + +InputManager="*res://scripts/autoload/input_manager.gd" +SettingsManager="*res://scripts/autoload/settings_manager.gd" +SceneManager="*res://scripts/autoload/scene_manager.gd" +Atmosphere="*res://scripts/flight_sim/atmosphere.gd" + +[display] + +window/size/viewport_width=1280 +window/size/viewport_height=720 +window/size/resizable=true +window/stretch/mode="canvas_items" + +[input] + +rc_aileron={ +"deadzone": 0.05, +"events": [Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":0,"axis_value":1.0,"script":null) +] +} +rc_elevator={ +"deadzone": 0.05, +"events": [Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":1,"axis_value":1.0,"script":null) +] +} +rc_throttle={ +"deadzone": 0.05, +"events": [Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":2,"axis_value":1.0,"script":null) +] +} +rc_rudder={ +"deadzone": 0.05, +"events": [Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":3,"axis_value":1.0,"script":null) +] +} +camera_cycle={ +"deadzone": 0.5, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194310,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +] +} +camera_fpv={ +"deadzone": 0.5, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194306,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +] +} +camera_chase={ +"deadzone": 0.5, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194307,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +] +} +camera_stationary={ +"deadzone": 0.5, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194308,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +] +} +camera_tower={ +"deadzone": 0.5, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194309,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +] +} +camera_orbit={ +"deadzone": 0.5, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194310,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +] +} +ui_menu={ +"deadzone": 0.5, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194305,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +] +} +rc_aux1={ +"deadzone": 0.05, +"events": [Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":4,"axis_value":1.0,"script":null) +] +} +rc_aux2={ +"deadzone": 0.05, +"events": [Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":5,"axis_value":1.0,"script":null) +] +} + +[physics] + +common/physics_ticks_per_second=60 +common/max_physics_steps_per_frame=8 + +[rendering] + +renderer/rendering_method="gl_compatibility" +renderer/rendering_method.mobile="gl_compatibility" +textures/vram_compression/import_etc2_astc=true +anti_aliasing/quality/msaa_3d=0 +shadows/positional_shadow/size=1024 +environment/defaults/default_clear_color=Color(0.3, 0.5, 0.8, 1) +lights_and_shadows/directional_shadow/size=2048 + +[layer_names] + +3d_physics/layer_1="aircraft" +3d_physics/layer_2="terrain" +3d_physics/layer_3="obstacles" +3d_physics/layer_4="triggers" diff --git a/godot_project/scenes/aircraft/.keep b/godot_project/scenes/aircraft/.keep new file mode 100644 index 0000000..e69de29 diff --git a/godot_project/scenes/main.tscn b/godot_project/scenes/main.tscn new file mode 100644 index 0000000..4f66caf --- /dev/null +++ b/godot_project/scenes/main.tscn @@ -0,0 +1,61 @@ +[gd_scene load_steps=6 format=3 uid="uid://main_scene"] + +[ext_resource type="Script" path="res://scripts/flight_sim/aircraft_node.gd" id="1_aircraft_node"] +[ext_resource type="Script" path="res://scripts/camera/camera_manager.gd" id="2_camera_manager"] +[ext_resource type="Script" path="res://scripts/camera/chase_camera.gd" id="3_chase_cam"] +[ext_resource type="Script" path="res://scripts/camera/fpv_camera.gd" id="4_fpv_cam"] +[ext_resource type="Script" path="res://scripts/camera/free_orbit_camera.gd" id="5_orbit_cam"] +[ext_resource type="Script" path="res://scripts/camera/stationary_camera.gd" id="6_stat_cam"] +[ext_resource type="Script" path="res://scripts/camera/tower_camera.gd" id="7_tower_cam"] +[ext_resource type="Script" path="res://scripts/flight_sim/fdm_interface.gd" id="8_fdm"] +[ext_resource type="Script" path="res://scripts/ui/hud.gd" id="9_hud"] + +[node name="Main" type="Node3D"] + +[node name="WorldEnvironment" type="WorldEnvironment" parent="."] +environment = SubResource("environment_1") + +[node name="DirectionalLight" type="DirectionalLight3D" parent="."] +transform = Transform3D(0.866, -0.354, 0.354, 0, 0.707, 0.707, -0.5, -0.612, 0.612, 0, 20, 0) +shadow_enabled = true +directional_shadow_mode = 2 + +[node name="Aircraft" type="Node3D" parent="." script=ExtResource("1_aircraft_node")] +aircraft_config_path = "res://assets/aircraft/trainer/trainer.json" + +[node name="FDMInterface" type="Node" parent="Aircraft" script=ExtResource("8_fdm")] + +[node name="MeshInstance3D" type="MeshInstance3D" parent="Aircraft"] +mesh = SubResource("box_mesh_1") + +[node name="CameraRig" type="Node3D" parent="."] + +[node name="CameraManager" type="Node" parent="CameraRig" script=ExtResource("2_camera_manager")] + +[node name="ChaseCamera" type="Camera3D" parent="CameraRig" script=ExtResource("3_chase_cam")] +current = true + +[node name="FPVCamera" type="Camera3D" parent="Aircraft" script=ExtResource("4_fpv_cam")] + +[node name="FreeOrbitCamera" type="Camera3D" parent="CameraRig" script=ExtResource("5_orbit_cam")] + +[node name="StationaryCamera" type="Camera3D" parent="CameraRig" script=ExtResource("6_stat_cam")] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 3, 30) + +[node name="TowerCamera" type="Camera3D" parent="CameraRig" script=ExtResource("7_tower_cam")] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 8, 40) + +[node name="Runway" type="CSGBox3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -0.1, 0) +size = Vector3(10, 0.2, 100) +material = SubResource("runway_mat") + +[node name="Grass" type="CSGBox3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -0.2, 0) +size = Vector3(1000, 0.2, 1000) +material = SubResource("grass_mat") + +[node name="HUD" type="CanvasLayer" parent="." script=ExtResource("9_hud")] + +[node name="MainSceneController" type="Node" parent="."] +script = ExtResource("main_scene_controller") diff --git a/godot_project/scenes/sceneries/.keep b/godot_project/scenes/sceneries/.keep new file mode 100644 index 0000000..e69de29 diff --git a/godot_project/scenes/ui/.keep b/godot_project/scenes/ui/.keep new file mode 100644 index 0000000..e69de29 diff --git a/godot_project/scripts/autoload/input_manager.gd b/godot_project/scripts/autoload/input_manager.gd new file mode 100644 index 0000000..89e9754 --- /dev/null +++ b/godot_project/scripts/autoload/input_manager.gd @@ -0,0 +1,220 @@ +## input_manager.gd +## Autoload singleton that manages all RC controller input, joystick detection, +## calibration profiles, and provides smoothed, scaled input values to the FDM. +extends Node + +# --------------------------------------------------------------------------- +# Signals +# --------------------------------------------------------------------------- +signal joystick_connected(device_id: int, name: String) +signal joystick_disconnected(device_id: int) +signal calibration_changed() + +# --------------------------------------------------------------------------- +# Constants +# --------------------------------------------------------------------------- +const PROFILE_PATH := "user://controller_profiles.cfg" +const DEFAULT_AXIS_AILERON := 0 +const DEFAULT_AXIS_ELEVATOR := 1 +const DEFAULT_AXIS_THROTTLE := 2 +const DEFAULT_AXIS_RUDDER := 3 + +# --------------------------------------------------------------------------- +# Internal state +# --------------------------------------------------------------------------- +## Processed channel values in range [-1, 1] (throttle: [0, 1]) +var channels: Dictionary = { + "aileron": 0.0, + "elevator": 0.0, + "throttle": 0.0, + "rudder": 0.0, + "aux1": 0.0, + "aux2": 0.0, +} + +## Active joystick device index (-1 = keyboard fallback) +var active_device: int = -1 + +## Per-device calibration profiles loaded from config +## Structure: { guid: { axis_map, reversed, deadzone, min, max, center } } +var _profiles: Dictionary = {} + +## Current calibration data for the active device +var _cal: Dictionary = {} + +## Config file for profiles +var _config := ConfigFile.new() + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: + _load_profiles() + _detect_joysticks() + Input.joy_connection_changed.connect(_on_joy_connection_changed) + +func _process(_delta: float) -> void: + _update_channels() + +# --------------------------------------------------------------------------- +# Joystick detection +# --------------------------------------------------------------------------- +func _detect_joysticks() -> void: + for id in Input.get_connected_joypads(): + _on_joy_connection_changed(id, true) + +func _on_joy_connection_changed(device_id: int, connected: bool) -> void: + if connected: + var joy_name := Input.get_joy_name(device_id) + var guid := Input.get_joy_guid(device_id) + print("[InputManager] Joystick connected: %s (GUID: %s, device: %d)" % [joy_name, guid, device_id]) + if active_device == -1: + active_device = device_id + _load_calibration_for_guid(guid) + joystick_connected.emit(device_id, joy_name) + else: + print("[InputManager] Joystick disconnected: device %d" % device_id) + if active_device == device_id: + active_device = -1 + _cal = _default_calibration() + # Try to activate next available joystick + var pads := Input.get_connected_joypads() + if not pads.is_empty(): + active_device = pads[0] + _load_calibration_for_guid(Input.get_joy_guid(active_device)) + joystick_disconnected.emit(device_id) + +# --------------------------------------------------------------------------- +# Channel update +# --------------------------------------------------------------------------- +func _update_channels() -> void: + if active_device >= 0: + channels["aileron"] = _read_axis("aileron") + channels["elevator"] = _read_axis("elevator") + channels["throttle"] = _read_throttle() + channels["rudder"] = _read_axis("rudder") + channels["aux1"] = _read_raw_axis(4) + channels["aux2"] = _read_raw_axis(5) + else: + # Keyboard fallback (useful for testing without hardware) + channels["aileron"] = float(int(Input.is_key_pressed(KEY_D)) - int(Input.is_key_pressed(KEY_A))) + channels["elevator"] = float(int(Input.is_key_pressed(KEY_S)) - int(Input.is_key_pressed(KEY_W))) + channels["throttle"] = clampf(channels["throttle"] + + float(int(Input.is_key_pressed(KEY_UP)) - int(Input.is_key_pressed(KEY_DOWN))) * get_process_delta_time(), + 0.0, 1.0) + channels["rudder"] = float(int(Input.is_key_pressed(KEY_E)) - int(Input.is_key_pressed(KEY_Q))) + +func _read_axis(channel: String) -> float: + var axis_idx: int = _cal.get("axis_map", {}).get(channel, _default_axis_for(channel)) + var raw := Input.get_joy_axis(active_device, axis_idx) + return _apply_calibration(channel, raw) + +func _read_throttle() -> float: + var axis_idx: int = _cal.get("axis_map", {}).get("throttle", DEFAULT_AXIS_THROTTLE) + var raw := Input.get_joy_axis(active_device, axis_idx) + var cal_val := _apply_calibration("throttle", raw) + # Throttle is typically 0-1 (from -1 to 1 raw) + return (cal_val + 1.0) * 0.5 + +func _read_raw_axis(axis_idx: int) -> float: + return Input.get_joy_axis(active_device, axis_idx) + +func _apply_calibration(channel: String, raw: float) -> float: + var deadzone: float = _cal.get("deadzone", {}).get(channel, 0.05) + var reversed: bool = _cal.get("reversed", {}).get(channel, false) + var center: float = _cal.get("center", {}).get(channel, 0.0) + var range_min: float = _cal.get("range_min", {}).get(channel, -1.0) + var range_max: float = _cal.get("range_max", {}).get(channel, 1.0) + + # Remove center offset + var v := raw - center + + # Apply deadzone + if absf(v) < deadzone: + return 0.0 + + # Normalize to [-1, 1] based on recorded range + var half_range := (range_max - range_min) * 0.5 + if half_range > 0.001: + v = v / half_range + + v = clampf(v, -1.0, 1.0) + + if reversed: + v = -v + + return v + +# --------------------------------------------------------------------------- +# Calibration helpers +# --------------------------------------------------------------------------- +func _default_axis_for(channel: String) -> int: + match channel: + "aileron": return DEFAULT_AXIS_AILERON + "elevator": return DEFAULT_AXIS_ELEVATOR + "throttle": return DEFAULT_AXIS_THROTTLE + "rudder": return DEFAULT_AXIS_RUDDER + return 0 + +func _default_calibration() -> Dictionary: + return { + "axis_map": { + "aileron": DEFAULT_AXIS_AILERON, + "elevator": DEFAULT_AXIS_ELEVATOR, + "throttle": DEFAULT_AXIS_THROTTLE, + "rudder": DEFAULT_AXIS_RUDDER, + }, + "reversed": { "aileron": false, "elevator": false, "throttle": false, "rudder": false }, + "deadzone": { "aileron": 0.05, "elevator": 0.05, "throttle": 0.05, "rudder": 0.05 }, + "center": { "aileron": 0.0, "elevator": 0.0, "throttle": 0.0, "rudder": 0.0 }, + "range_min": { "aileron": -1.0, "elevator": -1.0, "throttle": -1.0, "rudder": -1.0 }, + "range_max": { "aileron": 1.0, "elevator": 1.0, "throttle": 1.0, "rudder": 1.0 }, + } + +func _load_calibration_for_guid(guid: String) -> void: + if _profiles.has(guid): + _cal = _profiles[guid] + print("[InputManager] Loaded calibration for GUID: %s" % guid) + else: + _cal = _default_calibration() + print("[InputManager] Using default calibration for GUID: %s" % guid) + +## Save calibration for the currently active device +func save_calibration() -> void: + if active_device < 0: + return + var guid := Input.get_joy_guid(active_device) + _profiles[guid] = _cal.duplicate(true) + _store_profile_to_config(guid, _cal) + var err := _config.save(PROFILE_PATH) + if err != OK: + push_error("[InputManager] Failed to save profiles: %d" % err) + calibration_changed.emit() + +func _store_profile_to_config(guid: String, cal: Dictionary) -> void: + for key in cal: + if cal[key] is Dictionary: + for sub_key in cal[key]: + _config.set_value(guid + "_" + key, sub_key, cal[key][sub_key]) + else: + _config.set_value(guid, key, cal[key]) + +func _load_profiles() -> void: + var err := _config.load(PROFILE_PATH) + if err != OK: + return # No saved profiles yet โ€” that's fine + # Profiles are loaded on demand per GUID in _load_calibration_for_guid + +## Update a calibration parameter at runtime (used by CalibrationWizard) +func set_calibration_value(channel: String, param: String, value) -> void: + if not _cal.has(param): + _cal[param] = {} + _cal[param][channel] = value + +## Expose raw joystick axis value for calibration UI +func get_raw_axis(device_id: int, axis: int) -> float: + return Input.get_joy_axis(device_id, axis) + +## Return the currently active device id +func get_active_device() -> int: + return active_device diff --git a/godot_project/scripts/autoload/scene_manager.gd b/godot_project/scripts/autoload/scene_manager.gd new file mode 100644 index 0000000..fe112b4 --- /dev/null +++ b/godot_project/scripts/autoload/scene_manager.gd @@ -0,0 +1,101 @@ +## scene_manager.gd +## Autoload singleton for scene transitions with optional loading screen support. +extends Node + +# --------------------------------------------------------------------------- +# Signals +# --------------------------------------------------------------------------- +signal scene_loading_started(scene_path: String) +signal scene_loading_finished(scene_path: String) + +# --------------------------------------------------------------------------- +# Constants +# --------------------------------------------------------------------------- +const LOADING_SCREEN_PATH := "res://scenes/ui/loading_screen.tscn" + +# --------------------------------------------------------------------------- +# Internal state +# --------------------------------------------------------------------------- +var _current_scene_path: String = "" +var _loading_screen: Node = null + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: + # Store initial scene path + var root := get_tree().root + var current := root.get_child(root.get_child_count() - 1) + _current_scene_path = current.scene_file_path + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- + +## Transition to a new scene. Optionally show a loading screen for heavy scenes. +func go_to_scene(scene_path: String, use_loading_screen: bool = false) -> void: + scene_loading_started.emit(scene_path) + if use_loading_screen: + await _show_loading_screen() + await _load_scene_async(scene_path) + else: + _load_scene_immediate(scene_path) + +## Reload the current scene +func reload_scene() -> void: + go_to_scene(_current_scene_path) + +## Return to main menu +func go_to_main_menu() -> void: + go_to_scene("res://scenes/ui/main_menu.tscn") + +## Go to a flight scene with a given aircraft and scenery +func start_flight(aircraft: String, scenery: String) -> void: + SettingsManager.set_setting("aircraft", aircraft) + SettingsManager.set_setting("scenery", scenery) + go_to_scene("res://scenes/main.tscn", true) + +# --------------------------------------------------------------------------- +# Internal helpers +# --------------------------------------------------------------------------- +func _load_scene_immediate(scene_path: String) -> void: + var err := get_tree().change_scene_to_file(scene_path) + if err != OK: + push_error("[SceneManager] Failed to load scene: %s (err %d)" % [scene_path, err]) + return + _current_scene_path = scene_path + scene_loading_finished.emit(scene_path) + +func _show_loading_screen() -> void: + # Show loading overlay if available + if ResourceLoader.exists(LOADING_SCREEN_PATH): + var screen_scene := load(LOADING_SCREEN_PATH) as PackedScene + if screen_scene: + _loading_screen = screen_scene.instantiate() + get_tree().root.add_child(_loading_screen) + await get_tree().process_frame + +func _load_scene_async(scene_path: String) -> void: + ResourceLoader.load_threaded_request(scene_path) + while true: + var status := ResourceLoader.load_threaded_get_status(scene_path) + if status == ResourceLoader.THREAD_LOAD_LOADED: + break + elif status == ResourceLoader.THREAD_LOAD_FAILED: + push_error("[SceneManager] Async load failed: %s" % scene_path) + _hide_loading_screen() + return + await get_tree().process_frame + + var packed_scene := ResourceLoader.load_threaded_get(scene_path) as PackedScene + _hide_loading_screen() + + if packed_scene: + get_tree().change_scene_to_packed(packed_scene) + _current_scene_path = scene_path + scene_loading_finished.emit(scene_path) + +func _hide_loading_screen() -> void: + if _loading_screen and is_instance_valid(_loading_screen): + _loading_screen.queue_free() + _loading_screen = null diff --git a/godot_project/scripts/autoload/settings_manager.gd b/godot_project/scripts/autoload/settings_manager.gd new file mode 100644 index 0000000..d8fd8fb --- /dev/null +++ b/godot_project/scripts/autoload/settings_manager.gd @@ -0,0 +1,131 @@ +## settings_manager.gd +## Autoload singleton that persists user preferences and adjusts graphics quality presets. +extends Node + +# --------------------------------------------------------------------------- +# Signals +# --------------------------------------------------------------------------- +signal settings_changed(key: String, value: Variant) +signal preset_changed(preset: String) + +# --------------------------------------------------------------------------- +# Constants +# --------------------------------------------------------------------------- +const SETTINGS_PATH := "user://settings.cfg" + +const PRESET_LOW := "Low" +const PRESET_MEDIUM := "Medium" +const PRESET_HIGH := "High" +const PRESET_ULTRA := "Ultra" + +# Shadow size map +const SHADOW_SIZES := { + PRESET_LOW: 512, + PRESET_MEDIUM: 1024, + PRESET_HIGH: 2048, + PRESET_ULTRA: 4096, +} + +# MSAA map (RenderingServer values) +const MSAA_VALUES := { + PRESET_LOW: 0, # Disabled + PRESET_MEDIUM: 2, # 2x + PRESET_HIGH: 4, # 4x + PRESET_ULTRA: 8, # 8x +} + +# --------------------------------------------------------------------------- +# Default settings +# --------------------------------------------------------------------------- +var _defaults: Dictionary = { + "graphics_preset": PRESET_MEDIUM, + "fullscreen": false, + "vsync": true, + "draw_distance": 1000.0, + "grass_density": 0.5, + "post_processing": true, + "audio_master_vol": 1.0, + "audio_sfx_vol": 1.0, + "audio_music_vol": 0.5, + "aircraft": "trainer", + "scenery": "default_airfield", + "camera_mode": "chase", + "show_hud": true, + "language": "en", +} + +var _settings: Dictionary = {} +var _config := ConfigFile.new() + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: + _settings = _defaults.duplicate() + _load() + _apply_all() + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- +func get_setting(key: String, default_val: Variant = null) -> Variant: + if _settings.has(key): + return _settings[key] + if _defaults.has(key): + return _defaults[key] + return default_val + +func set_setting(key: String, value: Variant) -> void: + _settings[key] = value + settings_changed.emit(key, value) + +func save() -> void: + for key in _settings: + _config.set_value("settings", key, _settings[key]) + var err := _config.save(SETTINGS_PATH) + if err != OK: + push_error("[SettingsManager] Failed to save settings: %d" % err) + +func apply_graphics_preset(preset: String) -> void: + set_setting("graphics_preset", preset) + + # Shadow quality + var shadow_size: int = SHADOW_SIZES.get(preset, 1024) + RenderingServer.directional_shadow_atlas_set_size(shadow_size, true) + + # MSAA + var msaa: int = MSAA_VALUES.get(preset, 0) + get_viewport().msaa_3d = msaa + + # Post-processing toggle + var post_proc: bool = preset in [PRESET_HIGH, PRESET_ULTRA] + set_setting("post_processing", post_proc) + + preset_changed.emit(preset) + +# --------------------------------------------------------------------------- +# Internal helpers +# --------------------------------------------------------------------------- +func _load() -> void: + var err := _config.load(SETTINGS_PATH) + if err != OK: + return # First run, use defaults + for key in _defaults: + if _config.has_section_key("settings", key): + _settings[key] = _config.get_value("settings", key) + +func _apply_all() -> void: + # Fullscreen + if _settings.get("fullscreen", false): + DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN) + # VSync + DisplayServer.window_set_vsync_mode( + DisplayServer.VSYNC_ENABLED if _settings.get("vsync", true) else DisplayServer.VSYNC_DISABLED + ) + # Audio volumes + var master_bus := AudioServer.get_bus_index("Master") + if master_bus >= 0: + AudioServer.set_bus_volume_db(master_bus, + linear_to_db(_settings.get("audio_master_vol", 1.0))) + # Graphics preset + apply_graphics_preset(_settings.get("graphics_preset", PRESET_MEDIUM)) diff --git a/godot_project/scripts/camera/camera_manager.gd b/godot_project/scripts/camera/camera_manager.gd new file mode 100644 index 0000000..adabd44 --- /dev/null +++ b/godot_project/scripts/camera/camera_manager.gd @@ -0,0 +1,98 @@ +## camera_manager.gd +## Manages switching between all five camera modes via hotkeys F1-F5. +## Attach to the scene root. All camera child nodes must be registered. +class_name CameraManager +extends Node + +# --------------------------------------------------------------------------- +# Signals +# --------------------------------------------------------------------------- +signal camera_mode_changed(mode: String) + +# --------------------------------------------------------------------------- +# Camera mode enum +# --------------------------------------------------------------------------- +enum CameraMode { FPV, CHASE, STATIONARY, TOWER, FREE_ORBIT } + +# --------------------------------------------------------------------------- +# Exported node references (drag-and-drop in editor) +# --------------------------------------------------------------------------- +@export var fpv_camera: Camera3D = null +@export var chase_camera: Camera3D = null +@export var stationary_camera: Camera3D = null +@export var tower_camera: Camera3D = null +@export var free_orbit_camera: Camera3D = null + +# --------------------------------------------------------------------------- +# State +# --------------------------------------------------------------------------- +var current_mode: CameraMode = CameraMode.CHASE + +var _cameras: Dictionary = {} + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: + _cameras[CameraMode.FPV] = fpv_camera + _cameras[CameraMode.CHASE] = chase_camera + _cameras[CameraMode.STATIONARY] = stationary_camera + _cameras[CameraMode.TOWER] = tower_camera + _cameras[CameraMode.FREE_ORBIT] = free_orbit_camera + + # Apply saved preference + var saved := SettingsManager.get_setting("camera_mode", "chase") + match saved: + "fpv": set_camera(CameraMode.FPV) + "stationary": set_camera(CameraMode.STATIONARY) + "tower": set_camera(CameraMode.TOWER) + "orbit": set_camera(CameraMode.FREE_ORBIT) + _: set_camera(CameraMode.CHASE) + +func _input(event: InputEvent) -> void: + if event.is_action_pressed("camera_fpv"): + set_camera(CameraMode.FPV) + elif event.is_action_pressed("camera_chase"): + set_camera(CameraMode.CHASE) + elif event.is_action_pressed("camera_stationary"): + set_camera(CameraMode.STATIONARY) + elif event.is_action_pressed("camera_tower"): + set_camera(CameraMode.TOWER) + elif event.is_action_pressed("camera_orbit"): + set_camera(CameraMode.FREE_ORBIT) + elif event.is_action_pressed("camera_cycle"): + _cycle_camera() + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- +func set_camera(mode: CameraMode) -> void: + current_mode = mode + for m in _cameras: + var cam := _cameras[m] as Camera3D + if cam != null: + cam.current = (m == mode) + + var mode_name := _mode_to_string(mode) + SettingsManager.set_setting("camera_mode", mode_name) + camera_mode_changed.emit(mode_name) + print("[CameraManager] Active camera: %s" % mode_name) + +func get_active_camera() -> Camera3D: + return _cameras.get(current_mode) as Camera3D + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- +func _cycle_camera() -> void: + var next := (current_mode + 1) % (CameraMode.FREE_ORBIT + 1) + set_camera(next as CameraMode) + +func _mode_to_string(mode: CameraMode) -> String: + match mode: + CameraMode.FPV: return "fpv" + CameraMode.CHASE: return "chase" + CameraMode.STATIONARY: return "stationary" + CameraMode.TOWER: return "tower" + CameraMode.FREE_ORBIT: return "orbit" + return "chase" diff --git a/godot_project/scripts/camera/chase_camera.gd b/godot_project/scripts/camera/chase_camera.gd new file mode 100644 index 0000000..ea365b0 --- /dev/null +++ b/godot_project/scripts/camera/chase_camera.gd @@ -0,0 +1,41 @@ +## chase_camera.gd +## Third-person spring-arm chase camera. Smoothly follows the aircraft from +## behind and above, with configurable arm length and damping. +class_name ChaseCamera +extends Camera3D + +@export var arm_length: float = 5.0 ## metres +@export var height_offset: float = 1.5 ## metres above aircraft +@export var follow_speed: float = 5.0 ## positional follow speed +@export var rotation_speed: float = 3.0 ## rotational lag speed +@export var terrain_margin: float = 0.5 ## min height above terrain + +## Reference to the aircraft node (set by main scene) +var target: Node3D = null + +var _desired_pos: Vector3 = Vector3.ZERO +var _desired_basis: Basis = Basis.IDENTITY + +func _ready() -> void: + set_as_top_level(true) # Camera moves independently of parent in world space + +func _process(delta: float) -> void: + if target == null: + return + + var aircraft_pos := target.global_position + var aircraft_fwd := -target.global_transform.basis.z # forward + + # Desired camera position: behind and above aircraft + var back_dir := -aircraft_fwd + _desired_pos = aircraft_pos + back_dir * arm_length + Vector3.UP * height_offset + + # Simple terrain avoidance: clamp to terrain_margin above y=0 (ground plane) + _desired_pos.y = maxf(_desired_pos.y, terrain_margin) + + # Smooth positional follow + global_position = global_position.lerp(_desired_pos, clampf(follow_speed * delta, 0.0, 1.0)) + + # Look at aircraft + var look_target := aircraft_pos + Vector3.UP * 0.3 + look_at(look_target, Vector3.UP) diff --git a/godot_project/scripts/camera/fpv_camera.gd b/godot_project/scripts/camera/fpv_camera.gd new file mode 100644 index 0000000..c80b738 --- /dev/null +++ b/godot_project/scripts/camera/fpv_camera.gd @@ -0,0 +1,17 @@ +## fpv_camera.gd +## First-Person-View camera. Parented directly to the aircraft node and +## placed at the cockpit eye point. Follows the aircraft orientation exactly. +class_name FPVCamera +extends Camera3D + +## Offset from the aircraft pivot to the FPV eye point (metres) +@export var eye_offset: Vector3 = Vector3(0.0, 0.05, -0.1) + +func _ready() -> void: + position = eye_offset + # The camera inherits orientation from parent (AircraftNode), so nothing + # extra needed โ€“ just ensure it is correctly positioned. + +func _process(_delta: float) -> void: + # Optionally add a tiny stabilisation lag for head-tracking effect + pass diff --git a/godot_project/scripts/camera/free_orbit_camera.gd b/godot_project/scripts/camera/free_orbit_camera.gd new file mode 100644 index 0000000..84d1662 --- /dev/null +++ b/godot_project/scripts/camera/free_orbit_camera.gd @@ -0,0 +1,51 @@ +## free_orbit_camera.gd +## Free-orbit camera: RMB drag to orbit, scroll wheel to zoom, always +## orbiting around the current aircraft target. +class_name FreeOrbitCamera +extends Camera3D + +@export var orbit_speed: float = 0.4 ## degrees per pixel of mouse movement +@export var zoom_speed: float = 2.0 ## metres per scroll tick +@export var min_distance: float = 1.0 +@export var max_distance: float = 100.0 +@export var default_distance: float = 10.0 + +var target: Node3D = null + +var _yaw: float = 0.0 ## degrees +var _pitch: float = 20.0 ## degrees +var _dist: float = 10.0 + +var _is_orbiting: bool = false + +func _ready() -> void: + set_as_top_level(true) + _dist = default_distance + +func _input(event: InputEvent) -> void: + if event is InputEventMouseButton: + var mb := event as InputEventMouseButton + if mb.button_index == MOUSE_BUTTON_RIGHT: + _is_orbiting = mb.pressed + elif mb.button_index == MOUSE_BUTTON_WHEEL_UP and mb.pressed: + _dist = clampf(_dist - zoom_speed, min_distance, max_distance) + elif mb.button_index == MOUSE_BUTTON_WHEEL_DOWN and mb.pressed: + _dist = clampf(_dist + zoom_speed, min_distance, max_distance) + + elif event is InputEventMouseMotion and _is_orbiting: + var mm := event as InputEventMouseMotion + _yaw -= mm.relative.x * orbit_speed + _pitch -= mm.relative.y * orbit_speed + _pitch = clampf(_pitch, -89.0, 89.0) + +func _process(_delta: float) -> void: + if target == null: + return + var center := target.global_position + var offset := Vector3( + _dist * cos(deg_to_rad(_pitch)) * sin(deg_to_rad(_yaw)), + _dist * sin(deg_to_rad(_pitch)), + _dist * cos(deg_to_rad(_pitch)) * cos(deg_to_rad(_yaw)) + ) + global_position = center + offset + look_at(center, Vector3.UP) diff --git a/godot_project/scripts/camera/stationary_camera.gd b/godot_project/scripts/camera/stationary_camera.gd new file mode 100644 index 0000000..d760fee --- /dev/null +++ b/godot_project/scripts/camera/stationary_camera.gd @@ -0,0 +1,21 @@ +## stationary_camera.gd +## Fixed-position pilot-box camera. Always looks at the aircraft with smooth +## tracking. Position is set in the editor or via the camera_manager. +class_name StationaryCamera +extends Camera3D + +@export var track_speed: float = 4.0 ## How fast the camera rotates to follow + +var target: Node3D = null + +func _ready() -> void: + set_as_top_level(true) + +func _process(delta: float) -> void: + if target == null: + return + # Smoothly look towards the aircraft + var look_pos := target.global_position + var current_basis := global_transform.basis + var desired_transform := global_transform.looking_at(look_pos, Vector3.UP) + global_transform.basis = current_basis.slerp(desired_transform.basis, clampf(track_speed * delta, 0.0, 1.0)) diff --git a/godot_project/scripts/camera/tower_camera.gd b/godot_project/scripts/camera/tower_camera.gd new file mode 100644 index 0000000..9764b2c --- /dev/null +++ b/godot_project/scripts/camera/tower_camera.gd @@ -0,0 +1,48 @@ +## tower_camera.gd +## Blends between predefined tower positions based on aircraft distance/bearing. +class_name TowerCamera +extends Camera3D + +## Tower positions (world coordinates) โ€“ set in editor via exported array +@export var tower_positions: Array[Vector3] = [] +@export var blend_speed: float = 2.0 +@export var track_speed: float = 5.0 + +var target: Node3D = null + +var _active_tower_idx: int = 0 + +func _ready() -> void: + set_as_top_level(true) + if tower_positions.is_empty(): + # Default: single tower at origin offset + tower_positions.append(Vector3(0.0, 5.0, 30.0)) + +func _process(delta: float) -> void: + if target == null: + return + + var aircraft_pos := target.global_position + _select_best_tower(aircraft_pos) + + var desired_pos: Vector3 = tower_positions[_active_tower_idx] + global_position = global_position.lerp(desired_pos, clampf(blend_speed * delta, 0.0, 1.0)) + + var current_basis := global_transform.basis + var desired_transform := global_transform.looking_at(aircraft_pos, Vector3.UP) + global_transform.basis = current_basis.slerp(desired_transform.basis, clampf(track_speed * delta, 0.0, 1.0)) + +func _select_best_tower(aircraft_pos: Vector3) -> void: + if tower_positions.size() <= 1: + _active_tower_idx = 0 + return + # Pick the tower with the best view angle (roughly closest + facing) + var best_idx := 0 + var best_score := -INF + for i in tower_positions.size(): + var dist := tower_positions[i].distance_to(aircraft_pos) + var score := -dist # simple: prefer closest + if score > best_score: + best_score = score + best_idx = i + _active_tower_idx = best_idx diff --git a/godot_project/scripts/controller/calibration_wizard.gd b/godot_project/scripts/controller/calibration_wizard.gd new file mode 100644 index 0000000..2c63866 --- /dev/null +++ b/godot_project/scripts/controller/calibration_wizard.gd @@ -0,0 +1,192 @@ +## calibration_wizard.gd +## Step-by-step controller calibration wizard. +## Guides the user through: detect sticks โ†’ move to endpoints โ†’ set center +## โ†’ reverse axes โ†’ configure deadzones โ†’ save. +class_name CalibrationWizard +extends Control + +# --------------------------------------------------------------------------- +# Signals +# --------------------------------------------------------------------------- +signal calibration_complete() +signal calibration_cancelled() + +# --------------------------------------------------------------------------- +# Wizard steps +# --------------------------------------------------------------------------- +enum Step { + WELCOME, + DETECT_DEVICE, + MOVE_AILERON, + MOVE_ELEVATOR, + MOVE_THROTTLE, + MOVE_RUDDER, + SET_CENTER, + REVERSE_AXES, + SET_DEADZONE, + CONFIRM, +} + +var _step: Step = Step.WELCOME + +# Channel currently being calibrated +const CHANNELS := ["aileron", "elevator", "throttle", "rudder"] +var _current_channel_idx: int = 0 + +# Recorded min/max/center for each channel +var _recorded: Dictionary = {} + +# Temporary working calibration +var _working_cal: Dictionary = {} + +# --------------------------------------------------------------------------- +# UI node references (configure in editor or set programmatically) +# --------------------------------------------------------------------------- +@onready var _label_title: Label = $VBox/Title +@onready var _label_instruction: Label = $VBox/Instruction +@onready var _progress_bar: ProgressBar = $VBox/Progress +@onready var _axis_readout: Label = $VBox/AxisReadout +@onready var _btn_next: Button = $VBox/Buttons/BtnNext +@onready var _btn_cancel: Button = $VBox/Buttons/BtnCancel +@onready var _reverse_check: CheckBox = $VBox/ReverseCheck +@onready var _deadzone_slider: HSlider = $VBox/DeadzoneSlider + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: + _btn_next.pressed.connect(_on_next_pressed) + _btn_cancel.pressed.connect(_on_cancel_pressed) + _init_working_cal() + _show_step(_step) + +func _process(_delta: float) -> void: + _update_readout() + +# --------------------------------------------------------------------------- +# Wizard navigation +# --------------------------------------------------------------------------- +func _on_next_pressed() -> void: + _commit_current_step() + _advance_step() + +func _on_cancel_pressed() -> void: + calibration_cancelled.emit() + queue_free() + +func _advance_step() -> void: + _step = (_step + 1) as Step + if _step > Step.CONFIRM: + _finish() + return + _show_step(_step) + +func _show_step(step: Step) -> void: + _reverse_check.visible = false + _deadzone_slider.visible = false + _progress_bar.value = (float(step) / float(Step.CONFIRM)) * 100.0 + + match step: + Step.WELCOME: + _label_title.text = "Controller Calibration Wizard" + _label_instruction.text = "This wizard will calibrate your RC controller.\nMake sure your transmitter or dongle is connected." + Step.DETECT_DEVICE: + var dev_id := InputManager.get_active_device() + if dev_id >= 0: + _label_title.text = "Device Detected" + _label_instruction.text = "Found: %s\nPress Next to continue." % Input.get_joy_name(dev_id) + else: + _label_title.text = "No Device Found" + _label_instruction.text = "No joystick detected. Connect your controller and press Next." + Step.MOVE_AILERON, Step.MOVE_ELEVATOR, Step.MOVE_THROTTLE, Step.MOVE_RUDDER: + var ch := _get_channel_for_step(step) + _label_title.text = "Move %s to full extent" % ch.capitalize() + _label_instruction.text = "Move the %s stick/channel from MIN to MAX and back several times.\nPress Next when done." % ch + Step.SET_CENTER: + _label_title.text = "Centre All Sticks" + _label_instruction.text = "Release all sticks to their natural centre position.\nPress Next to record centre." + Step.REVERSE_AXES: + _label_title.text = "Reverse Axes" + _label_instruction.text = "Check the box if the channel moves in the wrong direction." + _reverse_check.visible = true + _reverse_check.text = "Reverse %s" % CHANNELS[_current_channel_idx].capitalize() + Step.SET_DEADZONE: + _label_title.text = "Set Deadzone" + _label_instruction.text = "Adjust the deadzone slider for %s." % CHANNELS[_current_channel_idx].capitalize() + _deadzone_slider.visible = true + _deadzone_slider.min_value = 0.01 + _deadzone_slider.max_value = 0.3 + _deadzone_slider.step = 0.01 + _deadzone_slider.value = _working_cal.get("deadzone", {}).get(CHANNELS[_current_channel_idx], 0.05) + Step.CONFIRM: + _label_title.text = "Calibration Complete" + _label_instruction.text = "Calibration data has been recorded.\nPress Next to save and close." + +func _commit_current_step() -> void: + var dev_id := InputManager.get_active_device() + if dev_id < 0: + return + + match _step: + Step.MOVE_AILERON, Step.MOVE_ELEVATOR, Step.MOVE_THROTTLE, Step.MOVE_RUDDER: + # The readout has been continuously updating; just save recorded values + var ch := _get_channel_for_step(_step) + var axis_idx: int = _working_cal.get("axis_map", {}).get(ch, 0) + _working_cal.get_or_add("range_min", {})[ch] = _recorded.get(ch + "_min", -1.0) + _working_cal.get_or_add("range_max", {})[ch] = _recorded.get(ch + "_max", 1.0) + Step.SET_CENTER: + for ch in CHANNELS: + var axis_idx: int = _working_cal.get("axis_map", {}).get(ch, 0) + _working_cal.get_or_add("center", {})[ch] = InputManager.get_raw_axis(dev_id, axis_idx) + Step.REVERSE_AXES: + var ch := CHANNELS[_current_channel_idx] + _working_cal.get_or_add("reversed", {})[ch] = _reverse_check.button_pressed + Step.SET_DEADZONE: + var ch := CHANNELS[_current_channel_idx] + _working_cal.get_or_add("deadzone", {})[ch] = _deadzone_slider.value + +func _update_readout() -> void: + var dev_id := InputManager.get_active_device() + if dev_id < 0: + _axis_readout.text = "No device" + return + var text := "" + for i in range(6): + var v := InputManager.get_raw_axis(dev_id, i) + text += "Axis %d: %+.3f\n" % [i, v] + # Track min/max per channel for endpoint recording + var ch_name := _axis_to_channel_name(i) + if ch_name != "": + _recorded[ch_name + "_min"] = minf(_recorded.get(ch_name + "_min", INF), v) + _recorded[ch_name + "_max"] = maxf(_recorded.get(ch_name + "_max", -INF), v) + _axis_readout.text = text + +func _get_channel_for_step(step: Step) -> String: + match step: + Step.MOVE_AILERON: return "aileron" + Step.MOVE_ELEVATOR: return "elevator" + Step.MOVE_THROTTLE: return "throttle" + Step.MOVE_RUDDER: return "rudder" + return "" + +func _axis_to_channel_name(axis: int) -> String: + match axis: + 0: return "aileron" + 1: return "elevator" + 2: return "throttle" + 3: return "rudder" + return "" + +func _init_working_cal() -> void: + _working_cal = InputManager._cal.duplicate(true) if InputManager._cal else {} + for ch in CHANNELS: + _recorded[ch + "_min"] = INF + _recorded[ch + "_max"] = -INF + +func _finish() -> void: + # Push working calibration back to InputManager and save + for key in _working_cal: + InputManager._cal[key] = _working_cal[key] + InputManager.save_calibration() + calibration_complete.emit() + queue_free() diff --git a/godot_project/scripts/flight_sim/aircraft_node.gd b/godot_project/scripts/flight_sim/aircraft_node.gd new file mode 100644 index 0000000..812b47a --- /dev/null +++ b/godot_project/scripts/flight_sim/aircraft_node.gd @@ -0,0 +1,79 @@ +## aircraft_node.gd +## Main aircraft node. Reads inputs from InputManager, drives the FDMInterface, +## and applies the resulting physics state to the Node3D transform. +## Attach this script to a Node3D (or RigidBody3D) that represents the aircraft. +class_name AircraftNode +extends Node3D + +# --------------------------------------------------------------------------- +# Exported properties (configure per aircraft scene) +# --------------------------------------------------------------------------- +@export var aircraft_config_path: String = "res://assets/aircraft/trainer/trainer.json" +@export var engine_audio: AudioStreamPlayer3D = null +@export var propeller_mesh: MeshInstance3D = null + +# --------------------------------------------------------------------------- +# Child node references +# --------------------------------------------------------------------------- +@onready var fdm: FDMInterface = $FDMInterface as FDMInterface + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: +if fdm == null: +push_error("[AircraftNode] FDMInterface child node not found!") +return +fdm.load_aircraft(aircraft_config_path) + +func _physics_process(delta: float) -> void: +if fdm == null: +return + +# 1. Read smoothed inputs from InputManager +var inputs := InputManager.channels + +# 2. Apply expo/dual-rates from aircraft config +var cfg := fdm.aircraft_config +var aileron_rate: float = cfg.get("aileron_rate", 1.0) +var elevator_rate: float = cfg.get("elevator_rate", 1.0) +var rudder_rate: float = cfg.get("rudder_rate", 1.0) +var expo: float = cfg.get("expo", 0.3) + +fdm.set_control_surface(FDMInterface.SURFACE_AILERON, _apply_expo(inputs["aileron"], expo) * aileron_rate) +fdm.set_control_surface(FDMInterface.SURFACE_ELEVATOR, _apply_expo(inputs["elevator"], expo) * elevator_rate) +fdm.set_control_surface(FDMInterface.SURFACE_RUDDER, _apply_expo(inputs["rudder"], expo) * rudder_rate) +fdm.set_control_surface(FDMInterface.SURFACE_THROTTLE, inputs["throttle"]) + +# 3. Step the FDM +fdm.update_fdm(delta, global_transform) + +# 4. Apply resulting state to transform +var state := fdm.get_state() +global_position = state["position"] +global_transform.basis = Basis(state["orientation"]) + +# 5. Animate propeller +if propeller_mesh != null: +var rpm: float = state.get("engine_rpm", 0.0) +propeller_mesh.rotation.z += deg_to_rad(rpm / 60.0 * 360.0 * delta) + +# 6. Drive engine audio pitch by RPM +if engine_audio != null: +var rpm: float = state.get("engine_rpm", 0.0) +var max_rpm: float = cfg.get("max_rpm", 10000.0) +engine_audio.pitch_scale = clampf(0.4 + (rpm / max_rpm) * 1.4, 0.4, 1.8) +engine_audio.volume_db = linear_to_db(clampf(rpm / max_rpm, 0.05, 1.0)) + +## Called by external systems (e.g., camera) to get current airspeed +func get_airspeed() -> float: +return fdm.state.get("airspeed_ms", 0.0) + +## Called by external systems to get altitude +func get_altitude() -> float: +return fdm.state.get("altitude_m", 0.0) + +## Apply exponential curve to a control input value. +## v: raw input [-1, 1]; e: expo factor [0, 1] (0 = linear, 1 = maximum curve) +func _apply_expo(v: float, e: float) -> float: +return v * (absf(v) * e + (1.0 - e)) diff --git a/godot_project/scripts/flight_sim/atmosphere.gd b/godot_project/scripts/flight_sim/atmosphere.gd new file mode 100644 index 0000000..9491066 --- /dev/null +++ b/godot_project/scripts/flight_sim/atmosphere.gd @@ -0,0 +1,116 @@ +## atmosphere.gd +## Autoload singleton for atmospheric conditions (wind, density, temperature). +## Reads from scenario files or global settings and exposes values to the FDM. +extends Node + +# --------------------------------------------------------------------------- +# Signals +# --------------------------------------------------------------------------- +signal atmosphere_changed() + +# --------------------------------------------------------------------------- +# Public properties โ€“ read by FDMInterface and JSBSimFDM +# --------------------------------------------------------------------------- +## Wind vector in m/s, world space (X=East, Y=Up, Z=South) +var wind_velocity: Vector3 = Vector3.ZERO + +## Wind gusts: maximum extra speed added per gust cycle +var wind_gust_max: float = 0.0 + +## Wind turbulence intensity 0-1 +var wind_turbulence: float = 0.0 + +## Air temperature in Celsius at sea level +var temperature_sea_level: float = 15.0 + +## Air pressure in hPa at sea level +var pressure_sea_level: float = 1013.25 + +## Air density at sea level (kg/mยณ) โ€“ computed from T and P +var air_density: float = 1.225 + +# --------------------------------------------------------------------------- +# Time-of-day +# --------------------------------------------------------------------------- +## Current time in hours (0-24) +var time_of_day: float = 12.0 + +## Speed of time passage (1 = real time, 0 = frozen) +var time_scale: float = 1.0 + +# --------------------------------------------------------------------------- +# Internal +# --------------------------------------------------------------------------- +var _gust_timer: float = 0.0 +var _gust_period: float = 5.0 # seconds between gust pulses +var _current_gust: float = 0.0 + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: + _compute_air_density() + +func _process(delta: float) -> void: + _update_gusts(delta) + _update_time(delta) + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- + +## Load atmosphere settings from a scenario Dictionary +func load_from_scenario(scenario: Dictionary) -> void: + var wind_dir_deg: float = scenario.get("wind_direction_deg", 0.0) + var wind_speed: float = scenario.get("wind_speed_ms", 0.0) + var wind_dir_rad := deg_to_rad(wind_dir_deg) + # Wind direction is "FROM" direction (meteorological convention) + wind_velocity = Vector3(-sin(wind_dir_rad) * wind_speed, 0.0, -cos(wind_dir_rad) * wind_speed) + wind_gust_max = scenario.get("wind_gust_max_ms", 0.0) + wind_turbulence = scenario.get("wind_turbulence", 0.0) + temperature_sea_level = scenario.get("temperature_c", 15.0) + pressure_sea_level = scenario.get("pressure_hpa", 1013.25) + time_of_day = scenario.get("start_time_h", 12.0) + time_scale = scenario.get("time_scale", 1.0) + _compute_air_density() + atmosphere_changed.emit() + +## Get effective wind at a given altitude (m above sea level) +func get_wind_at_altitude(altitude_m: float) -> Vector3: + # Simple linear wind shear model + var shear_factor := clampf(altitude_m / 300.0, 0.0, 1.5) + var base_wind := wind_velocity * shear_factor + var gust_contribution := wind_velocity.normalized() * _current_gust if wind_velocity.length() > 0.01 else Vector3.ZERO + return base_wind + gust_contribution + +## Return sun angle in degrees (0 = midnight, 90 = noon) +func get_sun_angle_degrees() -> float: + return (time_of_day / 24.0) * 360.0 - 90.0 + +# --------------------------------------------------------------------------- +# Internal helpers +# --------------------------------------------------------------------------- +func _compute_air_density() -> void: + # Standard atmosphere approximation: ฯ = P / (R * T) + var R_specific := 287.05 # J/(kgยทK) + var T_kelvin := temperature_sea_level + 273.15 + var P_pascals := pressure_sea_level * 100.0 # hPa โ†’ Pa + air_density = P_pascals / (R_specific * T_kelvin) + +func _update_gusts(delta: float) -> void: + if wind_gust_max <= 0.0: + _current_gust = 0.0 + return + _gust_timer += delta + if _gust_timer >= _gust_period: + _gust_timer = 0.0 + _gust_period = randf_range(3.0, 8.0) + _current_gust = randf_range(0.0, wind_gust_max) + else: + # Smooth gust decay + _current_gust = move_toward(_current_gust, 0.0, delta * (wind_gust_max / _gust_period)) + +func _update_time(delta: float) -> void: + time_of_day += (delta / 3600.0) * time_scale + if time_of_day >= 24.0: + time_of_day -= 24.0 diff --git a/godot_project/scripts/flight_sim/fdm_interface.gd b/godot_project/scripts/flight_sim/fdm_interface.gd new file mode 100644 index 0000000..192b932 --- /dev/null +++ b/godot_project/scripts/flight_sim/fdm_interface.gd @@ -0,0 +1,266 @@ +## fdm_interface.gd +## Common Flight Dynamics Model interface for all aircraft. +## When the JSBSim GDExtension is available it delegates to JSBSimFDM; +## otherwise it falls back to a built-in kinematic model suitable for +## simple testing without native library compilation. +extends Node + +# --------------------------------------------------------------------------- +# Signals +# --------------------------------------------------------------------------- +signal state_updated(state: Dictionary) + +# --------------------------------------------------------------------------- +# Constants +# --------------------------------------------------------------------------- +## Control surface names +const SURFACE_AILERON := "aileron" +const SURFACE_ELEVATOR := "elevator" +const SURFACE_RUDDER := "rudder" +const SURFACE_THROTTLE := "throttle" +const SURFACE_FLAP := "flap" + +# --------------------------------------------------------------------------- +# FDM backend selection +# --------------------------------------------------------------------------- +enum FDMBackend { KINEMATIC, JSBSIM } + +var backend: FDMBackend = FDMBackend.KINEMATIC +var _jsbsim_node: Node = null + +# --------------------------------------------------------------------------- +# Current flight state (published each physics frame) +# --------------------------------------------------------------------------- +var state: Dictionary = { + "position": Vector3.ZERO, # m, world-space + "velocity": Vector3.ZERO, # m/s, world-space + "angular_velocity": Vector3.ZERO, # rad/s, body-frame + "orientation": Quaternion.IDENTITY, + "euler_deg": Vector3.ZERO, # roll, pitch, yaw (degrees) + "airspeed_ms": 0.0, + "altitude_m": 0.0, + "aoa_deg": 0.0, # Angle of Attack + "engine_rpm": 0.0, + "throttle_pos": 0.0, + "on_ground": true, +} + +# --------------------------------------------------------------------------- +# Control surface commands [-1, 1] (throttle [0, 1]) +# --------------------------------------------------------------------------- +var _controls: Dictionary = { + SURFACE_AILERON: 0.0, + SURFACE_ELEVATOR: 0.0, + SURFACE_RUDDER: 0.0, + SURFACE_THROTTLE: 0.0, + SURFACE_FLAP: 0.0, +} + +# --------------------------------------------------------------------------- +# Aircraft configuration (loaded from JSON) +# --------------------------------------------------------------------------- +var aircraft_config: Dictionary = {} + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: + # Try to locate a JSBSimFDM node that may have been added by AircraftNode + _jsbsim_node = get_node_or_null("JSBSimFDM") + if _jsbsim_node != null and _jsbsim_node.has_method("load_aircraft"): + backend = FDMBackend.JSBSIM + print("[FDMInterface] Using JSBSim backend.") + else: + backend = FDMBackend.KINEMATIC + print("[FDMInterface] Using kinematic fallback backend.") + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- + +## Set a control surface value. Value range: [-1, 1] (throttle: [0, 1]). +func set_control_surface(surface: String, value: float) -> void: + _controls[surface] = value + if backend == FDMBackend.JSBSIM and _jsbsim_node != null: + var jsbsim_prop := _surface_to_jsbsim_prop(surface) + if jsbsim_prop != "": + _jsbsim_node.set_property(jsbsim_prop, value) + +## Return a copy of the current flight state dictionary. +func get_state() -> Dictionary: + return state.duplicate() + +## Load aircraft definition and initialize FDM. +func load_aircraft(config_path: String) -> void: + var f := FileAccess.open(config_path, FileAccess.READ) + if f == null: + push_error("[FDMInterface] Cannot open aircraft config: %s" % config_path) + return + var json := JSON.new() + var err := json.parse(f.get_as_text()) + f.close() + if err != OK: + push_error("[FDMInterface] JSON parse error in %s: %s" % [config_path, json.get_error_message()]) + return + aircraft_config = json.get_data() + if backend == FDMBackend.JSBSIM and _jsbsim_node != null: + var xml_path: String = aircraft_config.get("jsbsim_xml", "") + if xml_path != "": + _jsbsim_node.load_aircraft(xml_path) + +## Step the FDM by delta seconds (called from AircraftNode._physics_process). +func update_fdm(delta: float, transform: Transform3D) -> void: + if backend == FDMBackend.JSBSIM and _jsbsim_node != null: + _jsbsim_node.update(delta) + _read_jsbsim_state() + else: + _step_kinematic(delta, transform) + state_updated.emit(state) + +# --------------------------------------------------------------------------- +# JSBSim state reader +# --------------------------------------------------------------------------- +func _read_jsbsim_state() -> void: + if _jsbsim_node == null: + return + state["airspeed_ms"] = _jsbsim_node.get_property("velocities/vt-fps") * 0.3048 + state["altitude_m"] = _jsbsim_node.get_property("position/h-sl-ft") * 0.3048 + state["aoa_deg"] = rad_to_deg(_jsbsim_node.get_property("aero/alpha-rad")) + state["engine_rpm"] = _jsbsim_node.get_property("propulsion/engine/rpm") + state["throttle_pos"] = _controls[SURFACE_THROTTLE] + + # Extract body-frame forces โ†’ world position/velocity update is handled by AircraftNode + var vx := _jsbsim_node.get_property("velocities/v-east-fps") * 0.3048 + var vy := _jsbsim_node.get_property("velocities/v-up-fps") * 0.3048 + var vz := _jsbsim_node.get_property("velocities/v-north-fps") * 0.3048 + state["velocity"] = Vector3(vx, vy, -vz) # Godot Y-up, Z-forward + + var roll_deg := rad_to_deg(_jsbsim_node.get_property("attitude/roll-rad")) + var pitch_deg := rad_to_deg(_jsbsim_node.get_property("attitude/pitch-rad")) + var yaw_deg := rad_to_deg(_jsbsim_node.get_property("attitude/psi-rad")) + state["euler_deg"] = Vector3(roll_deg, pitch_deg, yaw_deg) + state["orientation"] = Quaternion.from_euler(Vector3( + deg_to_rad(roll_deg), deg_to_rad(yaw_deg), deg_to_rad(pitch_deg) + )) + +# --------------------------------------------------------------------------- +# Built-in kinematic fallback model +# --------------------------------------------------------------------------- +## Simple 6-DOF kinematic model used when JSBSim is not available. +## Based on trainer-like parameters baked from aircraft_config. +var _kin_velocity: Vector3 = Vector3.ZERO +var _kin_ang_vel: Vector3 = Vector3.ZERO +var _kin_rotation: Vector3 = Vector3.ZERO # Euler angles degrees: roll, pitch, yaw +var _kin_on_ground: bool = true + +func _step_kinematic(delta: float, transform: Transform3D) -> void: + var cfg := aircraft_config + + var mass: float = cfg.get("mass_kg", 1.5) + var wingspan: float = cfg.get("wingspan_m", 1.2) + var cl_alpha: float = cfg.get("cl_alpha", 5.0) # lift curve slope (1/rad) + var cd0: float = cfg.get("cd0", 0.03) # zero-lift drag + var max_rpm: float = cfg.get("max_rpm", 10000.0) + var thrust_n: float = cfg.get("max_thrust_n", 15.0) + + var throttle: float = _controls[SURFACE_THROTTLE] + var aileron: float = _controls[SURFACE_AILERON] + var elevator: float = _controls[SURFACE_ELEVATOR] + var rudder: float = _controls[SURFACE_RUDDER] + + # Effective airspeed + var fwd := -transform.basis.z + var wind := Atmosphere.get_wind_at_altitude(transform.origin.y) + var vel_relative := _kin_velocity - wind + var airspeed := vel_relative.length() + + # Angle of attack (angle between forward vector and velocity vector in body xz-plane) + var aoa_rad := 0.0 + if airspeed > 0.5: + var local_vel := transform.basis.inverse() * vel_relative + aoa_rad = atan2(-local_vel.y, -local_vel.z) + state["aoa_deg"] = rad_to_deg(aoa_rad) + + # Dynamic pressure + var q := 0.5 * Atmosphere.air_density * airspeed * airspeed + var wing_area: float = cfg.get("wing_area_m2", 0.25) + + # Aerodynamic forces in body frame + var cl := cl_alpha * aoa_rad + cfg.get("cl0", 0.3) + cl = clampf(cl, -1.5, 1.5) + var cd := cd0 + (cl * cl) / (PI * cfg.get("aspect_ratio", 5.8) * cfg.get("oswald", 0.8)) + var lift_n := q * wing_area * cl + var drag_n := q * wing_area * cd + + # Lift acts perpendicular to velocity in the lift plane; drag opposes velocity + var lift_dir := transform.basis.y # approximation: vertical in body frame + var drag_dir := -fwd if airspeed < 0.1 else -vel_relative.normalized() + + var aero_force := lift_dir * lift_n + drag_dir * drag_n + + # Engine thrust + var thrust_force := fwd * thrust_n * throttle + state["engine_rpm"] = max_rpm * throttle + state["throttle_pos"] = throttle + + # Total force & acceleration + var gravity := Vector3(0.0, -9.81 * mass, 0.0) + var total_force := aero_force + thrust_force + gravity + + # Ground clamp + var ground_y := 0.0 + if transform.origin.y <= ground_y + 0.1: + _kin_on_ground = true + if total_force.y < 0.0: + total_force.y = 0.0 + if _kin_velocity.y < 0.0: + _kin_velocity.y = 0.0 + transform.origin.y = ground_y + 0.05 + else: + _kin_on_ground = false + + state["on_ground"] = _kin_on_ground + + # Integrate velocity & position + _kin_velocity += (total_force / mass) * delta + state["velocity"] = _kin_velocity + state["position"] = transform.origin + _kin_velocity * delta + state["airspeed_ms"] = airspeed + state["altitude_m"] = state["position"].y + + # Angular dynamics (simple proportional control) + var roll_rate_max := deg_to_rad(cfg.get("max_roll_rate_dps", 180.0)) + var pitch_rate_max := deg_to_rad(cfg.get("max_pitch_rate_dps", 90.0)) + var yaw_rate_max := deg_to_rad(cfg.get("max_yaw_rate_dps", 60.0)) + + var speed_factor := clampf(airspeed / 10.0, 0.0, 1.0) + _kin_ang_vel.x = aileron * roll_rate_max * speed_factor + _kin_ang_vel.z = elevator * pitch_rate_max * speed_factor + _kin_ang_vel.y = rudder * yaw_rate_max * speed_factor + + # Integrate orientation + _kin_rotation += Vector3( + rad_to_deg(_kin_ang_vel.x), + rad_to_deg(_kin_ang_vel.y), + rad_to_deg(_kin_ang_vel.z) + ) * delta + + state["angular_velocity"] = _kin_ang_vel + state["euler_deg"] = _kin_rotation + state["orientation"] = Quaternion.from_euler(Vector3( + deg_to_rad(_kin_rotation.x), + deg_to_rad(_kin_rotation.y), + deg_to_rad(_kin_rotation.z) + )) + +# --------------------------------------------------------------------------- +# Utility +# --------------------------------------------------------------------------- +func _surface_to_jsbsim_prop(surface: String) -> String: + match surface: + SURFACE_AILERON: return "fcs/aileron-cmd-norm" + SURFACE_ELEVATOR: return "fcs/elevator-cmd-norm" + SURFACE_RUDDER: return "fcs/rudder-cmd-norm" + SURFACE_THROTTLE: return "fcs/throttle-cmd-norm" + SURFACE_FLAP: return "fcs/flap-cmd-norm" + return "" diff --git a/godot_project/scripts/ui/hud.gd b/godot_project/scripts/ui/hud.gd new file mode 100644 index 0000000..d88e863 --- /dev/null +++ b/godot_project/scripts/ui/hud.gd @@ -0,0 +1,72 @@ +## hud.gd +## In-flight heads-up display: shows airspeed, altitude, attitude indicator, +## throttle bar, camera mode, and telemetry. +extends CanvasLayer + +# --------------------------------------------------------------------------- +# Node references +# --------------------------------------------------------------------------- +@onready var _label_airspeed: Label = $HUDPanel/Airspeed +@onready var _label_altitude: Label = $HUDPanel/Altitude +@onready var _label_throttle: Label = $HUDPanel/Throttle +@onready var _label_camera: Label = $HUDPanel/CameraMode +@onready var _label_fps: Label = $HUDPanel/FPS +@onready var _attitude_indicator: Control = $HUDPanel/AttitudeIndicator + +## Reference to the active aircraft node (set by main scene) +var aircraft: AircraftNode = null + +## Reference to the camera manager (set by main scene) +var camera_manager: CameraManager = null + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- +func _ready() -> void: + visible = SettingsManager.get_setting("show_hud", true) + +func _process(_delta: float) -> void: + if not visible: + return + + # FPS counter + _label_fps.text = "FPS: %d" % Engine.get_frames_per_second() + + if aircraft == null: + return + + var state := aircraft.fdm.get_state() + + # Airspeed (m/s โ†’ km/h for display) + var airspeed_kmh := state.get("airspeed_ms", 0.0) * 3.6 + _label_airspeed.text = "SPD: %.1f km/h" % airspeed_kmh + + # Altitude (m) + var alt := state.get("altitude_m", 0.0) + _label_altitude.text = "ALT: %.1f m" % alt + + # Throttle percentage + var thr := state.get("throttle_pos", 0.0) * 100.0 + _label_throttle.text = "THR: %.0f%%" % thr + + # Camera mode + if camera_manager: + _label_camera.text = "CAM: %s" % camera_manager._mode_to_string(camera_manager.current_mode).to_upper() + + # Attitude indicator: update via euler angles + var euler := state.get("euler_deg", Vector3.ZERO) + _update_attitude_indicator(euler.x, euler.z) + +## Simple artificial horizon drawing +func _update_attitude_indicator(roll_deg: float, pitch_deg: float) -> void: + if _attitude_indicator == null: + return + _attitude_indicator.rotation = deg_to_rad(-roll_deg) + # Shift the horizon line based on pitch + var pitch_pixel_scale := 2.0 # pixels per degree + _attitude_indicator.position.y = pitch_deg * pitch_pixel_scale + +## Toggle HUD visibility +func toggle_hud() -> void: + visible = not visible + SettingsManager.set_setting("show_hud", visible) diff --git a/godot_project/scripts/ui/main_menu.gd b/godot_project/scripts/ui/main_menu.gd new file mode 100644 index 0000000..b5619e2 --- /dev/null +++ b/godot_project/scripts/ui/main_menu.gd @@ -0,0 +1,55 @@ +## main_menu.gd +## Main menu UI: handles aircraft/scenery selection and launches flight. +extends Control + +@onready var _btn_fly: Button = $VBox/BtnFly +@onready var _btn_settings: Button = $VBox/BtnSettings +@onready var _btn_calibrate: Button = $VBox/BtnCalibrate +@onready var _btn_quit: Button = $VBox/BtnQuit +@onready var _aircraft_option: OptionButton = $VBox/AircraftOption +@onready var _scenery_option: OptionButton = $VBox/SceneryOption +@onready var _version_label: Label = $VersionLabel + +const AIRCRAFT_LIST := ["trainer", "aerobat", "jet"] +const SCENERY_LIST := ["default_airfield", "indoor_arena"] + +func _ready() -> void: + _btn_fly.pressed.connect(_on_fly_pressed) + _btn_settings.pressed.connect(_on_settings_pressed) + _btn_calibrate.pressed.connect(_on_calibrate_pressed) + _btn_quit.pressed.connect(_on_quit_pressed) + + # Populate dropdowns + _aircraft_option.clear() + for a in AIRCRAFT_LIST: + _aircraft_option.add_item(a.capitalize()) + _scenery_option.clear() + for s in SCENERY_LIST: + _scenery_option.add_item(s.replace("_", " ").capitalize()) + + # Restore last selection + var saved_aircraft := SettingsManager.get_setting("aircraft", "trainer") + var saved_scenery := SettingsManager.get_setting("scenery", "default_airfield") + _aircraft_option.selected = max(AIRCRAFT_LIST.find(saved_aircraft), 0) + _scenery_option.selected = max(SCENERY_LIST.find(saved_scenery), 0) + + _version_label.text = "RC-Flight-Sim v%s" % ProjectSettings.get_setting("application/config/version", "0.1.0") + +func _on_fly_pressed() -> void: + var aircraft := AIRCRAFT_LIST[_aircraft_option.selected] + var scenery := SCENERY_LIST[_scenery_option.selected] + SceneManager.start_flight(aircraft, scenery) + +func _on_settings_pressed() -> void: + get_tree().change_scene_to_file("res://scenes/ui/settings_menu.tscn") + +func _on_calibrate_pressed() -> void: + var wizard_scene := load("res://scenes/ui/calibration_wizard.tscn") as PackedScene + if wizard_scene: + var wizard := wizard_scene.instantiate() + add_child(wizard) + else: + push_warning("[MainMenu] Calibration wizard scene not found.") + +func _on_quit_pressed() -> void: + get_tree().quit() diff --git a/godot_project/scripts/ui/settings_menu.gd b/godot_project/scripts/ui/settings_menu.gd new file mode 100644 index 0000000..3f5e3d1 --- /dev/null +++ b/godot_project/scripts/ui/settings_menu.gd @@ -0,0 +1,63 @@ +## settings_menu.gd +## Settings menu: graphics presets, audio volumes, display options. +extends Control + +@onready var _preset_option: OptionButton = $ScrollContainer/VBox/PresetOption +@onready var _fullscreen_check: CheckBox = $ScrollContainer/VBox/FullscreenCheck +@onready var _vsync_check: CheckBox = $ScrollContainer/VBox/VsyncCheck +@onready var _master_slider: HSlider = $ScrollContainer/VBox/MasterSlider +@onready var _sfx_slider: HSlider = $ScrollContainer/VBox/SFXSlider +@onready var _music_slider: HSlider = $ScrollContainer/VBox/MusicSlider +@onready var _btn_apply: Button = $Buttons/BtnApply +@onready var _btn_back: Button = $Buttons/BtnBack + +const PRESETS := [ + SettingsManager.PRESET_LOW, + SettingsManager.PRESET_MEDIUM, + SettingsManager.PRESET_HIGH, + SettingsManager.PRESET_ULTRA, +] + +func _ready() -> void: + _btn_apply.pressed.connect(_on_apply_pressed) + _btn_back.pressed.connect(_on_back_pressed) + + _preset_option.clear() + for p in PRESETS: + _preset_option.add_item(p) + + _load_current_settings() + +func _load_current_settings() -> void: + var preset := SettingsManager.get_setting("graphics_preset", SettingsManager.PRESET_MEDIUM) + _preset_option.selected = max(PRESETS.find(preset), 0) + _fullscreen_check.button_pressed = SettingsManager.get_setting("fullscreen", false) + _vsync_check.button_pressed = SettingsManager.get_setting("vsync", true) + _master_slider.value = SettingsManager.get_setting("audio_master_vol", 1.0) + _sfx_slider.value = SettingsManager.get_setting("audio_sfx_vol", 1.0) + _music_slider.value = SettingsManager.get_setting("audio_music_vol", 0.5) + +func _on_apply_pressed() -> void: + SettingsManager.apply_graphics_preset(PRESETS[_preset_option.selected]) + SettingsManager.set_setting("fullscreen", _fullscreen_check.button_pressed) + SettingsManager.set_setting("vsync", _vsync_check.button_pressed) + SettingsManager.set_setting("audio_master_vol", _master_slider.value) + SettingsManager.set_setting("audio_sfx_vol", _sfx_slider.value) + SettingsManager.set_setting("audio_music_vol", _music_slider.value) + SettingsManager.save() + + # Re-apply display settings immediately + if _fullscreen_check.button_pressed: + DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN) + else: + DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED) + DisplayServer.window_set_vsync_mode( + DisplayServer.VSYNC_ENABLED if _vsync_check.button_pressed else DisplayServer.VSYNC_DISABLED + ) + + var master_bus := AudioServer.get_bus_index("Master") + if master_bus >= 0: + AudioServer.set_bus_volume_db(master_bus, linear_to_db(_master_slider.value)) + +func _on_back_pressed() -> void: + get_tree().change_scene_to_file("res://scenes/ui/main_menu.tscn") From 1c7066c55b14ca23c897e35197852ba30950e098 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 29 May 2026 01:25:07 +0000 Subject: [PATCH 3/3] ci: clone godot-cpp directly (godot-4.2 branch) so build can find it The .gitmodules entry for godot-cpp isn't registered as a gitlink, so actions/checkout's `submodules: recursive` silently skipped it and the subsequent `git submodule update` was a no-op (suppressed with `|| true`). CMake then aborted with "godot-cpp not found". Replace the submodule step with a shallow `git clone` of the godot-4.2 branch (matching GODOT_VERSION 4.2.2) into ${{ github.workspace }}/godot-cpp, which is the path already passed via -DGODOT_CPP_DIR. --- .github/workflows/build.yml | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 72e55ad..1bea35f 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -40,8 +40,13 @@ jobs: with: submodules: recursive - - name: Setup godot-cpp submodule - run: git submodule update --init -- godot-cpp || true + - name: Fetch godot-cpp (matching Godot ${{ env.GODOT_VERSION }}) + run: | + if [ ! -f godot-cpp/CMakeLists.txt ]; then + rm -rf godot-cpp + git clone --depth 1 --branch godot-4.2 https://github.com/godotengine/godot-cpp godot-cpp + fi + shell: bash - name: Cache CMake build uses: actions/cache@v4