Compare commits
8 Commits
09280dd410
..
v0.5.0
| Author | SHA1 | Date | |
|---|---|---|---|
 ml
|
70c43240bc | ||
|
ml
|
d8324d409e | ||
|
ml
|
c24b7f15cb | ||
|
ml
|
e1e6a006d4 | ||
|
ml
|
5fe4cdf7f8 | ||
|
ml
|
369555efc7 | ||
|
ml
|
360a1f7e3d | ||
|
ml
|
c0619a55ab |
@@ -3,6 +3,7 @@
|
||||
|
||||
# Game assets are not included in the repo
|
||||
/res/assets/setup_system_shock_enhanced*
|
||||
/res/assets/setup_system_shock_classic*
|
||||
/res/assets/*.zip
|
||||
/res/assets/ss_ee/
|
||||
|
||||
|
||||
@@ -9,9 +9,11 @@ startup, in addition to (and independent of) the engine's own `prefs.txt`.
|
||||
- **Format**: plain JSON, grouped by concern. Each top-level key is a
|
||||
*group*; each key inside a group is one *option*.
|
||||
- **Loading**: read automatically at app startup, before the splash screen,
|
||||
if the file exists. If it doesn't exist, nothing changes - the engine
|
||||
behaves exactly as it did before this file existed (driven by `prefs.txt`
|
||||
as usual).
|
||||
if the file exists. If it doesn't, `questshock.config.default.json` (same
|
||||
folder) is used instead - a copy bundled with the app, refreshed on every
|
||||
launch, never overwriting your own saved `questshock.config.json`. If
|
||||
neither file exists, the engine behaves as it did before this file
|
||||
existed (driven by `prefs.txt` as usual).
|
||||
- **Saving**: never automatic. In-headset, open the menu (controller menu
|
||||
button) and press **Save Configuration** to write the file from your
|
||||
current live settings, overwriting it if present. Press **Load
|
||||
@@ -29,7 +31,7 @@ startup, in addition to (and independent of) the engine's own `prefs.txt`.
|
||||
load and so applies every group in the file, including the
|
||||
restart-required ones.
|
||||
|
||||
(Both options currently documented below are live-appliable, so this
|
||||
(Every option currently documented below is live-appliable, so this
|
||||
dialog won't actually appear yet - it's built in for options added in a
|
||||
future version that do need a restart.)
|
||||
- Unrecognized groups/keys are ignored (harmless if you're editing the file
|
||||
@@ -47,7 +49,38 @@ startup, in addition to (and independent of) the engine's own `prefs.txt`.
|
||||
{
|
||||
"video_options": {
|
||||
"renderer": "opengl",
|
||||
"resolution": "1024x768"
|
||||
"resolution": "1024x768",
|
||||
"initial_screen_width_m": 1.6,
|
||||
"initial_screen_distance_m": 2.0,
|
||||
"game_screen_width_m": 2.8,
|
||||
"game_screen_distance_m": 2.0,
|
||||
"screen_width_offset_m": 1.0,
|
||||
"screen_width_step_m": 0.6,
|
||||
"screen_distance_offset_m": 1.0,
|
||||
"screen_distance_step_m": 0.5
|
||||
},
|
||||
"general": {
|
||||
"language": "english"
|
||||
},
|
||||
"player_position": {
|
||||
"x": 0.0,
|
||||
"z": 0.0,
|
||||
"yaw_degrees": 0.0
|
||||
},
|
||||
"player_controls": {
|
||||
"move_forward": "left_thumbstick_up",
|
||||
"move_back": "left_thumbstick_down",
|
||||
"strafe_left": "left_thumbstick_left",
|
||||
"strafe_right": "left_thumbstick_right",
|
||||
"turn_left": "right_thumbstick_left",
|
||||
"turn_right": "right_thumbstick_right",
|
||||
"jump": "left_thumbstick_click",
|
||||
"mouse_click": "right_a",
|
||||
"mouse_double_click": "right_b",
|
||||
"stand": "right_thumbstick_up",
|
||||
"prone": "right_thumbstick_down",
|
||||
"map_view": "right_thumbstick_click",
|
||||
"fire_weapon": "right_trigger"
|
||||
}
|
||||
}
|
||||
```
|
||||
@@ -69,3 +102,349 @@ The game's internal rendering resolution.
|
||||
- **Type**: enum
|
||||
- **Possible values**: `"320x200"`, `"320x400"`, `"640x400"`, `"640x480"`, `"1024x768"`
|
||||
- **Restart required?**: No (live-appliable)
|
||||
|
||||
### `initial_screen_width_m`, `initial_screen_distance_m`, `game_screen_width_m`, `game_screen_distance_m`
|
||||
|
||||
The virtual screen's physical width and distance from the player (both in
|
||||
meters) - the game shows two independently configurable screen
|
||||
"profiles", switched automatically based on what's currently on screen:
|
||||
|
||||
- **Initial Screen** (`initial_screen_*`) - the splash screen, intro
|
||||
cutscenes, and the game's own main menu.
|
||||
- **Game Screen** (`game_screen_*`) - actual gameplay (the 3D view,
|
||||
automap, cyberspace, etc.).
|
||||
|
||||
Switching happens automatically - no player action needed - the instant
|
||||
the game itself transitions between these (e.g. starting/loading a game,
|
||||
or returning to the menu).
|
||||
|
||||
- **Type**: number (meters)
|
||||
- **Possible values**: the in-headset Video Options tab offers 5 presets
|
||||
each - widths `1.0`, `1.6` (the original, pre-this-feature default),
|
||||
`2.2`, `2.8`, `3.4`; distances `1.0`, `1.5`, `2.0` (the original,
|
||||
pre-this-feature default), `2.5`, `3.0` - but a hand-edited value
|
||||
doesn't need to match a preset exactly (it's clamped to a sane range -
|
||||
width `[0.2, 10.0]`, distance `[0.5, 10.0]` - rather than snapped or
|
||||
rejected; the Video Options tab just shows no button selected for an
|
||||
in-between value).
|
||||
- **Restart required?**: No (live-appliable)
|
||||
- **Note**: the screen is always flat - there's no curve option.
|
||||
|
||||
### `screen_width_offset_m`, `screen_width_step_m`, `screen_distance_offset_m`, `screen_distance_step_m`
|
||||
|
||||
Reshapes the 5 preset buttons the Video Options tab offers for width and
|
||||
distance (above) - config-file-only, there's no in-headset control for
|
||||
these. Shared by both **Initial Screen** and **Game Screen** (both
|
||||
columns' buttons show the same 5 values per row) - this only changes
|
||||
what the buttons offer, not either profile's current value.
|
||||
|
||||
Preset button `index` (0-4) shows `offset + step * index`. For example,
|
||||
a distance offset of `0` and step of `2` shows buttons `0`, `2`, `4`,
|
||||
`6`, `8`; the defaults below reproduce this feature's original launch
|
||||
presets exactly.
|
||||
|
||||
- **Type**: number (meters)
|
||||
- **Default values**: width offset `1.0`, step `0.6` (buttons `1.0`,
|
||||
`1.6`, `2.2`, `2.8`, `3.4`); distance offset `1.0`, step `0.5` (buttons
|
||||
`1.0`, `1.5`, `2.0`, `2.5`, `3.0`).
|
||||
- **Restart required?**: No (live-appliable)
|
||||
- **Note**: not clamped - an unusual offset/step (e.g. negative step) is
|
||||
accepted as-is. A resulting preset value outside the current value's
|
||||
own clamp range (see above) still clamps normally when that preset
|
||||
button is actually pressed.
|
||||
|
||||
## General (`general`)
|
||||
|
||||
### `language`
|
||||
|
||||
The game's UI/text language - both the game's own resource strings and this
|
||||
project's own menu/keyboard chrome text (title bar, buttons, etc.).
|
||||
|
||||
- **Type**: enum
|
||||
- **Possible values**: `"english"`, `"french"`, `"german"`
|
||||
- **Restart required?**: No (live-appliable) - applies the same way the
|
||||
game's own in-game options menu applies a language change (reloads the
|
||||
language-specific resource files and refreshes the inventory/MFD/side-icon
|
||||
UI immediately).
|
||||
- **Note**: French and German both need their own full resource pack
|
||||
(`frnstrng.res`/`mfdfrn.res`, `gerstrng.res`/`mfdger.res` under
|
||||
`res/data/`) - if any of those files aren't present, the switch is
|
||||
refused (logged, `questshock.config.json` and the current language are
|
||||
left unchanged) rather than leaving the game with no valid resource file
|
||||
open. See README.md section 3 ("Game assets") for where `mfdfrn.res`/
|
||||
`mfdger.res` come from - the GOG Enhanced Edition installer alone doesn't
|
||||
include them.
|
||||
|
||||
## Player Position (`player_position`)
|
||||
|
||||
Where the player is virtually standing/facing, independent of - and not
|
||||
reset by - starting a new game or loading a save (same independence from
|
||||
`prefs.txt`/savegames as every other group here). Set by moving around
|
||||
in-headset (menu open, left thumbstick snap-turns, right thumbstick smooth-
|
||||
moves) to line yourself up with the game quad ("virtual screen"). Height is
|
||||
never included here - it always comes from your real tracked headset
|
||||
height, not this file.
|
||||
|
||||
**Startup fallback**: only applied at startup if all three fields (`x`,
|
||||
`z`, `yaw_degrees`) are present - a config file with none of them (or none
|
||||
at all), or a partial/hand-edited one missing any of the three, falls back
|
||||
to an automatic recenter instead (see **Reset Position** below), using
|
||||
your real head pose at that moment. A complete saved position is applied
|
||||
as-is, with no such recenter.
|
||||
|
||||
**Reset Position** (Main Menu tab) is a live-only action, not a config
|
||||
value: it moves you to the centre in front of the game quad, based on where
|
||||
your head actually is right now. It resets only your *position*, not which
|
||||
way you're facing, so the screen does not rotate to follow your gaze - press
|
||||
it while looking off to one side and the screen stays off to the other side.
|
||||
The automatic recenter at startup (when there's no saved position) does
|
||||
face the screen towards where you're looking. Reset Position never reads or
|
||||
writes `questshock.config.json`.
|
||||
|
||||
### `x`, `z`
|
||||
|
||||
Horizontal position, in meters, on the play space's floor plane.
|
||||
|
||||
- **Type**: number
|
||||
- **Restart required?**: No (live-appliable)
|
||||
|
||||
### `yaw_degrees`
|
||||
|
||||
Which way the player is virtually facing, in degrees.
|
||||
|
||||
- **Type**: number
|
||||
- **Restart required?**: No (live-appliable)
|
||||
|
||||
## Player Controls (`player_controls`)
|
||||
|
||||
Maps each of 57 in-game actions to a physical controller input: 9
|
||||
movement/click actions, 2 free-view actions, 11 cyberspace actions, and 35
|
||||
for the engine's own keyboard hotkeys and firing (posture, save/load, weapon
|
||||
select, MFD panels, etc. - see the hotkey table below). Some actions are bound by default (see the default-input
|
||||
columns); the rest are unbound and can be bound on demand. Assign them in the
|
||||
**Controller Options** menu tab: tap an action's binding button, then press
|
||||
the button or stick direction to use ("Press a button…"); tap it again, or
|
||||
wait 8 seconds, to cancel without changing it.
|
||||
|
||||
- **Type**: one enum-string field per action (below)
|
||||
- **Restart required?**: No (live-appliable) - a rebind takes effect
|
||||
immediately, and persists across restarts once saved (**Save
|
||||
Configuration**, same as every other group here).
|
||||
- **Not included here**: opening/closing the VR menu itself is a fixed,
|
||||
non-remappable button (see "Menu button" below) - there's no
|
||||
`menu_toggle` field, and the Controller Options tab never lets you
|
||||
reassign it. This guarantees you can always reach this tab and press
|
||||
**Reset to Defaults** to recover from any bad rebind, no matter what else
|
||||
you've reassigned.
|
||||
- **Reset to Defaults**: restores the "Default input" column below for
|
||||
every action not overridden by a `player_controls` group in
|
||||
`questshock.config.default.json` - if that file defines one (it doesn't,
|
||||
out of the box), the values it specifies are applied on top of the table
|
||||
below instead, so you can customize what "reset" means without a rebuild.
|
||||
This is independent of your own `questshock.config.json` - resetting
|
||||
doesn't read or write that file, just the live bindings (**Save
|
||||
Configuration** afterward to persist them).
|
||||
|
||||
### Actions
|
||||
|
||||
| Action key | Default input | Effect |
|
||||
|---|---|---|
|
||||
| `move_forward` | `left_thumbstick_up` | Walk forward |
|
||||
| `move_back` | `left_thumbstick_down` | Walk backward |
|
||||
| `strafe_left` | `left_thumbstick_left` | Step sideways, left |
|
||||
| `strafe_right` | `left_thumbstick_right` | Step sideways, right |
|
||||
| `turn_left` | `right_thumbstick_left` | Turn left |
|
||||
| `turn_right` | `right_thumbstick_right` | Turn right |
|
||||
| `jump` | `left_thumbstick_click` | Jump |
|
||||
| `mouse_click` | `right_a` | Click - operates the keyboard/game quad's cursor, whichever the pointing hand's ray is over |
|
||||
| `mouse_double_click` | `right_b` | Double-click - game quad only (e.g. using an inventory item); has no effect over the menu or keyboard |
|
||||
| `free_left_thumbstick_view` | `left_squeeze` | Hold to look around with the left thumbstick (see below) |
|
||||
| `free_right_thumbstick_view` | `none` | Hold to look around with the right thumbstick (see below) |
|
||||
|
||||
Movement actions bound to a thumbstick direction are suppressed while the
|
||||
VR menu is open, since the same physical stick already snap-turns/smooth-
|
||||
moves the player in that state (see `player_position` above) - this is the
|
||||
one case where a binding's effect depends on whether the menu is open, and
|
||||
it only ever affects the 8 thumbstick-direction inputs below.
|
||||
|
||||
**Free view** (`free_left_thumbstick_view`, `free_right_thumbstick_view`) is
|
||||
the engine's mouse look driven by a thumbstick. While the bound input is held,
|
||||
that stick looks around instead of doing its normal job: left/right turns the
|
||||
view, up/down looks up and down, in proportion to how far the stick is pushed.
|
||||
The stick's own direction bindings (move, strafe, turn, stand/prone) are
|
||||
suspended while it is held, and the cursor stays centred in the view. Release
|
||||
the input to return to normal. It has no effect while the VR menu is open.
|
||||
|
||||
### Cyberspace actions
|
||||
|
||||
Cyberspace has its own set of movement actions, active only while the player
|
||||
is in cyberspace. While in cyberspace the normal movement actions
|
||||
(`move_*`, `strafe_*`, `turn_*`, `jump`, `stand`, `crouch`, `prone`) are
|
||||
inactive, and the cyberspace actions are inactive everywhere else. Each set
|
||||
has its own bindings, so one input can be bound in both (for example the left
|
||||
stick up is `move_forward` on foot and `cyber_climb` in cyberspace);
|
||||
the Controller Options tab only reports a conflict between actions that can
|
||||
be active at the same time. Free view, clicking and firing work in both.
|
||||
|
||||
Pitch and bank (`cyber_climb`, `cyber_dive`, `cyber_bank_*` and the four
|
||||
diagonals) are proportional when bound to a thumbstick direction: pushing the
|
||||
stick further turns faster, from 20% of full speed just past the trigger point
|
||||
to 60% at full deflection. Bound to a button they run at full speed. Thrust and
|
||||
roll are always full speed.
|
||||
|
||||
| Action key | Default input | Keyboard equivalent | Effect |
|
||||
|---|---|---|---|
|
||||
| `cyber_thrust` | `right_thumbstick_up` | `s` | Thrust forward |
|
||||
| `cyber_climb` | `left_thumbstick_up` | `w` | Pitch up |
|
||||
| `cyber_dive` | `left_thumbstick_down` | `x` | Pitch down |
|
||||
| `cyber_bank_left` | `left_thumbstick_left` | `a` | Bank left |
|
||||
| `cyber_bank_right` | `left_thumbstick_right` | `d` | Bank right |
|
||||
| `cyber_roll_left` | `right_thumbstick_left` | `e` | Roll left |
|
||||
| `cyber_roll_right` | `right_thumbstick_right` | `q` | Roll right |
|
||||
| `cyber_climb_left` | `none` | Keypad 7 | Pitch up and bank left |
|
||||
| `cyber_climb_right` | `none` | Keypad 9 | Pitch up and bank right |
|
||||
| `cyber_dive_left` | `none` | Keypad 1 | Pitch down and bank left |
|
||||
| `cyber_dive_right` | `none` | Keypad 3 | Pitch down and bank right |
|
||||
|
||||
`mouse_click` additionally behaves differently depending on the menu:
|
||||
while the VR menu is open, its "click" is always whichever hand's trigger
|
||||
is used to interact with the menu (so you can never lock yourself out of
|
||||
this settings screen by rebinding `mouse_click` elsewhere); once the menu
|
||||
is closed, both the on-screen keyboard (if it's still open) and the game
|
||||
quad use your actual `mouse_click` binding. The default (`right_a`) is a
|
||||
specific button on the right controller, so only the right hand's ray clicks;
|
||||
bind the `trigger` identifier (see below) for either hand to click.
|
||||
|
||||
### Hotkey actions
|
||||
|
||||
The engine's own keyboard hotkeys (`HotKeyLookup[]` in `Prefs.c`) plus
|
||||
firing, as 35 bindable actions. `stand` (`right_thumbstick_up`), `prone`
|
||||
(`right_thumbstick_down`), `map_view` (`right_thumbstick_click`) and
|
||||
`fire_weapon` (`right_trigger`) are bound by default; the rest are unbound
|
||||
(`none`). Each fires once per press, like pressing the key on a real
|
||||
keyboard (there is no hold behavior).
|
||||
|
||||
| Action key | Keyboard equivalent | Effect |
|
||||
|---|---|---|
|
||||
| `stand` | `t` | Stand up |
|
||||
| `crouch` | `g` | Crouch |
|
||||
| `prone` | `b` | Go prone |
|
||||
| `pause` | `p` | Pause the game |
|
||||
| `full_view` | Ctrl+F | Switch to the fullscreen view loop |
|
||||
| `normal_view` | Ctrl+D | Switch to the normal gameplay view |
|
||||
| `map_view` | Ctrl+A | Switch to the automap view |
|
||||
| `save_game` | Ctrl+S | Save the game |
|
||||
| `load_game` | Ctrl+L | Load the game |
|
||||
| `select_grenade` | Ctrl+' | Select the next grenade type |
|
||||
| `arm_grenade` | Alt+' | Arm the selected grenade |
|
||||
| `select_drug` | Ctrl+; | Select the next drug/patch |
|
||||
| `use_drug` | Alt+; | Use the selected drug/patch |
|
||||
| `toggle_online_help` | Ctrl+H | Toggle the online help overlay |
|
||||
| `show_help` | Alt+O | Show the help screen |
|
||||
| `toggle_music` | Ctrl+M | Toggle music |
|
||||
| `quit` | Ctrl+Q | Quit the game - opt-in only; nothing binds this by default |
|
||||
| `cycle_weapon_next` | Tab | Ready the next weapon |
|
||||
| `cycle_weapon_prev` | Shift+Tab | Ready the previous weapon |
|
||||
| `cycle_detail` | Ctrl+1 | Cycle the graphics detail level |
|
||||
| `reload_weapon_primary` | Ctrl+Backspace | Reload the current weapon's primary ammo |
|
||||
| `reload_weapon_secondary` | Alt+Backspace | Reload the current weapon's secondary ammo |
|
||||
| `hud_color` | Alt+H | Cycle the HUD color scheme |
|
||||
| `clear_fullscreen` | Backspace | Close a fullscreen view (e.g. a datapad or email) |
|
||||
| `mfd_left_1`-`mfd_left_5` | F1-F5 | Set the left MFD panel to Weapon/Item/Map/Target/Info |
|
||||
| `mfd_right_1`-`mfd_right_5` | F6-F10 | Set the right MFD panel to Weapon/Item/Map/Target/Info |
|
||||
| `fire_weapon` | Enter | Fire the readied weapon at the cursor (the engine's default fire key). Clicking in the 3D view with `mouse_click` also fires; this is a separate button for it |
|
||||
|
||||
**Not exposed** (other `HotKeyLookup[]` entries):
|
||||
- `keypad 0`-`keypad 9`: a controller button per digit is not useful; use the
|
||||
on-screen keyboard.
|
||||
- `toggle_freelook` (F): the free-view actions cover mouse look.
|
||||
- The 4 `cheat_*` entries: debug cheats. They are on the menu's Cheats tab instead.
|
||||
- `mac_help` (disabled) and `audiolog_cancel` (its build flag is not
|
||||
defined): they are not real hotkeys in this build.
|
||||
- `toggle_opengl` (Ctrl+G): the Video Options tab's Renderer buttons already
|
||||
toggle the same setting.
|
||||
- The 10 numeric hardware-item hotkeys (bio scan, fullscreen, 360 view,
|
||||
lantern, shield, infrared, nav unit, data reader, booster, jumpjets): their
|
||||
registered keys never match a real keypress in the engine.
|
||||
|
||||
### Raw input identifiers
|
||||
|
||||
Every raw physical input available to bind an action to, with its generic
|
||||
OpenXR interaction-profile component name and its Meta Quest Touch control
|
||||
name. Two symmetric identifiers (`trigger`, `squeeze`) are also accepted, but
|
||||
only for `mouse_click`/`mouse_double_click`: they mean "either hand's own
|
||||
trigger/grip, whichever hand is pointing". Every other identifier below
|
||||
refers to one specific control.
|
||||
|
||||
| Identifier | OpenXR component (Touch) | Meta Quest control |
|
||||
|---|---|---|
|
||||
| `left_trigger` | `/user/hand/left/input/trigger/value` | Left Trigger |
|
||||
| `right_trigger` | `/user/hand/right/input/trigger/value` | Right Trigger |
|
||||
| `left_squeeze` | `/user/hand/left/input/squeeze/value` | Left Grip |
|
||||
| `right_squeeze` | `/user/hand/right/input/squeeze/value` | Right Grip |
|
||||
| `left_x` | `/user/hand/left/input/x/click` | X Button |
|
||||
| `left_y` | `/user/hand/left/input/y/click` | Y Button |
|
||||
| `right_a` | `/user/hand/right/input/a/click` | A Button |
|
||||
| `right_b` | `/user/hand/right/input/b/click` | B Button |
|
||||
| `left_thumbstick_click` | `/user/hand/left/input/thumbstick/click` | Left Thumbstick Click |
|
||||
| `right_thumbstick_click` | `/user/hand/right/input/thumbstick/click` | Right Thumbstick Click |
|
||||
| `left_thumbstick_up/down/left/right` | `/user/hand/left/input/thumbstick` (digitized) | Left Thumbstick, tilted |
|
||||
| `right_thumbstick_up/down/left/right` | `/user/hand/right/input/thumbstick` (digitized) | Right Thumbstick, tilted |
|
||||
| `trigger` | either hand's trigger | Either Trigger (`mouse_click`/`mouse_double_click` only) |
|
||||
| `squeeze` | either hand's grip | Either Grip (`mouse_click`/`mouse_double_click` only) |
|
||||
| `none` | - | Unbound - the action never fires |
|
||||
|
||||
**Menu button** (left controller, Touch/Vive/generic alike) is not in this
|
||||
list - it always opens/closes the VR menu and can never be reassigned.
|
||||
|
||||
**Other supported controllers**: HTC Vive wands have no A/B/X/Y and no
|
||||
analog grip - `left_x`/`left_y`/`right_a`/`right_b` simply never fire on
|
||||
that profile, and `left/right_squeeze` are a plain click rather than
|
||||
analog. Their trackpad stands in for the thumbstick identifiers above
|
||||
(same digitization, just a trackpad instead of a stick). A bare-minimum
|
||||
OpenXR controller (`khr/simple_controller`, used as a fallback when
|
||||
neither Touch nor Vive bindings are suggested) only has `left_trigger`/
|
||||
`right_trigger` (via its `select/click` component) and the menu button -
|
||||
every other identifier above simply never fires on it, which is why the
|
||||
Controller Options tab shows a note and hides irrelevant rows when this
|
||||
profile is active.
|
||||
|
||||
### Controller profile files (`controller_profiles/`)
|
||||
|
||||
The Controller Options tab shows a labeled illustration of whichever
|
||||
controller is actually active, driven by `res/controller_profiles/*.json`
|
||||
(bundled with the app, copied to `/sdcard/questshock/controller_profiles/`
|
||||
on every launch, refreshing the known bundled files without touching any
|
||||
extra ones you add there yourself). Each file:
|
||||
|
||||
```json
|
||||
{
|
||||
"name": "Meta Quest Touch",
|
||||
"interaction_profile": "/interaction_profiles/oculus/touch_controller",
|
||||
"image": "touch.png",
|
||||
"controls": [
|
||||
{"id": "right_b", "label": "B", "anchor_x": 0.76, "anchor_y": 0.22}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
- `interaction_profile` - the OpenXR interaction profile path this file
|
||||
describes; matched against whichever one is actually bound at runtime.
|
||||
Falls back to `generic.json` if nothing matches.
|
||||
- `image` - filename (same folder) of the controller illustration.
|
||||
- `controls` - one entry per labeled point on that illustration: `id` is a
|
||||
raw input identifier from the table above (thumbstick directions share
|
||||
one `left_thumbstick`/`right_thumbstick` entry, since they're the same
|
||||
physical stick); `anchor_x`/`anchor_y` are 0-1 fractions of the image for
|
||||
positioning that label's pointer line.
|
||||
|
||||
This is presentation data only - adding real support for a new controller
|
||||
still needs matching bindings in the app itself; a profile file with no
|
||||
corresponding code-level support just never gets matched.
|
||||
|
||||
### Fatal startup error
|
||||
|
||||
If the OpenXR runtime rejects any of the three supported controller
|
||||
profiles' bindings at launch (an app bug, not something you did), a
|
||||
non-cancelable dialog explains this and exits - this should never happen
|
||||
in a normal build.
|
||||
|
||||
@@ -90,6 +90,21 @@ package`/`make apk` pick it up the same way either way. This one copy of
|
||||
game assets feeds both the desktop build and the Android/Quest build
|
||||
below.
|
||||
|
||||
**Note on French/German**: the GOG Enhanced Edition installer only ships
|
||||
English MFD (Multi-Function Display - the small in-game screens showing
|
||||
the map, inventory, etc.) art resources (`mfdart.res`) - it doesn't include
|
||||
`mfdfrn.res`/`mfdger.res`, which French/German need in addition to their
|
||||
own text resources (`frnstrng.res`/`gerstrng.res`, which the installer
|
||||
*does* include). Without those two files, switching to French/German (via
|
||||
`questshock.config.json`'s `general.language` or the in-headset menu's
|
||||
Language row - see [CONFIG.md](CONFIG.md)) is refused with an in-headset
|
||||
popup rather than applied, since doing so anyway used to crash the game. If
|
||||
you also own **System Shock: Classic** on gog.com (which does include both
|
||||
files), drop its offline installer into `res/assets/` alongside the
|
||||
Enhanced Edition one and `extract_assets.sh` pulls them out of it too,
|
||||
entirely optionally - it still runs fine with just the Enhanced Edition
|
||||
installer.
|
||||
|
||||
## 4. Desktop build
|
||||
|
||||
Builds and runs Questshock natively on the desktop (your dev machine, or
|
||||
|
||||
@@ -104,10 +104,14 @@ def stageEngineTask = tasks.register("stageEngine", Exec) {
|
||||
inputs.dir("${projectDir}/../gl4es-src")
|
||||
inputs.dir("${projectDir}/../gl4es-patches")
|
||||
inputs.file("${repoRoot}/build-image/Dockerfile")
|
||||
// Staged into assets/ by prepare-android-project.sh.
|
||||
inputs.file("${repoRoot}/res/questshock.config.default.json")
|
||||
inputs.dir("${repoRoot}/res/controller_profiles")
|
||||
outputs.dir("${repoRoot}/build/android-engine")
|
||||
outputs.dir("${repoRoot}/build/android-gl4es")
|
||||
outputs.dir("${repoRoot}/build/android-prebuilt")
|
||||
outputs.file("${projectDir}/../engine.properties")
|
||||
outputs.dir("${projectDir}/src/main/assets")
|
||||
}
|
||||
|
||||
// preBuild is what every variant's compile/native-build tasks already
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -49,15 +49,100 @@ void qs_config_request_load(void);
|
||||
void qs_config_request_set_renderer(bool opengl);
|
||||
void qs_config_request_set_resolution(int resolution_index);
|
||||
|
||||
// Returns true and handles the event if it's one of the four custom events
|
||||
// qs_config_request_save()/_load()/_set_renderer()/_set_resolution()
|
||||
// enqueue - called from pump_events() (sdl_events.c, see
|
||||
// android/engine-patches/21-android-config.patch) on the engine's own
|
||||
// thread, once per polled event, before its normal switch on well-known
|
||||
// SDL_* event types. Returns false (no-op) for any other event type,
|
||||
// including before the four custom types have even been registered.
|
||||
// Same cross-thread-dispatch reasoning as the two above - called from the
|
||||
// Main Menu tab's Language row (MenuOverlay.java). language_index is 0
|
||||
// English/1 French/2 German (gShockPrefs.goLanguage's own numbering,
|
||||
// Prefs.h). Applies live immediately, the same way the game's own options
|
||||
// menu applies a language change (see qs_config.c's qs_apply_language()).
|
||||
void qs_config_request_set_language(int language_index);
|
||||
|
||||
// Same cross-thread dispatch as the three above - called from the Main Menu
|
||||
// tab's "Reset Position" button. Re-anchors the player's position in front of
|
||||
// the game quad (see xr_input_reset_player_position()); never reads or writes
|
||||
// the config file.
|
||||
void qs_config_request_reset_position(void);
|
||||
|
||||
// Same cross-thread-dispatch reasoning as the four above - called from the
|
||||
// Video Options tab's "Initial Screen"/"Game Screen" width/distance
|
||||
// preset rows (MenuOverlay.java). preset_index indexes qs_config.c's own
|
||||
// shared, offset+step-generated width/distance preset lists (both in
|
||||
// meters; the offset/step themselves are config-file-only, not exposed
|
||||
// as buttons), read back via the four qs_config_current_*_screen_*_index()
|
||||
// getters below. Applies live immediately if the just-changed profile is
|
||||
// the currently active one (see CONFIG.md) - otherwise just updates the
|
||||
// stored preference, invisibly, until that profile becomes active (e.g.
|
||||
// tweaking "Initial Screen" mid-game).
|
||||
void qs_config_request_set_initial_screen_width(int preset_index);
|
||||
void qs_config_request_set_initial_screen_distance(int preset_index);
|
||||
void qs_config_request_set_game_screen_width(int preset_index);
|
||||
void qs_config_request_set_game_screen_distance(int preset_index);
|
||||
|
||||
// Cross-thread requests from the Controller Options tab (MenuOverlay.java),
|
||||
// enqueued like every request_*() above. action_index indexes
|
||||
// xr_input_action_name()'s list. Begin/cancel start and stop rebind capture;
|
||||
// reset restores all bindings (the built-in defaults, then
|
||||
// questshock.config.default.json's player_controls group if it has one).
|
||||
void qs_config_request_begin_control_capture(int action_index);
|
||||
void qs_config_request_cancel_control_capture(void);
|
||||
void qs_config_request_reset_player_controls(void);
|
||||
|
||||
// Called from xr_input.c's xr_input_process_capture() on the engine's own
|
||||
// thread, so no cross-thread dispatch is needed (as with
|
||||
// qs_screen_profile_notify_loop_mode() below). Resolves
|
||||
// MenuOverlay.onControlCaptureResult(int, String) for action_index (raw_name
|
||||
// NULL on timeout or cancel), and again for displaced_action_index if the new
|
||||
// binding took the input from another action (-1/NULL when none), so both
|
||||
// rows can be updated together.
|
||||
void qs_config_notify_control_capture_result(int action_index, const char *raw_name,
|
||||
int displaced_action_index,
|
||||
const char *displaced_raw_name);
|
||||
|
||||
// Called from xr_input.c whenever the VR menu's visibility changes. Showing
|
||||
// the menu pauses a running game (not the main menu, intro or cutscenes) that
|
||||
// is not already paused; hiding it unpauses only if the menu did the pausing.
|
||||
// Enqueued like the request_*() functions above; the pause itself runs on the
|
||||
// engine's thread at pump_events() time.
|
||||
void qs_config_notify_menu_visibility(bool visible);
|
||||
|
||||
// Cheats tab (MenuOverlay.java). Same enqueue-only requests as above; the work
|
||||
// runs on the engine's thread. cheat_id: 0 give everything, 1 toggle physics,
|
||||
// 2 next level, 3 previous level, 4-7 toggle unlimited health, energy, ammo,
|
||||
// items (grenades and drugs). Cheats need a running game (the unlimited
|
||||
// switches can be set anywhere). The getters are plain scalar reads, safe from
|
||||
// the UI thread; the unlimited mask has bit 0 health, 1 energy, 2 ammo, 3 items.
|
||||
void qs_config_request_cheat(int cheat_id);
|
||||
int qs_config_cheat_unlimited_mask(void);
|
||||
bool qs_config_cheat_physics_running(void);
|
||||
|
||||
// Called once per frame from xr_input.c on the engine's thread; applies the
|
||||
// unlimited-resource cheats that are switched on.
|
||||
void qs_config_frame_tick(void);
|
||||
|
||||
// Called from xr_input.c's xr_input_suggest_bindings() when the OpenXR runtime
|
||||
// rejects a supported interaction profile's suggested bindings at startup.
|
||||
// That is an app bug, not a config problem, so it shows
|
||||
// MenuOverlay.showFatalControllerBindingError()'s non-cancelable "Exit" dialog;
|
||||
// xr_input_init() aborts right after.
|
||||
void qs_config_report_fatal_input_error(const char *profile_display_name);
|
||||
|
||||
// Returns true and handles the event if it is one of the custom events the
|
||||
// request_*()/notify functions above enqueue. Called from pump_events()
|
||||
// (sdl_events.c, see android/engine-patches/21-android-config.patch) on the
|
||||
// engine's thread, once per polled event. Returns false for any other event
|
||||
// type, including before the custom types are registered.
|
||||
bool qs_config_handle_event(const SDL_Event *event);
|
||||
|
||||
// Called directly (no event-queue dispatch - see
|
||||
// android/engine-patches/22-android-screen-profile.patch and this
|
||||
// function's own definition in qs_config.c for why) from the engine's
|
||||
// mainloop.c whenever the loop mode changes, and once from
|
||||
// qs_config_load_startup() - picks between the "Initial Screen" (menu/
|
||||
// intro) and "Game Screen" (actual gameplay) presets based on new_mode
|
||||
// (mainloop.h's SETUP_LOOP/CUTSCENE_LOOP vs. everything else) and applies
|
||||
// the newly-active one's shape to xr_session.c, but only if it's actually
|
||||
// different from what was already active.
|
||||
void qs_screen_profile_notify_loop_mode(short new_mode);
|
||||
|
||||
// Read-only queries for the Video Options tab's own selection highlight
|
||||
// (MenuOverlay.java re-reads these whenever the tab is (re)shown, so it
|
||||
// reflects the live value even if it was last changed some other way, e.g.
|
||||
@@ -70,12 +155,37 @@ bool qs_config_handle_event(const SDL_Event *event);
|
||||
bool qs_config_current_renderer_is_opengl(void);
|
||||
int qs_config_current_resolution_index(void);
|
||||
|
||||
// -1 (not just an unlikely fallback, a routine, expected result here -
|
||||
// unlike qs_config_current_resolution_index() above) if the profile's
|
||||
// current value doesn't exactly match one of qs_config.c's own
|
||||
// offset+step-generated width/distance presets, e.g. after a hand-edited
|
||||
// config file sets an in-between value - MenuOverlay.java's own
|
||||
// setSelected() naturally shows no button selected in that case, no
|
||||
// special-casing needed.
|
||||
int qs_config_current_initial_screen_width_index(void);
|
||||
int qs_config_current_initial_screen_distance_index(void);
|
||||
int qs_config_current_game_screen_width_index(void);
|
||||
int qs_config_current_game_screen_distance_index(void);
|
||||
|
||||
// Returns the value preset button `index` (0..4) currently shows for the
|
||||
// width/distance option - shared by both "Initial Screen" and "Game
|
||||
// Screen" columns (their offset/step is config-file-only, not per-profile
|
||||
// - see qs_config.c's own comment on the underlying statics), so
|
||||
// MenuOverlay.java can label its preset buttons correctly even after a
|
||||
// Load Configuration changes the offset/step. Index is clamped into
|
||||
// range, not validated - every index 0..4 always has a value.
|
||||
float qs_config_screen_width_preset_value(int index);
|
||||
float qs_config_screen_distance_preset_value(int index);
|
||||
|
||||
// gShockPrefs.goLanguage (0 English/1 French/2 German, Prefs.h) - read by
|
||||
// MenuOverlay.java's/KeyboardOverlay.java's periodic header-refresh timer
|
||||
// to pick which language's chrome text (Strings.java) to display, so a
|
||||
// language change made mid-session via the game's own options menu is
|
||||
// picked up without needing to reopen either panel. Same
|
||||
// off-thread-scalar-read reasoning as the two getters above.
|
||||
// language change made mid-session via the game's own options menu (or our
|
||||
// own Language row, or Load Configuration) is picked up without needing to
|
||||
// reopen either panel; also doubles as the Main Menu tab's Language row's
|
||||
// own selection highlight, same as qs_config_current_renderer_is_opengl()/
|
||||
// qs_config_current_resolution_index() above. Same off-thread-scalar-read
|
||||
// reasoning as those two getters.
|
||||
int qs_config_current_language(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
#include <SDL.h>
|
||||
|
||||
#include "qs_config.h"
|
||||
#include "xr_input.h"
|
||||
#include "xr_overlay.h"
|
||||
#include "xr_session.h"
|
||||
|
||||
@@ -118,6 +119,47 @@ Java_de_ladkau_questshock_MenuOverlay_nativeRequestSetResolution(JNIEnv *env, jc
|
||||
qs_config_request_set_resolution(resolutionIndex);
|
||||
}
|
||||
|
||||
// MenuOverlay's Main Menu tab's Language row - same enqueue-only reasoning as above.
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestSetLanguage(JNIEnv *env, jclass clazz,
|
||||
jint languageIndex) {
|
||||
qs_config_request_set_language(languageIndex);
|
||||
}
|
||||
|
||||
// MenuOverlay's Main Menu tab's "Reset Position" button - same enqueue-only
|
||||
// reasoning as above.
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestResetPosition(JNIEnv *env, jclass clazz) {
|
||||
qs_config_request_reset_position();
|
||||
}
|
||||
|
||||
// MenuOverlay's Video Options tab - "Initial Screen"/"Game Screen" width/
|
||||
// distance preset rows, same enqueue-only reasoning as above.
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestSetInitialScreenWidth(JNIEnv *env, jclass clazz,
|
||||
jint presetIndex) {
|
||||
qs_config_request_set_initial_screen_width(presetIndex);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestSetGameScreenWidth(JNIEnv *env, jclass clazz,
|
||||
jint presetIndex) {
|
||||
qs_config_request_set_game_screen_width(presetIndex);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestSetInitialScreenDistance(JNIEnv *env,
|
||||
jclass clazz,
|
||||
jint presetIndex) {
|
||||
qs_config_request_set_initial_screen_distance(presetIndex);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestSetGameScreenDistance(JNIEnv *env, jclass clazz,
|
||||
jint presetIndex) {
|
||||
qs_config_request_set_game_screen_distance(presetIndex);
|
||||
}
|
||||
|
||||
// Read-only queries - safe to call directly (no enqueue needed, see
|
||||
// qs_config.h's own comment on each of these).
|
||||
JNIEXPORT jboolean JNICALL
|
||||
@@ -130,6 +172,42 @@ Java_de_ladkau_questshock_MenuOverlay_nativeGetResolutionIndex(JNIEnv *env, jcla
|
||||
return qs_config_current_resolution_index();
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetInitialScreenWidthIndex(JNIEnv *env, jclass clazz) {
|
||||
return qs_config_current_initial_screen_width_index();
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetGameScreenWidthIndex(JNIEnv *env, jclass clazz) {
|
||||
return qs_config_current_game_screen_width_index();
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetInitialScreenDistanceIndex(JNIEnv *env,
|
||||
jclass clazz) {
|
||||
return qs_config_current_initial_screen_distance_index();
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetGameScreenDistanceIndex(JNIEnv *env, jclass clazz) {
|
||||
return qs_config_current_game_screen_distance_index();
|
||||
}
|
||||
|
||||
// Preset button *labels* (not the current value) - shared by both
|
||||
// "Initial Screen" and "Game Screen" columns, since their offset/step is
|
||||
// config-file-only, not per-profile (see qs_config.h's own comment).
|
||||
JNIEXPORT jfloat JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetScreenWidthPresetValue(JNIEnv *env, jclass clazz,
|
||||
jint index) {
|
||||
return qs_config_screen_width_preset_value(index);
|
||||
}
|
||||
|
||||
JNIEXPORT jfloat JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetScreenDistancePresetValue(JNIEnv *env, jclass clazz,
|
||||
jint index) {
|
||||
return qs_config_screen_distance_preset_value(index);
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetLanguage(JNIEnv *env, jclass clazz) {
|
||||
return qs_config_current_language();
|
||||
@@ -156,3 +234,55 @@ JNIEXPORT jfloat JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetGpuUtilization(JNIEnv *env, jclass clazz) {
|
||||
return xr_session_get_gpu_utilization();
|
||||
}
|
||||
|
||||
// Controller Options tab: actionIndex follows xr_input.c's action order
|
||||
// (MenuOverlay.java and Strings.java hold the matching labels).
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestBeginControlCapture(JNIEnv *env, jclass clazz,
|
||||
jint actionIndex) {
|
||||
qs_config_request_begin_control_capture(actionIndex);
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestCancelControlCapture(JNIEnv *env, jclass clazz) {
|
||||
qs_config_request_cancel_control_capture();
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestResetPlayerControls(JNIEnv *env, jclass clazz) {
|
||||
qs_config_request_reset_player_controls();
|
||||
}
|
||||
|
||||
JNIEXPORT jstring JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetControlBindingKey(JNIEnv *env, jclass clazz,
|
||||
jint actionIndex) {
|
||||
return (*env)->NewStringUTF(env, xr_input_get_action_binding_name(actionIndex));
|
||||
}
|
||||
|
||||
JNIEXPORT jstring JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetActiveInteractionProfilePath(JNIEnv *env,
|
||||
jclass clazz) {
|
||||
return (*env)->NewStringUTF(env, xr_input_get_active_interaction_profile_path());
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeSetControllerOptionsTabOpen(JNIEnv *env, jclass clazz,
|
||||
jboolean open) {
|
||||
xr_input_set_controller_options_tab_open(open == JNI_TRUE);
|
||||
}
|
||||
|
||||
// Cheats tab: same enqueue-only pattern as the other requests.
|
||||
JNIEXPORT void JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeRequestCheat(JNIEnv *env, jclass clazz, jint cheatId) {
|
||||
qs_config_request_cheat(cheatId);
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetCheatUnlimitedMask(JNIEnv *env, jclass clazz) {
|
||||
return qs_config_cheat_unlimited_mask();
|
||||
}
|
||||
|
||||
JNIEXPORT jboolean JNICALL
|
||||
Java_de_ladkau_questshock_MenuOverlay_nativeGetCheatPhysicsRunning(JNIEnv *env, jclass clazz) {
|
||||
return qs_config_cheat_physics_running();
|
||||
}
|
||||
|
||||
+1730
-180
File diff suppressed because it is too large
Load Diff
@@ -66,6 +66,85 @@ void xr_input_sync_and_draw(XrSpace baseSpace, XrTime time, bool draw);
|
||||
// frame.
|
||||
bool xr_input_get_beam_layer(int hand, XrCompositionLayerQuad *out_quad);
|
||||
|
||||
// Recenters the player so the game quad ("virtual screen") appears directly
|
||||
// ahead of wherever they are standing and facing, from their current real head
|
||||
// pose. Never reads or writes questshock.config.json. Called automatically
|
||||
// once, from xr_input_sync_and_draw(), on the first frame with a valid head
|
||||
// pose after startup, unless a complete saved player_position was loaded (see
|
||||
// xr_input_skip_startup_recenter()): a saved position is relative to a
|
||||
// previous session's real-space origin, which is not stable across launches.
|
||||
// Returns false (no-op) if no valid head pose is available yet.
|
||||
bool xr_input_recenter_player_to_screen(void);
|
||||
|
||||
// The Main Menu tab's "Reset Position" button (via qs_config.c). Like
|
||||
// xr_input_recenter_player_to_screen(), but re-anchors only the player's
|
||||
// position to the centre in front of the game quad; the current facing (yaw)
|
||||
// is kept, so the screen does not rotate to follow the gaze. Returns false
|
||||
// (no-op) if no valid head pose is available yet.
|
||||
bool xr_input_reset_player_position(void);
|
||||
|
||||
// Called once, from qs_config_load_startup() (qs_config.c), when a
|
||||
// complete saved player_position was actually loaded from
|
||||
// questshock.config.json - cancels the pending automatic startup recenter
|
||||
// above so it doesn't immediately override the value that was just
|
||||
// applied. Safe to call regardless of whether xr_input_init() has even run
|
||||
// yet (this only touches the plain file-local flag, no XR calls).
|
||||
void xr_input_skip_startup_recenter(void);
|
||||
|
||||
// ===========================================================================
|
||||
// Remappable controls ("player_controls" config group; see qs_config.c and
|
||||
// CONFIG.md). menu_toggle is not among them and has no getter/setter: it is
|
||||
// fixed (see xr_input_sync_and_draw()).
|
||||
// ===========================================================================
|
||||
|
||||
// Number of remappable actions and each one's index<->name mapping, which
|
||||
// qs_config.c uses to parse/write the player_controls group without its own
|
||||
// copy of the list. The names are the keys used in questshock.config.json;
|
||||
// index_from_name() returns false for an unrecognized name.
|
||||
int xr_input_action_count(void);
|
||||
const char *xr_input_action_name(int action_index);
|
||||
bool xr_input_action_index_from_name(const char *name, int *out_index);
|
||||
|
||||
// Current binding for one action, as an opaque int and as its string form
|
||||
// (e.g. "right_b", "trigger", "none" for unbound), the same strings used in
|
||||
// questshock.config.json and reported by capture.
|
||||
int xr_input_get_action_binding(int action_index);
|
||||
const char *xr_input_get_action_binding_name(int action_index);
|
||||
|
||||
// Sets one action's binding from a config-file string. Returns false (binding
|
||||
// unchanged) for an unrecognized name, or for the symmetric "trigger"/
|
||||
// "squeeze" on an action other than mouse_click/mouse_double_click. Does not
|
||||
// enforce one-action-per-input the way capture does: a hand-edited file that
|
||||
// binds two actions to one input is accepted as-is.
|
||||
bool xr_input_set_action_binding(int action_index, const char *raw_name);
|
||||
|
||||
// Restores every action to its built-in default (the table xr_input_init()
|
||||
// starts from). qs_config.c calls this first for "Reset to Defaults", then
|
||||
// applies questshock.config.default.json's player_controls group on top if it
|
||||
// has one.
|
||||
void xr_input_reset_player_controls(void);
|
||||
|
||||
// Begins/cancels rebind capture for one action (an index into
|
||||
// xr_input_action_name()'s list): the next fresh button or thumbstick-direction
|
||||
// edge on any hand becomes that action's binding and is reported via
|
||||
// qs_config_notify_control_capture_result(); with no press, capture cancels
|
||||
// after 8 seconds. Called via qs_config.c's cross-thread request functions.
|
||||
// The menu button is never captured.
|
||||
void xr_input_capture_begin(int action_index);
|
||||
void xr_input_capture_cancel(void);
|
||||
|
||||
// The OpenXR interaction profile currently bound (e.g.
|
||||
// "/interaction_profiles/oculus/touch_controller"), refreshed once per frame.
|
||||
// MenuOverlay.java's Controller Options tab uses it to pick a file from
|
||||
// controller_profiles/ (see CONFIG.md). Empty until the first successful
|
||||
// query.
|
||||
const char *xr_input_get_active_interaction_profile_path(void);
|
||||
|
||||
// Set by MenuOverlay.java when the Controller Options tab becomes or stops
|
||||
// being the menu's current tab. While it is open, the menu's thumbstick
|
||||
// locomotion (snap turn/smooth move) is disabled.
|
||||
void xr_input_set_controller_options_tab_open(bool open);
|
||||
|
||||
void xr_input_shutdown(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#include "xr_overlay.h"
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -18,11 +19,33 @@
|
||||
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
|
||||
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
|
||||
|
||||
// Same constant (deliberately not <math.h>'s M_PI, which isn't used
|
||||
// anywhere else in this codebase and isn't guaranteed by the C standard -
|
||||
// only POSIX) as xr_session.c's own play-space rebuild math.
|
||||
#define QS_DEG_TO_RAD (3.14159265358979323846f / 180.0f)
|
||||
|
||||
struct XrOverlay {
|
||||
XrInstance instance; // for error logging only
|
||||
int width, height;
|
||||
float distance_m, half_width_m, half_height_m;
|
||||
float center_x_m, center_y_m;
|
||||
// The *authored* distance_m (config->distance_m at creation time),
|
||||
// never touched again afterward by anything, including
|
||||
// xr_overlay_set_pose() - kept separate from the live, mutable
|
||||
// distance_m above because that one stops meaning "how far in front of
|
||||
// the origin" once a rotated set_pose() call (the menu recenter)
|
||||
// repurposes it as a raw base-space Z coordinate; reusing *that* as a
|
||||
// "how far in front of me" magnitude on a later recenter would drift
|
||||
// further with every reopen instead of staying at a stable distance -
|
||||
// see xr_overlay_get_default_distance_m().
|
||||
float default_distance_m;
|
||||
// Rotation about the vertical axis, applied on top of center_x_m/
|
||||
// center_y_m/distance_m (see xr_overlay_set_pose()) - 0 for every
|
||||
// overlay except the menu launcher immediately after it's freshly
|
||||
// reopened (xr_input.c re-centers it in front of wherever the player
|
||||
// is currently facing, which needs this to keep the quad actually
|
||||
// facing them instead of whatever direction it started out at).
|
||||
float yaw_deg;
|
||||
bool visible;
|
||||
|
||||
XrSwapchainState swapchain;
|
||||
@@ -205,6 +228,7 @@ XrOverlay *xr_overlay_create(XrInstance instance, XrSession session, int64_t swa
|
||||
overlay->width = config->width;
|
||||
overlay->height = config->height;
|
||||
overlay->distance_m = config->distance_m;
|
||||
overlay->default_distance_m = config->distance_m;
|
||||
overlay->half_width_m = config->width_m * 0.5f;
|
||||
overlay->half_height_m = config->width_m * 0.5f * (float)config->height / (float)config->width;
|
||||
overlay->center_x_m = config->default_center_x_m;
|
||||
@@ -281,9 +305,10 @@ void xr_overlay_set_visible(XrOverlay *overlay, bool visible) {
|
||||
bool xr_overlay_is_visible(const XrOverlay *overlay) { return overlay != NULL && overlay->visible; }
|
||||
|
||||
void xr_overlay_get_quad_extent(const XrOverlay *overlay, float *center_x_m, float *center_y_m,
|
||||
float *distance_m, float *half_width_m, float *half_height_m) {
|
||||
float *distance_m, float *half_width_m, float *half_height_m,
|
||||
float *yaw_deg) {
|
||||
if (overlay == NULL) {
|
||||
*center_x_m = *center_y_m = *distance_m = *half_width_m = *half_height_m = 0.0f;
|
||||
*center_x_m = *center_y_m = *distance_m = *half_width_m = *half_height_m = *yaw_deg = 0.0f;
|
||||
return;
|
||||
}
|
||||
*center_x_m = overlay->center_x_m;
|
||||
@@ -291,6 +316,7 @@ void xr_overlay_get_quad_extent(const XrOverlay *overlay, float *center_x_m, flo
|
||||
*distance_m = overlay->distance_m;
|
||||
*half_width_m = overlay->half_width_m;
|
||||
*half_height_m = overlay->half_height_m;
|
||||
*yaw_deg = overlay->yaw_deg;
|
||||
}
|
||||
|
||||
void xr_overlay_set_position(XrOverlay *overlay, float center_x_m, float center_y_m) {
|
||||
@@ -300,6 +326,20 @@ void xr_overlay_set_position(XrOverlay *overlay, float center_x_m, float center_
|
||||
overlay->center_y_m = center_y_m;
|
||||
}
|
||||
|
||||
void xr_overlay_set_pose(XrOverlay *overlay, float center_x_m, float center_y_m, float distance_m,
|
||||
float yaw_deg) {
|
||||
if (overlay == NULL)
|
||||
return;
|
||||
overlay->center_x_m = center_x_m;
|
||||
overlay->center_y_m = center_y_m;
|
||||
overlay->distance_m = distance_m;
|
||||
overlay->yaw_deg = yaw_deg;
|
||||
}
|
||||
|
||||
float xr_overlay_get_default_distance_m(const XrOverlay *overlay) {
|
||||
return overlay == NULL ? 0.0f : overlay->default_distance_m;
|
||||
}
|
||||
|
||||
void xr_overlay_touch(XrOverlay *overlay, float u, float v, bool down) {
|
||||
if (overlay == NULL)
|
||||
return;
|
||||
@@ -443,7 +483,17 @@ bool xr_overlay_render_and_build_layer(XrOverlay *overlay, XrCompositionLayerQua
|
||||
out_quad->subImage.swapchain = overlay->swapchain.swapchain;
|
||||
out_quad->subImage.imageRect.extent.width = overlay->swapchain.width;
|
||||
out_quad->subImage.imageRect.extent.height = overlay->swapchain.height;
|
||||
out_quad->pose.orientation.w = 1.0f;
|
||||
// Rotation about the vertical axis only (see the struct field's own
|
||||
// comment) - same R_y(-yaw_deg) quaternion construction as
|
||||
// xr_session.c's own play-space rebuild, for the same reason: this
|
||||
// quad's pose is expressed as "yaw_deg turned from its own local -Z",
|
||||
// so a point/ray in that rotated frame maps back into the (unrotated)
|
||||
// base space by rotating by -yaw_deg.
|
||||
float half = -(overlay->yaw_deg * QS_DEG_TO_RAD) * 0.5f;
|
||||
out_quad->pose.orientation.x = 0.0f;
|
||||
out_quad->pose.orientation.y = sinf(half);
|
||||
out_quad->pose.orientation.z = 0.0f;
|
||||
out_quad->pose.orientation.w = cosf(half);
|
||||
out_quad->pose.position.x = overlay->center_x_m;
|
||||
out_quad->pose.position.y = overlay->center_y_m;
|
||||
out_quad->pose.position.z = -overlay->distance_m;
|
||||
|
||||
@@ -58,18 +58,39 @@ void xr_overlay_toggle_visible(XrOverlay *overlay);
|
||||
void xr_overlay_set_visible(XrOverlay *overlay, bool visible);
|
||||
bool xr_overlay_is_visible(const XrOverlay *overlay);
|
||||
|
||||
// Local-space pose/size of the quad, valid regardless of visibility -
|
||||
// shared with xr_input.c's ray/quad hit-testing.
|
||||
// Base-space pose/size of the quad, valid regardless of visibility - shared
|
||||
// with xr_input.c's ray/quad hit-testing. yaw_deg is rotation about the
|
||||
// vertical axis (see xr_overlay_set_pose()) - 0 unless something has
|
||||
// called that.
|
||||
void xr_overlay_get_quad_extent(const XrOverlay *overlay, float *center_x_m, float *center_y_m,
|
||||
float *distance_m, float *half_width_m, float *half_height_m);
|
||||
float *distance_m, float *half_width_m, float *half_height_m,
|
||||
float *yaw_deg);
|
||||
|
||||
// Repositions the quad (world-space X/Y offset, same units/space as
|
||||
// Repositions the quad (base-space X/Y offset, same units/space as
|
||||
// xr_overlay_get_quad_extent()'s center_x_m/center_y_m) - e.g. driven by
|
||||
// xr_input.c while the user drags a panel's title bar. Distance from the
|
||||
// viewer isn't adjustable this way - only left/right/up/down
|
||||
// repositioning, not push/pull.
|
||||
// viewer and rotation aren't adjustable this way - only left/right/up/down
|
||||
// repositioning, not push/pull or turning - see xr_overlay_set_pose() for
|
||||
// that.
|
||||
void xr_overlay_set_position(XrOverlay *overlay, float center_x_m, float center_y_m);
|
||||
|
||||
// Full reposition: X/Y offset, distance ("push/pull"), and rotation about
|
||||
// the vertical axis (degrees, same sign convention as
|
||||
// xr_session_set_player_transform()'s yaw_deg) - used by xr_input.c to
|
||||
// re-center the menu launcher in front of wherever the player currently
|
||||
// is/facing each time it's freshly reopened, unlike
|
||||
// xr_overlay_set_position()'s drag-only X/Y-at-fixed-distance-and-facing.
|
||||
void xr_overlay_set_pose(XrOverlay *overlay, float center_x_m, float center_y_m, float distance_m,
|
||||
float yaw_deg);
|
||||
|
||||
// The overlay's original, never-mutated distance_m (from XrOverlayConfig at
|
||||
// creation time) - unlike xr_overlay_get_quad_extent()'s live distance_m,
|
||||
// which xr_overlay_set_pose() repurposes as a raw base-space Z coordinate
|
||||
// once any rotation is involved (see xr_overlay_set_pose()'s own comment),
|
||||
// this stays a stable "how far in front" magnitude across repeated
|
||||
// recenters. 0 for a NULL overlay.
|
||||
float xr_overlay_get_default_distance_m(const XrOverlay *overlay);
|
||||
|
||||
// Forwards a hit on the quad (in the quad's own 0..1 u/v, top-left origin)
|
||||
// to the backing Java view as a synthetic touch down/up.
|
||||
void xr_overlay_touch(XrOverlay *overlay, float u, float v, bool down);
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#include "xr_session.h"
|
||||
|
||||
#include <ctype.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -25,14 +26,18 @@
|
||||
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
|
||||
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
|
||||
|
||||
// Fixed pose/size for the single game quad - 2m in front of the local space
|
||||
// origin, sized to preserve the game's own aspect ratio at a comfortable
|
||||
// visual angle. No per-eye view/projection work is needed for a quad layer
|
||||
// at all - the compositor handles reprojecting it per eye itself, which is
|
||||
// exactly why this milestone doesn't need xrLocateViews or any stereo
|
||||
// rendering (see the plan's step A notes).
|
||||
// Original, pre-screen-profile-feature default distance for the game
|
||||
// screen - 2m in front of the local space origin - now just the initial
|
||||
// value of g_screen_distance_m (below) rather than a fixed constant.
|
||||
// Width/curve/distance are all configurable (see g_screen_width_m/
|
||||
// g_screen_curve_deg/g_screen_distance_m above and CONFIG.md's Video
|
||||
// Options "Initial Screen"/"Game Screen" settings), sized to preserve the
|
||||
// game's own pixel aspect ratio at whatever physical width is currently
|
||||
// configured. No per-eye view/projection work is needed for a quad/
|
||||
// cylinder layer at all - the compositor handles reprojecting it per eye
|
||||
// itself, which is exactly why this milestone doesn't need xrLocateViews
|
||||
// or any stereo rendering (see the plan's step A notes).
|
||||
#define QUAD_DISTANCE_METERS 2.0f
|
||||
#define QUAD_WIDTH_METERS 1.6f
|
||||
|
||||
// The menu launcher (just a "Keyboard" button - see MenuOverlay.java) is
|
||||
// small and sits above where the keyboard defaults to; the keyboard keeps
|
||||
@@ -40,16 +45,22 @@
|
||||
// xr_overlay.h) so both can be shown/hidden/dragged separately - deliberately
|
||||
// positioned apart by default so they don't start out overlapping.
|
||||
#define MENU_JAVA_CLASS "de.ladkau.questshock.MenuOverlay"
|
||||
// 768x552 (was 512x256, then 768x512) - grown to fit the header/tabs/Video
|
||||
// Options content added on top of the original single "Keyboard" button,
|
||||
// then again to fit the stats ribbon below the tab bar; taller in world
|
||||
// space too since MENU_WIDTH_METERS (the physical size) stays fixed and
|
||||
// height_m is derived from it by aspect ratio (see xr_overlay.c's
|
||||
// xr_overlay_init()).
|
||||
// 768x800 (was 512x256, then 768x512, then 768x552) - grown to fit the
|
||||
// header/tabs/Video Options content added on top of the original single
|
||||
// "Keyboard" button, then again to fit the stats ribbon below the tab
|
||||
// bar, then again to fit the Video Options tab's screen-size grid; taller
|
||||
// in world space too since MENU_WIDTH_METERS (the physical size) stays
|
||||
// fixed and height_m is derived from it by aspect ratio (see
|
||||
// xr_overlay.c's xr_overlay_init()). Must match MenuOverlay.java's own
|
||||
// WIDTH/HEIGHT, and xr_input.c's MENU_TITLE_BAR_V_FRACTION denominator.
|
||||
#define MENU_WIDTH 768
|
||||
#define MENU_HEIGHT 552
|
||||
#define MENU_HEIGHT 800
|
||||
#define MENU_DISTANCE_METERS 1.3f
|
||||
#define MENU_WIDTH_METERS 0.35f
|
||||
// Physical size - was 0.35m, too small to read comfortably at
|
||||
// MENU_DISTANCE_METERS given how much text the header/tabs/stats ribbon
|
||||
// pack in; same pixel resolution (MENU_WIDTH/HEIGHT above) just displayed
|
||||
// bigger, not a layout change.
|
||||
#define MENU_WIDTH_METERS 0.5f
|
||||
#define MENU_DEFAULT_CENTER_X_METERS 0.0f
|
||||
#define MENU_DEFAULT_CENTER_Y_METERS 0.15f
|
||||
|
||||
@@ -65,6 +76,26 @@ static XrInstance g_instance = XR_NULL_HANDLE;
|
||||
static XrSystemId g_system_id = XR_NULL_SYSTEM_ID;
|
||||
static XrSession g_session = XR_NULL_HANDLE;
|
||||
static XrSpace g_local_space = XR_NULL_HANDLE;
|
||||
|
||||
// Everything this app submits/locates (game/menu/keyboard/beam quads, hand
|
||||
// and head poses) is expressed relative to g_play_space, not g_local_space
|
||||
// directly - it's g_local_space translated/rotated by the inverse of the
|
||||
// player's own virtual transform (see xr_session_set_player_transform()'s
|
||||
// own comment in xr_session.h and xr_session_rebuild_play_space() below),
|
||||
// so moving/turning the player moves/turns everything else relative to
|
||||
// them without touching any actual pose-building or hit-testing math
|
||||
// elsewhere in the app - it's all still "relative to the base space",
|
||||
// which just happens to no longer be g_local_space itself.
|
||||
static XrSpace g_play_space = XR_NULL_HANDLE;
|
||||
static float g_player_x = 0.0f;
|
||||
static float g_player_z = 0.0f;
|
||||
static float g_player_yaw_deg = 0.0f;
|
||||
// Set by xr_session_set_player_transform() (including before xr_init() has
|
||||
// even run - see its own comment), cleared once xr_session_rebuild_play_space()
|
||||
// actually rebuilds g_play_space from the current x/z/yaw_deg - checked
|
||||
// once per frame in xr_frame_end() so a stick held at rest costs nothing.
|
||||
static bool g_player_transform_dirty = false;
|
||||
|
||||
static XrSessionState g_session_state = XR_SESSION_STATE_UNKNOWN;
|
||||
// Distinct from g_session_state - true from a successful xrBeginSession
|
||||
// until xrEndSession/loss/exit. Many runtimes only advance the *state*
|
||||
@@ -102,6 +133,24 @@ static PFN_xrQueryPerformanceMetricsCounterMETA g_xrQueryPerformanceMetricsCount
|
||||
static XrPath g_cpu_utilization_path = XR_NULL_PATH;
|
||||
static XrPath g_gpu_utilization_path = XR_NULL_PATH;
|
||||
|
||||
// XR_KHR_composition_layer_cylinder support - same "only if the runtime
|
||||
// advertised it" reasoning as g_performance_metrics_supported above. If
|
||||
// unsupported, the curve is forced to 0 (flat) everywhere regardless of
|
||||
// configuration (see xr_get_game_quad_extent()) so the game screen just
|
||||
// silently stays flat instead of failing to submit a layer at all.
|
||||
static bool g_cylinder_layer_supported = false;
|
||||
|
||||
// The game screen's currently-configured shape (see qs_config.c's
|
||||
// qs_screen_profile_notify_loop_mode(), which is what actually calls
|
||||
// xr_session_set_game_screen_shape() below - this file has no notion of
|
||||
// "which profile" is active, only "what shape is current"). Defaults
|
||||
// match the game quad's own original, pre-this-feature hardcoded width
|
||||
// (1.6m) and lack of curve, so a build that never touches the new config
|
||||
// options renders identically to before.
|
||||
static float g_screen_width_m = 1.6f;
|
||||
static float g_screen_curve_deg = 0.0f;
|
||||
static float g_screen_distance_m = QUAD_DISTANCE_METERS;
|
||||
|
||||
static bool xr_check(XrResult result, const char *what) {
|
||||
if (XR_SUCCEEDED(result))
|
||||
return true;
|
||||
@@ -256,6 +305,65 @@ static EGLConfig xr_get_current_egl_config(EGLDisplay display, EGLContext contex
|
||||
return config;
|
||||
}
|
||||
|
||||
#define QS_DEG_TO_RAD (3.14159265358979323846f / 180.0f)
|
||||
|
||||
// Destroys/recreates g_play_space from g_local_space, offset by the
|
||||
// inverse of the player's current virtual transform (g_player_x/z/yaw_deg) -
|
||||
// see xr_session_set_player_transform()'s comment in xr_session.h for why
|
||||
// this is the inverse rather than the transform itself. Given
|
||||
// V = Translate(x, 0, z) * Rotate_Y(yaw_deg) (the player's own transform,
|
||||
// "apparent pose in play space = V composed with real pose in local
|
||||
// space"), the new space's poseInReferenceSpace must be V's inverse:
|
||||
// orientation = Rotate_Y(-yaw_deg), position = Rotate_Y(-yaw_deg) * (-x, 0, -z).
|
||||
// Called once, right after g_local_space itself is created (picking up
|
||||
// whatever qs_config_load_startup() already seeded before xr_init() ever
|
||||
// ran), and once per frame from xr_frame_end() whenever
|
||||
// g_player_transform_dirty says the transform actually changed since the
|
||||
// last rebuild - a plain stick-at-rest frame costs nothing beyond that one
|
||||
// bool check. g_session must already exist.
|
||||
static void xr_session_rebuild_play_space(void) {
|
||||
if (g_play_space != XR_NULL_HANDLE) {
|
||||
xrDestroySpace(g_play_space);
|
||||
g_play_space = XR_NULL_HANDLE;
|
||||
}
|
||||
|
||||
float theta = g_player_yaw_deg * QS_DEG_TO_RAD;
|
||||
float half = -theta * 0.5f;
|
||||
float c = cosf(-theta), s = sinf(-theta);
|
||||
float vx = -g_player_x, vz = -g_player_z;
|
||||
|
||||
XrReferenceSpaceCreateInfo spaceInfo = {XR_TYPE_REFERENCE_SPACE_CREATE_INFO};
|
||||
spaceInfo.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
|
||||
spaceInfo.poseInReferenceSpace.orientation.x = 0.0f;
|
||||
spaceInfo.poseInReferenceSpace.orientation.y = sinf(half);
|
||||
spaceInfo.poseInReferenceSpace.orientation.z = 0.0f;
|
||||
spaceInfo.poseInReferenceSpace.orientation.w = cosf(half);
|
||||
spaceInfo.poseInReferenceSpace.position.x = vx * c + vz * s;
|
||||
spaceInfo.poseInReferenceSpace.position.y = 0.0f;
|
||||
spaceInfo.poseInReferenceSpace.position.z = -vx * s + vz * c;
|
||||
xr_check(xrCreateReferenceSpace(g_session, &spaceInfo, &g_play_space),
|
||||
"xrCreateReferenceSpace(play)");
|
||||
|
||||
g_player_transform_dirty = false;
|
||||
}
|
||||
|
||||
void xr_session_set_player_transform(float x, float z, float yaw_deg) {
|
||||
g_player_x = x;
|
||||
g_player_z = z;
|
||||
g_player_yaw_deg = yaw_deg;
|
||||
g_player_transform_dirty = true;
|
||||
}
|
||||
|
||||
void xr_session_get_player_transform(float *x, float *z, float *yaw_deg) {
|
||||
*x = g_player_x;
|
||||
*z = g_player_z;
|
||||
*yaw_deg = g_player_yaw_deg;
|
||||
}
|
||||
|
||||
XrSpace xr_session_get_local_space(void) { return g_local_space; }
|
||||
|
||||
XrTime xr_session_get_predicted_display_time(void) { return g_predicted_display_time; }
|
||||
|
||||
static bool xr_create_instance_and_session(int game_width, int game_height) {
|
||||
JNIEnv *env = (JNIEnv *)SDL_AndroidGetJNIEnv();
|
||||
jobject activity = (jobject)SDL_AndroidGetActivity();
|
||||
@@ -271,12 +379,24 @@ static bool xr_create_instance_and_session(int game_width, int game_height) {
|
||||
|
||||
g_performance_metrics_supported =
|
||||
xr_instance_extension_supported(XR_META_PERFORMANCE_METRICS_EXTENSION_NAME);
|
||||
g_cylinder_layer_supported =
|
||||
xr_instance_extension_supported(XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME);
|
||||
|
||||
const char *extensions[3] = {
|
||||
// The two KHR extensions here are always required; the other two are
|
||||
// each independently optional device capabilities (see
|
||||
// g_performance_metrics_supported/g_cylinder_layer_supported's own
|
||||
// comments) - appended only if actually advertised, since listing an
|
||||
// unsupported extension fails xrCreateInstance entirely, not just that
|
||||
// one feature.
|
||||
const char *extensions[4] = {
|
||||
XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME,
|
||||
XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME,
|
||||
XR_META_PERFORMANCE_METRICS_EXTENSION_NAME,
|
||||
};
|
||||
uint32_t extensionCount = 2;
|
||||
if (g_performance_metrics_supported)
|
||||
extensions[extensionCount++] = XR_META_PERFORMANCE_METRICS_EXTENSION_NAME;
|
||||
if (g_cylinder_layer_supported)
|
||||
extensions[extensionCount++] = XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME;
|
||||
|
||||
XrInstanceCreateInfoAndroidKHR androidInfo = {XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR};
|
||||
androidInfo.applicationVM = vm;
|
||||
@@ -284,7 +404,7 @@ static bool xr_create_instance_and_session(int game_width, int game_height) {
|
||||
|
||||
XrInstanceCreateInfo createInfo = {XR_TYPE_INSTANCE_CREATE_INFO};
|
||||
createInfo.next = &androidInfo;
|
||||
createInfo.enabledExtensionCount = g_performance_metrics_supported ? 3 : 2;
|
||||
createInfo.enabledExtensionCount = extensionCount;
|
||||
createInfo.enabledExtensionNames = extensions;
|
||||
strncpy(createInfo.applicationInfo.applicationName, "QuestShock",
|
||||
XR_MAX_APPLICATION_NAME_SIZE - 1);
|
||||
@@ -342,6 +462,14 @@ static bool xr_create_instance_and_session(int game_width, int game_height) {
|
||||
"xrCreateReferenceSpace"))
|
||||
return false;
|
||||
|
||||
// Picks up whatever qs_config_load_startup() already stored into
|
||||
// g_player_x/z/yaw_deg via xr_session_set_player_transform() before
|
||||
// this function ever ran (that call is pure state, no XR API calls, so
|
||||
// it works fine even this early) - so a saved position is already in
|
||||
// effect from the very first frame, not just after the player first
|
||||
// moves a thumbstick.
|
||||
xr_session_rebuild_play_space();
|
||||
|
||||
// Prefer a plain linear 8-bit format over GL_SRGB8_ALPHA8: the source
|
||||
// SDL surface pixels are already sRGB-encoded (as ordinary 8-bit image
|
||||
// data conventionally is) and get uploaded/sampled as plain linear
|
||||
@@ -546,6 +674,14 @@ void xr_frame_end(void) {
|
||||
if (g_session == XR_NULL_HANDLE)
|
||||
return;
|
||||
|
||||
// Rebuilt before xr_input_sync_and_draw() below so this same frame's
|
||||
// hit-testing and layer submission both see whatever the player's
|
||||
// thumbstick input (or a config-driven "Reset Position"/Load
|
||||
// Configuration) changed last frame - a no-op check on every frame
|
||||
// nothing moved.
|
||||
if (g_player_transform_dirty)
|
||||
xr_session_rebuild_play_space();
|
||||
|
||||
// Syncs actions and hit-tests/dispatches each hand's ray against
|
||||
// keyboard/menu/game quad (see xr_input.c) before the game swapchain
|
||||
// image is released below - this always runs, even when there's
|
||||
@@ -554,7 +690,7 @@ void xr_frame_end(void) {
|
||||
// laser-beam quads are submitted as their own composition layers
|
||||
// further down, not drawn into the game swapchain itself.
|
||||
if (xr_is_session_running())
|
||||
xr_input_sync_and_draw(g_local_space, g_predicted_display_time,
|
||||
xr_input_sync_and_draw(g_play_space, g_predicted_display_time,
|
||||
g_have_acquired_game_image);
|
||||
|
||||
if (g_have_acquired_game_image)
|
||||
@@ -563,34 +699,58 @@ void xr_frame_end(void) {
|
||||
if (!xr_is_session_running())
|
||||
return;
|
||||
|
||||
// Up to 5 layers: the game quad (if a frame was actually rendered),
|
||||
// the menu launcher and keyboard overlays while visible - each gets
|
||||
// its own acquire/render/release cycle against its own swapchain (see
|
||||
// xr_overlay_render_and_build_layer()) any time before xrEndFrame,
|
||||
// unlike the game quad there's no per-frame engine rendering to wrap
|
||||
// around here, just each overlay's own blit - and, per hand, a
|
||||
// laser-beam quad while that hand's ray is aimed at the keyboard,
|
||||
// menu, or the game quad itself (see xr_input_get_beam_layer()).
|
||||
// Up to 5 layers: the game screen (if a frame was actually rendered) -
|
||||
// a flat quad, or a curved cylinder if the currently-active screen
|
||||
// profile has a nonzero curve (see xr_get_game_quad_extent()'s own
|
||||
// comment; xr_input.c's xr_input_try_game_quad() hit-tests whichever
|
||||
// shape is actually submitted here, always agreeing since both read
|
||||
// the same getter) - the menu launcher and keyboard overlays while
|
||||
// visible - each gets its own acquire/render/release cycle against
|
||||
// its own swapchain (see xr_overlay_render_and_build_layer()) any
|
||||
// time before xrEndFrame, unlike the game screen there's no per-frame
|
||||
// engine rendering to wrap around here, just each overlay's own blit -
|
||||
// and, per hand, a laser-beam quad while that hand's ray is aimed at
|
||||
// the keyboard, menu, or the game screen itself (see
|
||||
// xr_input_get_beam_layer()).
|
||||
float gameDistance, gameHalfWidth, gameHalfHeight, gameRadius, gameCentralAngle;
|
||||
xr_get_game_quad_extent(&gameDistance, &gameHalfWidth, &gameHalfHeight, &gameRadius,
|
||||
&gameCentralAngle);
|
||||
bool gameScreenCurved = gameCentralAngle > 0.0f;
|
||||
|
||||
XrCompositionLayerQuad gameQuad = {XR_TYPE_COMPOSITION_LAYER_QUAD};
|
||||
gameQuad.space = g_local_space;
|
||||
XrCompositionLayerCylinderKHR gameCylinder = {XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR};
|
||||
if (gameScreenCurved) {
|
||||
gameCylinder.space = g_play_space;
|
||||
gameCylinder.eyeVisibility = XR_EYE_VISIBILITY_BOTH;
|
||||
gameCylinder.subImage.swapchain = g_game_swapchain.swapchain;
|
||||
gameCylinder.subImage.imageRect.extent.width = g_game_swapchain.width;
|
||||
gameCylinder.subImage.imageRect.extent.height = g_game_swapchain.height;
|
||||
gameCylinder.pose.orientation.w = 1.0f;
|
||||
gameCylinder.pose.position.z = -gameDistance;
|
||||
gameCylinder.radius = gameRadius;
|
||||
gameCylinder.centralAngle = gameCentralAngle;
|
||||
gameCylinder.aspectRatio = (float)g_game_swapchain.width / (float)g_game_swapchain.height;
|
||||
} else {
|
||||
gameQuad.space = g_play_space;
|
||||
gameQuad.eyeVisibility = XR_EYE_VISIBILITY_BOTH;
|
||||
gameQuad.subImage.swapchain = g_game_swapchain.swapchain;
|
||||
gameQuad.subImage.imageRect.extent.width = g_game_swapchain.width;
|
||||
gameQuad.subImage.imageRect.extent.height = g_game_swapchain.height;
|
||||
gameQuad.pose.orientation.w = 1.0f;
|
||||
gameQuad.pose.position.z = -QUAD_DISTANCE_METERS;
|
||||
gameQuad.size.width = QUAD_WIDTH_METERS;
|
||||
gameQuad.size.height =
|
||||
QUAD_WIDTH_METERS * (float)g_game_swapchain.height / (float)g_game_swapchain.width;
|
||||
gameQuad.pose.position.z = -gameDistance;
|
||||
gameQuad.size.width = gameHalfWidth * 2.0f;
|
||||
gameQuad.size.height = gameHalfHeight * 2.0f;
|
||||
}
|
||||
|
||||
const XrCompositionLayerBaseHeader *layers[5];
|
||||
uint32_t layerCount = 0;
|
||||
if (g_have_acquired_game_image)
|
||||
layers[layerCount++] = (XrCompositionLayerBaseHeader *)&gameQuad;
|
||||
layers[layerCount++] = gameScreenCurved ? (XrCompositionLayerBaseHeader *)&gameCylinder
|
||||
: (XrCompositionLayerBaseHeader *)&gameQuad;
|
||||
|
||||
XrCompositionLayerQuad menuQuad;
|
||||
if (g_frame_should_render && xr_overlay_render_and_build_layer(g_menu_overlay, &menuQuad)) {
|
||||
menuQuad.space = g_local_space;
|
||||
menuQuad.space = g_play_space;
|
||||
menuQuad.eyeVisibility = XR_EYE_VISIBILITY_BOTH;
|
||||
layers[layerCount++] = (XrCompositionLayerBaseHeader *)&menuQuad;
|
||||
}
|
||||
@@ -598,7 +758,7 @@ void xr_frame_end(void) {
|
||||
XrCompositionLayerQuad keyboardQuad;
|
||||
if (g_frame_should_render &&
|
||||
xr_overlay_render_and_build_layer(g_keyboard_overlay, &keyboardQuad)) {
|
||||
keyboardQuad.space = g_local_space;
|
||||
keyboardQuad.space = g_play_space;
|
||||
keyboardQuad.eyeVisibility = XR_EYE_VISIBILITY_BOTH;
|
||||
// Lets the keyboard sit on screen translucently while playing
|
||||
// rather than fully hiding whatever's behind it - KeyboardOverlay
|
||||
@@ -618,7 +778,7 @@ void xr_frame_end(void) {
|
||||
XrCompositionLayerQuad beamQuad[2];
|
||||
for (int hand = 0; hand < 2; hand++) {
|
||||
if (xr_input_get_beam_layer(hand, &beamQuad[hand])) {
|
||||
beamQuad[hand].space = g_local_space;
|
||||
beamQuad[hand].space = g_play_space;
|
||||
beamQuad[hand].eyeVisibility = XR_EYE_VISIBILITY_BOTH;
|
||||
beamQuad[hand].layerFlags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT;
|
||||
layers[layerCount++] = (XrCompositionLayerBaseHeader *)&beamQuad[hand];
|
||||
@@ -643,6 +803,10 @@ void xr_shutdown(void) {
|
||||
xrDestroySpace(g_local_space);
|
||||
g_local_space = XR_NULL_HANDLE;
|
||||
|
||||
if (g_play_space != XR_NULL_HANDLE)
|
||||
xrDestroySpace(g_play_space);
|
||||
g_play_space = XR_NULL_HANDLE;
|
||||
|
||||
// Before the session/instance they were created from.
|
||||
xr_input_shutdown();
|
||||
xr_overlay_destroy(g_menu_overlay);
|
||||
@@ -666,13 +830,45 @@ void xr_shutdown(void) {
|
||||
g_xrQueryPerformanceMetricsCounterMETA = NULL;
|
||||
g_cpu_utilization_path = XR_NULL_PATH;
|
||||
g_gpu_utilization_path = XR_NULL_PATH;
|
||||
|
||||
g_cylinder_layer_supported = false;
|
||||
// g_screen_width_m/g_screen_curve_deg/g_screen_distance_m deliberately
|
||||
// NOT reset here - same reasoning as xr_session_set_player_transform()'s
|
||||
// own state: it's meant to persist across a shutdown/reinit within the
|
||||
// same process (e.g. an Android lifecycle pause/resume), not just
|
||||
// within one XR session.
|
||||
}
|
||||
|
||||
void xr_get_game_quad_extent(float *distance_m, float *half_width_m, float *half_height_m) {
|
||||
*distance_m = QUAD_DISTANCE_METERS;
|
||||
*half_width_m = QUAD_WIDTH_METERS * 0.5f;
|
||||
*half_height_m =
|
||||
QUAD_WIDTH_METERS * 0.5f * (float)g_game_swapchain.height / (float)g_game_swapchain.width;
|
||||
void xr_session_set_game_screen_shape(float width_m, float curve_deg, float distance_m) {
|
||||
g_screen_width_m = width_m;
|
||||
g_screen_curve_deg = curve_deg;
|
||||
g_screen_distance_m = distance_m;
|
||||
}
|
||||
|
||||
// Single source of truth for the game screen's current shape, read by
|
||||
// both xr_frame_end() (to build/submit the actual layer) and
|
||||
// xr_input_try_game_quad() (xr_input.c, to hit-test the laser pointer
|
||||
// against it). half_width_m is meaningful only when *central_angle_rad is
|
||||
// 0 (flat); a curved screen's horizontal extent is bounded by
|
||||
// *central_angle_rad instead, with *half_height_m always the vertical
|
||||
// bound either way.
|
||||
void xr_get_game_quad_extent(float *distance_m, float *half_width_m, float *half_height_m,
|
||||
float *radius_m, float *central_angle_rad) {
|
||||
float curveDeg = g_cylinder_layer_supported ? g_screen_curve_deg : 0.0f;
|
||||
float aspect = (float)g_game_swapchain.height / (float)g_game_swapchain.width;
|
||||
|
||||
*distance_m = g_screen_distance_m;
|
||||
*half_width_m = g_screen_width_m * 0.5f;
|
||||
*half_height_m = g_screen_width_m * 0.5f * aspect;
|
||||
|
||||
if (curveDeg > 0.0f) {
|
||||
float theta = curveDeg * QS_DEG_TO_RAD;
|
||||
*central_angle_rad = theta;
|
||||
*radius_m = g_screen_width_m / theta;
|
||||
} else {
|
||||
*central_angle_rad = 0.0f;
|
||||
*radius_m = 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
void xr_get_game_resolution(int *width, int *height) {
|
||||
|
||||
@@ -62,17 +62,36 @@ bool xr_frame_begin(void);
|
||||
// launcher and keyboard overlay quads via xr_overlay_render_and_build_layer()
|
||||
// for whichever of them is currently visible, and submits whichever of the
|
||||
// three quads actually rendered this frame as composition layers
|
||||
// positioned in front of the local reference space's origin, then ends the
|
||||
// XR frame.
|
||||
// positioned in front of the play space's origin (see
|
||||
// xr_session_set_player_transform() above), then ends the XR frame.
|
||||
void xr_frame_end(void);
|
||||
|
||||
void xr_shutdown(void);
|
||||
|
||||
// Local-space geometry of the single game quad xr_frame_end() submits
|
||||
// (distance in front of the local space origin, half-width/half-height,
|
||||
// Play-space geometry of the single game screen xr_frame_end() submits
|
||||
// (distance in front of the play space origin, half-width/half-height,
|
||||
// all in meters) - shared with xr_input.c's ray/quad hit-testing so the
|
||||
// laser pointer always matches whatever's actually visible.
|
||||
void xr_get_game_quad_extent(float *distance_m, float *half_width_m, float *half_height_m);
|
||||
// laser pointer always matches whatever's actually visible. *radius_m/
|
||||
// *central_angle_rad are 0 when flat, in which case *half_width_m is the
|
||||
// horizontal extent; otherwise the screen is a curved cylinder segment
|
||||
// and the caller uses *central_angle_rad instead of *half_width_m for the
|
||||
// horizontal bound (*half_height_m stays meaningful either way). Curving
|
||||
// is currently unused - qs_config.c has no config surface for it - but
|
||||
// kept working so it can be re-enabled later.
|
||||
void xr_get_game_quad_extent(float *distance_m, float *half_width_m, float *half_height_m,
|
||||
float *radius_m, float *central_angle_rad);
|
||||
|
||||
// Sets the game screen's current physical width (meters) and curve (wrap
|
||||
// angle in degrees, 0 = flat) - a plain state setter, no XR calls, same
|
||||
// category as xr_session_set_player_transform() above (safe to call
|
||||
// before xr_init() has even run). Read by both xr_frame_end() (to build/
|
||||
// submit the actual layer) and, via xr_get_game_quad_extent() above,
|
||||
// xr_input.c's hit-testing. Driven by qs_config.c's
|
||||
// qs_screen_profile_notify_loop_mode(), which decides which of the
|
||||
// "Initial Screen"/"Game Screen" config profiles (see CONFIG.md) is
|
||||
// currently active - this function itself has no notion of "profiles",
|
||||
// only "what shape is current".
|
||||
void xr_session_set_game_screen_shape(float width_m, float curve_deg, float distance_m);
|
||||
|
||||
// The engine's current screen resolution (gScreenWide/gScreenHigh,
|
||||
// InitMac.h) - not the game quad's own swapchain size, which is fixed at
|
||||
@@ -98,6 +117,49 @@ float xr_session_get_frame_ms(void);
|
||||
float xr_session_get_cpu_utilization(void);
|
||||
float xr_session_get_gpu_utilization(void);
|
||||
|
||||
// The player's virtual position/orientation - horizontal-plane only (x/z
|
||||
// plus a yaw rotation about the vertical axis); height always comes from
|
||||
// the real tracked HMD pose, never from this. Everything the app submits
|
||||
// (game/menu/keyboard/beam quads) and every hand/head pose it locates is
|
||||
// expressed relative to a second reference space, derived from the real
|
||||
// LOCAL space by this transform's inverse (see xr_session.c's own
|
||||
// xr_session_rebuild_play_space()) - so changing it moves/turns the player
|
||||
// relative to those otherwise-fixed quads, letting them walk up to and
|
||||
// square up with the game quad ("virtual screen") without needing any
|
||||
// physical room-scale space to do it in.
|
||||
//
|
||||
// xr_session_set_player_transform() only stores the three floats (no XR
|
||||
// calls) - safe to call before xr_init() has even run, which is how
|
||||
// qs_config_load_startup() seeds the saved position before the OpenXR
|
||||
// session/spaces exist yet (xr_init() picks it up when it creates its own
|
||||
// spaces); also used live by xr_input.c's thumbstick locomotion and
|
||||
// "Reset Position" recenter (xr_input_recenter_player_to_screen()) and
|
||||
// qs_config.c's "Load Configuration", and read back by "Save Configuration"
|
||||
// via the getter.
|
||||
void xr_session_set_player_transform(float x, float z, float yaw_deg);
|
||||
void xr_session_get_player_transform(float *x, float *z, float *yaw_deg);
|
||||
|
||||
// The real, physical tracking-origin reference space - used only by
|
||||
// xr_input_recenter_player_to_screen() (xr_input.c), which needs the
|
||||
// player's CURRENT real head pose (not one already bent through the
|
||||
// existing play-space transform - see xr_session_set_player_transform()'s
|
||||
// own comment above) to compute a brand new one. Every other consumer in
|
||||
// this app (rendering, hit-testing) uses the play space instead - see
|
||||
// xr_session_rebuild_play_space()'s own comment for why this one stays a
|
||||
// separate, never-swapped-out space.
|
||||
XrSpace xr_session_get_local_space(void);
|
||||
|
||||
// The most recent xrWaitFrame-predicted display time (xr_frame_begin()'s
|
||||
// own g_predicted_display_time) - for the same reason as
|
||||
// xr_session_get_local_space() above, xr_input_recenter_player_to_screen()
|
||||
// needs a valid XrTime to locate a space with but isn't itself called from
|
||||
// the normal per-frame xr_frame_end()/xr_input_sync_and_draw() call chain
|
||||
// that already threads one through (it's triggered by a button press,
|
||||
// dispatched via qs_config.c's cross-thread event queue instead). A frame
|
||||
// or so of staleness doesn't matter for a one-shot recenter. 0 before the
|
||||
// first frame has ever begun.
|
||||
XrTime xr_session_get_predicted_display_time(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -271,7 +271,11 @@ abstract class OverlayPanel {
|
||||
// Absolute bounds of view within this panel's own coordinate space
|
||||
// (i.e. relative to root, which is always laid out at (0,0,width,
|
||||
// height) - see the constructor) - View's own getLeft()/getTop() are
|
||||
// parent-relative, so this walks up the parent chain summing them.
|
||||
// parent-relative, so this walks up the parent chain summing them,
|
||||
// additionally subtracting each ancestor's own getScrollX()/getScrollY()
|
||||
// (0 for a plain ViewGroup, non-zero for e.g. a ScrollView - see
|
||||
// MenuOverlay's Controller Options tab) so a view inside a scrolled
|
||||
// container reports its actual on-screen position, not its laid-out one.
|
||||
// Assumes view is actually part of this panel's tree (every registered
|
||||
// view always is, since registerHoverable() is only ever called from
|
||||
// buildContent()).
|
||||
@@ -285,7 +289,10 @@ abstract class OverlayPanel {
|
||||
if (current == root || !(current.getParent() instanceof View)) {
|
||||
break;
|
||||
}
|
||||
current = (View) current.getParent();
|
||||
View parent = (View) current.getParent();
|
||||
left -= parent.getScrollX();
|
||||
top -= parent.getScrollY();
|
||||
current = parent;
|
||||
}
|
||||
return new Rect(left, top, left + view.getWidth(), top + view.getHeight());
|
||||
}
|
||||
|
||||
@@ -39,7 +39,8 @@ import org.libsdl.app.SDLSurface;
|
||||
public class QuestShockActivity extends SDLActivity {
|
||||
private static final String TAG = "QuestShock";
|
||||
private static final int PERMISSION_REQUEST_STORAGE = 1;
|
||||
private static final String GAME_DIR = "/sdcard/questshock";
|
||||
// Package-visible: MenuOverlay reads controller_profiles/ from here.
|
||||
static final String GAME_DIR = "/sdcard/questshock";
|
||||
|
||||
// Loaded here (rather than waiting for SDLActivity's own
|
||||
// getLibraries()/loadLibraries(), which only runs from super.onCreate())
|
||||
@@ -143,11 +144,25 @@ public class QuestShockActivity extends SDLActivity {
|
||||
// is already there, assume a previous run already extracted everything.
|
||||
File marker = new File(gameDir, "GET_ASSETS_QUEST.txt");
|
||||
if (!marker.exists()) {
|
||||
copyAssetDir("shaders", new File(gameDir, "shaders"));
|
||||
copyAssetFile("res/soundfont.sf2", new File(gameDir, "res/soundfont.sf2"));
|
||||
copyAssetFile("GET_ASSETS_QUEST.txt", marker);
|
||||
copyAssetDir("shaders", new File(gameDir, "shaders"), false);
|
||||
copyAssetFile("res/soundfont.sf2", new File(gameDir, "res/soundfont.sf2"), false);
|
||||
copyAssetFile("GET_ASSETS_QUEST.txt", marker, false);
|
||||
}
|
||||
|
||||
// Refreshed on every launch (unlike the marker-gated block above) so
|
||||
// it always matches the installed build - qs_config.c reads this as
|
||||
// the initial config only when questshock.config.json doesn't exist
|
||||
// yet, never overwriting a user's own saved config.
|
||||
copyAssetFile("questshock.config.default.json",
|
||||
new File(gameDir, "questshock.config.default.json"), true);
|
||||
|
||||
// Refreshed on every launch. MenuOverlay's Controller Options tab
|
||||
// matches the active OpenXR interaction profile against these files'
|
||||
// "interaction_profile" and shows the paired image (see CONFIG.md).
|
||||
// Only the bundled filenames are overwritten, so profiles a user adds
|
||||
// to this folder are kept.
|
||||
copyAssetDir("controller_profiles", new File(gameDir, "controller_profiles"), true);
|
||||
|
||||
// Shockolate's engine/ is never patched to check this itself (see the
|
||||
// class doc above) - it just does plain fopen("res/data/...", ...)
|
||||
// and, on a fresh install with no game data copied in yet, that
|
||||
@@ -211,8 +226,8 @@ public class QuestShockActivity extends SDLActivity {
|
||||
.show();
|
||||
}
|
||||
|
||||
private void copyAssetFile(String assetPath, File dest) {
|
||||
if (dest.exists()) {
|
||||
private void copyAssetFile(String assetPath, File dest, boolean overwrite) {
|
||||
if (dest.exists() && !overwrite) {
|
||||
return;
|
||||
}
|
||||
File parent = dest.getParentFile();
|
||||
@@ -232,7 +247,7 @@ public class QuestShockActivity extends SDLActivity {
|
||||
}
|
||||
}
|
||||
|
||||
private void copyAssetDir(String assetDir, File destDir) {
|
||||
private void copyAssetDir(String assetDir, File destDir, boolean overwrite) {
|
||||
AssetManager assets = getAssets();
|
||||
String[] entries;
|
||||
try {
|
||||
@@ -246,7 +261,7 @@ public class QuestShockActivity extends SDLActivity {
|
||||
}
|
||||
destDir.mkdirs();
|
||||
for (String entry : entries) {
|
||||
copyAssetFile(assetDir + "/" + entry, new File(destDir, entry));
|
||||
copyAssetFile(assetDir + "/" + entry, new File(destDir, entry), overwrite);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -37,6 +37,8 @@ final class Strings {
|
||||
"Konfiguration speichern");
|
||||
put("load_configuration", "Load Configuration", "Charger la configuration",
|
||||
"Konfiguration laden");
|
||||
put("reset_position", "Reset Position", "Réinitialiser la position",
|
||||
"Position zurücksetzen");
|
||||
put("main_menu", "Main Menu", "Menu principal", "Hauptmenü");
|
||||
put("video_options", "Video Options", "Options vidéo", "Videooptionen");
|
||||
put("dismiss", "Dismiss", "Fermer", "Schließen");
|
||||
@@ -44,6 +46,14 @@ final class Strings {
|
||||
put("renderer", "Renderer", "Moteur de rendu", "Renderer");
|
||||
put("resolution", "Resolution", "Résolution", "Auflösung");
|
||||
put("software", "Software", "Logiciel", "Software");
|
||||
put("language", "Language", "Langue", "Sprache");
|
||||
put("english", "English", "Anglais", "Englisch");
|
||||
put("french", "French", "Français", "Französisch");
|
||||
put("german", "German", "Allemand", "Deutsch");
|
||||
put("initial_screen", "Initial Screen", "Écran initial", "Startbildschirm");
|
||||
put("game_screen", "Game Screen", "Écran de jeu", "Spielbildschirm");
|
||||
put("width", "Width", "Largeur", "Breite");
|
||||
put("distance", "Distance", "Distance", "Abstand");
|
||||
// "OpenGL" is a proper/brand name - not translated, same in every
|
||||
// language, so it has no entry here; call sites just use it as a
|
||||
// literal.
|
||||
@@ -51,6 +61,145 @@ final class Strings {
|
||||
"Clavier - faites glisser ici pour déplacer",
|
||||
"Tastatur - hier ziehen zum Verschieben");
|
||||
put("close", "Close", "Fermer", "Schließen");
|
||||
|
||||
// Controller Options tab: action row labels, keyed by xr_input.c's
|
||||
// action names (see MenuOverlay.ACTION_KEYS).
|
||||
put("controller_options", "Controller Options", "Options de manette", "Controller-Optionen");
|
||||
put("action_move_forward", "Move Forward", "Avancer", "Vorwärts gehen");
|
||||
put("action_move_back", "Move Back", "Reculer", "Rückwärts gehen");
|
||||
put("action_strafe_left", "Strafe Left", "Pas latéral gauche", "Seitwärts links");
|
||||
put("action_strafe_right", "Strafe Right", "Pas latéral droit", "Seitwärts rechts");
|
||||
put("action_turn_left", "Turn Left", "Tourner à gauche", "Nach links drehen");
|
||||
put("action_turn_right", "Turn Right", "Tourner à droite", "Nach rechts drehen");
|
||||
put("action_jump", "Jump", "Sauter", "Springen");
|
||||
put("action_mouse_click", "Click", "Cliquer", "Klicken");
|
||||
put("action_mouse_double_click", "Double-Click", "Double-clic", "Doppelklick");
|
||||
|
||||
// Hotkey actions (see xr_input.c); all unbound by default.
|
||||
put("action_stand", "Stand", "Debout", "Stehen");
|
||||
put("action_crouch", "Crouch", "Accroupi", "Ducken");
|
||||
put("action_prone", "Prone", "Couché", "Liegen");
|
||||
put("action_pause", "Pause Game", "Mettre en pause", "Spiel pausieren");
|
||||
put("action_full_view", "Fullscreen View", "Vue plein écran", "Vollbildansicht");
|
||||
put("action_normal_view", "Normal View", "Vue normale", "Normale Ansicht");
|
||||
put("action_map_view", "Automap View", "Vue de la carte", "Automap-Ansicht");
|
||||
put("action_save_game", "Save Game", "Sauvegarder", "Spiel speichern");
|
||||
put("action_load_game", "Load Game", "Charger", "Spiel laden");
|
||||
put("action_select_grenade", "Select Grenade", "Sélectionner une grenade",
|
||||
"Granate auswählen");
|
||||
put("action_arm_grenade", "Arm Grenade", "Armer la grenade", "Granate scharfmachen");
|
||||
put("action_select_drug", "Select Drug", "Sélectionner une drogue", "Droge auswählen");
|
||||
put("action_use_drug", "Use Drug", "Utiliser la drogue", "Droge benutzen");
|
||||
put("action_toggle_online_help", "Toggle Online Help", "Basculer l'aide en ligne",
|
||||
"Online-Hilfe umschalten");
|
||||
put("action_show_help", "Show Help", "Afficher l'aide", "Hilfe anzeigen");
|
||||
put("action_toggle_music", "Toggle Music", "Basculer la musique", "Musik umschalten");
|
||||
put("action_quit", "Quit Game", "Quitter le jeu", "Spiel beenden");
|
||||
put("action_cycle_weapon_next", "Next Weapon", "Arme suivante", "Nächste Waffe");
|
||||
put("action_cycle_weapon_prev", "Previous Weapon", "Arme précédente", "Vorherige Waffe");
|
||||
put("action_cycle_detail", "Cycle Detail Level", "Changer le niveau de détail",
|
||||
"Detailgrad wechseln");
|
||||
put("action_reload_weapon_primary", "Reload Weapon (Primary)",
|
||||
"Recharger l'arme (principal)", "Waffe nachladen (primär)");
|
||||
put("action_reload_weapon_secondary", "Reload Weapon (Secondary)",
|
||||
"Recharger l'arme (secondaire)", "Waffe nachladen (sekundär)");
|
||||
put("action_hud_color", "Cycle HUD Color", "Changer la couleur de l'interface",
|
||||
"HUD-Farbe wechseln");
|
||||
put("action_clear_fullscreen", "Clear Fullscreen View", "Quitter la vue plein écran",
|
||||
"Vollbildansicht schließen");
|
||||
put("action_mfd_left_1", "Left MFD: Weapon", "MFD gauche : arme", "Linkes MFD: Waffe");
|
||||
put("action_mfd_left_2", "Left MFD: Item", "MFD gauche : objet", "Linkes MFD: Gegenstand");
|
||||
put("action_mfd_left_3", "Left MFD: Map", "MFD gauche : carte", "Linkes MFD: Karte");
|
||||
put("action_mfd_left_4", "Left MFD: Target", "MFD gauche : cible", "Linkes MFD: Ziel");
|
||||
put("action_mfd_left_5", "Left MFD: Info", "MFD gauche : info", "Linkes MFD: Info");
|
||||
put("action_mfd_right_1", "Right MFD: Weapon", "MFD droit : arme", "Rechtes MFD: Waffe");
|
||||
put("action_mfd_right_2", "Right MFD: Item", "MFD droit : objet",
|
||||
"Rechtes MFD: Gegenstand");
|
||||
put("action_mfd_right_3", "Right MFD: Map", "MFD droit : carte", "Rechtes MFD: Karte");
|
||||
put("action_mfd_right_4", "Right MFD: Target", "MFD droit : cible", "Rechtes MFD: Ziel");
|
||||
put("action_mfd_right_5", "Right MFD: Info", "MFD droit : info", "Rechtes MFD: Info");
|
||||
put("action_fire_weapon", "Fire Weapon", "Tirer", "Waffe abfeuern");
|
||||
// Cheats tab.
|
||||
put("cheats", "Cheats", "Triches", "Cheats");
|
||||
put("cheats_note", "Cheats need a running game.", "Les triches nécessitent une partie en cours.",
|
||||
"Cheats benötigen ein laufendes Spiel.");
|
||||
put("cheat_give_all", "Give All Items & Weapons", "Tout obtenir", "Alles erhalten");
|
||||
put("cheat_physics", "Physics", "Physique", "Physik");
|
||||
put("cheat_level_up", "Next Level", "Niveau suivant", "Nächstes Level");
|
||||
put("cheat_level_down", "Previous Level", "Niveau précédent", "Vorheriges Level");
|
||||
put("cheat_unlimited_health", "Unlimited Health", "Santé illimitée", "Unbegrenzt Leben");
|
||||
put("cheat_unlimited_energy", "Unlimited Energy", "Énergie illimitée", "Unbegrenzt Energie");
|
||||
put("cheat_unlimited_ammo", "Unlimited Ammo", "Munitions illimitées", "Unbegrenzt Munition");
|
||||
put("cheat_unlimited_items", "Unlimited Items", "Objets illimités", "Unbegrenzt Items");
|
||||
|
||||
put("action_free_left_thumbstick_view", "Free View (Left Stick)",
|
||||
"Vue libre (stick gauche)", "Freie Ansicht (linker Stick)");
|
||||
put("action_free_right_thumbstick_view", "Free View (Right Stick)",
|
||||
"Vue libre (stick droit)", "Freie Ansicht (rechter Stick)");
|
||||
|
||||
// Cyberspace actions (active only in cyberspace, see xr_input.c).
|
||||
put("action_cyber_thrust", "Cyberspace: Thrust", "Cyberespace : poussée",
|
||||
"Cyberspace: Schub");
|
||||
put("action_cyber_climb", "Cyberspace: Climb", "Cyberespace : monter",
|
||||
"Cyberspace: Steigen");
|
||||
put("action_cyber_dive", "Cyberspace: Dive", "Cyberespace : plonger",
|
||||
"Cyberspace: Sinken");
|
||||
put("action_cyber_bank_left", "Cyberspace: Bank Left", "Cyberespace : virage à gauche",
|
||||
"Cyberspace: Links kippen");
|
||||
put("action_cyber_bank_right", "Cyberspace: Bank Right", "Cyberespace : virage à droite",
|
||||
"Cyberspace: Rechts kippen");
|
||||
put("action_cyber_roll_left", "Cyberspace: Roll Left", "Cyberespace : roulis gauche",
|
||||
"Cyberspace: Links rollen");
|
||||
put("action_cyber_roll_right", "Cyberspace: Roll Right", "Cyberespace : roulis droit",
|
||||
"Cyberspace: Rechts rollen");
|
||||
put("action_cyber_climb_left", "Cyberspace: Climb Left", "Cyberespace : monter à gauche",
|
||||
"Cyberspace: Links steigen");
|
||||
put("action_cyber_climb_right", "Cyberspace: Climb Right", "Cyberespace : monter à droite",
|
||||
"Cyberspace: Rechts steigen");
|
||||
put("action_cyber_dive_left", "Cyberspace: Dive Left", "Cyberespace : plonger à gauche",
|
||||
"Cyberspace: Links sinken");
|
||||
put("action_cyber_dive_right", "Cyberspace: Dive Right", "Cyberespace : plonger à droite",
|
||||
"Cyberspace: Rechts sinken");
|
||||
put("capture_prompt", "Press a button…", "Appuyez sur un bouton…", "Taste drücken…");
|
||||
put("reset_to_defaults", "Reset to Defaults", "Réinitialiser", "Auf Standard zurücksetzen");
|
||||
put("generic_profile_note",
|
||||
"This controller only exposes a trigger and a menu button - most actions above have "
|
||||
+ "nothing to bind to.",
|
||||
"Cette manette n'expose qu'une gâchette et un bouton menu - la plupart des actions "
|
||||
+ "ci-dessus n'ont rien à quoi être assignées.",
|
||||
"Dieser Controller bietet nur einen Trigger und eine Menütaste - die meisten "
|
||||
+ "Aktionen oben haben nichts, woran sie gebunden werden können.");
|
||||
|
||||
// Raw physical-input display names (xr_input.c's kRawInputNames);
|
||||
// "none" is the unbound sentinel.
|
||||
put("raw_left_trigger", "Left Trigger", "Gâchette gauche", "Linker Trigger");
|
||||
put("raw_right_trigger", "Right Trigger", "Gâchette droite", "Rechter Trigger");
|
||||
put("raw_left_squeeze", "Left Grip", "Préhension gauche", "Linker Griff");
|
||||
put("raw_right_squeeze", "Right Grip", "Préhension droite", "Rechter Griff");
|
||||
put("raw_left_x", "X Button", "Bouton X", "X-Taste");
|
||||
put("raw_left_y", "Y Button", "Bouton Y", "Y-Taste");
|
||||
put("raw_right_a", "A Button", "Bouton A", "A-Taste");
|
||||
put("raw_right_b", "B Button", "Bouton B", "B-Taste");
|
||||
put("raw_left_thumbstick_click", "Left Stick Click", "Clic du stick gauche",
|
||||
"Linker Stick-Klick");
|
||||
put("raw_right_thumbstick_click", "Right Stick Click", "Clic du stick droit",
|
||||
"Rechter Stick-Klick");
|
||||
put("raw_left_thumbstick_up", "Left Stick Up", "Stick gauche haut", "Linker Stick hoch");
|
||||
put("raw_left_thumbstick_down", "Left Stick Down", "Stick gauche bas", "Linker Stick runter");
|
||||
put("raw_left_thumbstick_left", "Left Stick Left", "Stick gauche à gauche",
|
||||
"Linker Stick links");
|
||||
put("raw_left_thumbstick_right", "Left Stick Right", "Stick gauche à droite",
|
||||
"Linker Stick rechts");
|
||||
put("raw_right_thumbstick_up", "Right Stick Up", "Stick droit haut", "Rechter Stick hoch");
|
||||
put("raw_right_thumbstick_down", "Right Stick Down", "Stick droit bas",
|
||||
"Rechter Stick runter");
|
||||
put("raw_right_thumbstick_left", "Right Stick Left", "Stick droit à gauche",
|
||||
"Rechter Stick links");
|
||||
put("raw_right_thumbstick_right", "Right Stick Right", "Stick droit à droite",
|
||||
"Rechter Stick rechts");
|
||||
put("raw_trigger", "Either Trigger", "L'une ou l'autre gâchette", "Beliebiger Trigger");
|
||||
put("raw_squeeze", "Either Grip", "L'une ou l'autre préhension", "Beliebiger Griff");
|
||||
put("raw_none", "(unbound)", "(non assigné)", "(nicht zugewiesen)");
|
||||
}
|
||||
|
||||
private Strings() {}
|
||||
|
||||
+12
-1
@@ -9,7 +9,18 @@ buildscript {
|
||||
google()
|
||||
}
|
||||
dependencies {
|
||||
classpath 'com.android.tools.build:gradle:8.1.1'
|
||||
// 8.5.1+ needed for AGP to automatically 16 KB-align native
|
||||
// libraries' zip entries within the APK - the actual .so's are
|
||||
// already ELF-segment-aligned for this regardless of AGP version
|
||||
// (see build-image/Dockerfile's ANDROID_16KB_LDFLAGS and
|
||||
// app/build.gradle's own CMAKE_SHARED_LINKER_FLAGS), but that alone
|
||||
// doesn't get them 16 KB-aligned *within the APK's zip*, which is
|
||||
// what Android Studio's "not compatible with 16 KB devices"
|
||||
// warning is actually about. Needs Gradle 8.7+ (see
|
||||
// gradle/wrapper/gradle-wrapper.properties) and JDK 17 in whatever
|
||||
// runs gradlew (already the case - see build-image/Dockerfile's
|
||||
// openjdk-17-jdk-headless).
|
||||
classpath 'com.android.tools.build:gradle:8.5.2'
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
--- a/src/GameSrc/mainloop.c
|
||||
+++ b/src/GameSrc/mainloop.c
|
||||
@@ -57,6 +57,10 @@
|
||||
#include "tools.h"
|
||||
#include "wrapper.h"
|
||||
|
||||
+#ifdef __ANDROID__
|
||||
+#include "qs_config.h"
|
||||
+#endif
|
||||
+
|
||||
// how is the game doing, anyway, set to true at end of time
|
||||
uchar cit_success = FALSE;
|
||||
|
||||
@@ -103,6 +107,16 @@
|
||||
_last_mode = *cmode;
|
||||
(*exit_modes[_last_mode])();
|
||||
*cmode = _new_mode;
|
||||
+#ifdef __ANDROID__
|
||||
+ // Notifies qs_config.c of every loop-mode transition so it can pick
|
||||
+ // between the "Initial Screen" and "Game Screen" virtual-screen
|
||||
+ // presets - see qs_config.h/CONFIG.md. Called synchronously, directly,
|
||||
+ // on this thread (mainloop()'s own) - unlike the UI-thread-triggered
|
||||
+ // config actions elsewhere in qs_config.c, this doesn't need the
|
||||
+ // cross-thread SDL-event dance since it already originates on the
|
||||
+ // right thread.
|
||||
+ qs_screen_profile_notify_loop_mode(*cmode);
|
||||
+#endif
|
||||
_static_change = 0;
|
||||
if (*cmode >= 0)
|
||||
(*enter_modes[*cmode])();
|
||||
@@ -0,0 +1,42 @@
|
||||
--- a/src/GameSrc/cutsloop.c
|
||||
+++ b/src/GameSrc/cutsloop.c
|
||||
@@ -292,11 +292,38 @@
|
||||
|
||||
|
||||
|
||||
+#ifdef __ANDROID__
|
||||
+// The intro (cutscene 0) ships in one file per language - localized
|
||||
+// voice-over - each holding the same resource id (cutscene_anims[0]), so
|
||||
+// opening the current language's file instead is all it takes. The death
|
||||
+// and ending cutscenes only have one version.
|
||||
+static char *intro_files_by_language[3] =
|
||||
+{
|
||||
+ "res/data/svgaintr.res", // English
|
||||
+ "res/data/svfrintr.res", // French
|
||||
+ "res/data/svgeintr.res" // German
|
||||
+};
|
||||
+
|
||||
+static int open_cutscene_file(int id)
|
||||
+{
|
||||
+ if (id == 0 && which_lang > 0 && which_lang < 3)
|
||||
+ {
|
||||
+ int handle = ResOpenFile(intro_files_by_language[(int)which_lang]);
|
||||
+ if (handle > 0)
|
||||
+ return handle;
|
||||
+ // Not installed for this language - fall back to English below.
|
||||
+ }
|
||||
+ return ResOpenFile(cutscene_files[id]);
|
||||
+}
|
||||
+#else
|
||||
+#define open_cutscene_file(id) ResOpenFile(cutscene_files[id])
|
||||
+#endif
|
||||
+
|
||||
short play_cutscene(int id, bool show_credits)
|
||||
{
|
||||
MacTuneKillCurrentTheme();
|
||||
|
||||
- cutscene_filehandle = ResOpenFile(cutscene_files[id]);
|
||||
+ cutscene_filehandle = open_cutscene_file(id);
|
||||
if (cutscene_filehandle <= 0) {
|
||||
// If we failed to play the cutscene, go to setup / credits.
|
||||
_new_mode = SETUP_LOOP;
|
||||
@@ -0,0 +1,13 @@
|
||||
--- a/src/GameSrc/mouselook.c
|
||||
+++ b/src/GameSrc/mouselook.c
|
||||
@@ -121,3 +121,10 @@
|
||||
get_mouselook_vel(&mvelx, &mvely);
|
||||
}
|
||||
}
|
||||
+
|
||||
+#ifdef __ANDROID__
|
||||
+// Whether the player is currently in cyberspace; read by the Android
|
||||
+// controller input code (android/app/src/main/cpp/xr_input.c) to switch
|
||||
+// between the normal and cyberspace action sets.
|
||||
+int qs_in_cyberspace(void) { return global_fullmap != NULL && global_fullmap->cyber; }
|
||||
+#endif
|
||||
@@ -0,0 +1,110 @@
|
||||
--- a/src/GameSrc/movekeys.c
|
||||
+++ b/src/GameSrc/movekeys.c
|
||||
@@ -44,6 +44,12 @@
|
||||
extern bool gKeypadOverride;
|
||||
|
||||
uchar parse_motion_key(ushort code, short *cnum, short *cval);
|
||||
+#ifdef __ANDROID__
|
||||
+// Set every frame by android/app/src/main/cpp/xr_input.c.
|
||||
+float qs_cyber_pitch_scale = 1.0f;
|
||||
+float qs_cyber_bank_scale = 1.0f;
|
||||
+#endif
|
||||
+
|
||||
uchar parse_motion_key_cyber(ushort code, short *cnum, short *cval);
|
||||
void init_motion_polling(void);
|
||||
|
||||
@@ -173,6 +179,20 @@
|
||||
*cnum = -1;
|
||||
*cval = 0;
|
||||
|
||||
+#ifdef __ANDROID__
|
||||
+ // Pitch and bank strength, scaled by the controller thumbstick's
|
||||
+ // deflection (see android/app/src/main/cpp/xr_input.c); 1.0 for a key.
|
||||
+ short pitchMax = (short)(CONTROL_MAX_VAL * qs_cyber_pitch_scale + 0.5f);
|
||||
+ short bankMax = (short)(CONTROL_MAX_VAL * qs_cyber_bank_scale + 0.5f);
|
||||
+ if (pitchMax < 1)
|
||||
+ pitchMax = 1;
|
||||
+ if (bankMax < 1)
|
||||
+ bankMax = 1;
|
||||
+#else
|
||||
+ short pitchMax = CONTROL_MAX_VAL;
|
||||
+ short bankMax = CONTROL_MAX_VAL;
|
||||
+#endif
|
||||
+
|
||||
while (MoveCyberKeybinds[i].code != 255) {
|
||||
if (code == MoveCyberKeybinds[i].code) {
|
||||
move = MoveCyberKeybinds[i].move;
|
||||
@@ -189,22 +209,22 @@
|
||||
|
||||
case M_CLIMB:
|
||||
*cnum = CONTROL_YVEL;
|
||||
- *cval = -CONTROL_MAX_VAL;
|
||||
+ *cval = -pitchMax;
|
||||
break;
|
||||
|
||||
case M_BANKLEFT:
|
||||
*cnum = CONTROL_XYROT;
|
||||
- *cval = -CONTROL_MAX_VAL;
|
||||
+ *cval = -bankMax;
|
||||
break;
|
||||
|
||||
case M_BANKRIGHT:
|
||||
*cnum = CONTROL_XYROT;
|
||||
- *cval = CONTROL_MAX_VAL;
|
||||
+ *cval = bankMax;
|
||||
break;
|
||||
|
||||
case M_DIVE:
|
||||
*cnum = CONTROL_YVEL;
|
||||
- *cval = CONTROL_MAX_VAL;
|
||||
+ *cval = pitchMax;
|
||||
break;
|
||||
|
||||
case M_ROLLRIGHT:
|
||||
@@ -219,38 +239,38 @@
|
||||
|
||||
case M_CLIMBLEFT:
|
||||
*cnum = CONTROL_YVEL;
|
||||
- *cval = -CONTROL_MAX_VAL;
|
||||
+ *cval = -pitchMax;
|
||||
if (abs(poll_controls[*cnum]) < abs(*cval))
|
||||
poll_controls[*cnum] = *cval;
|
||||
*cnum = CONTROL_XYROT;
|
||||
- *cval = -CONTROL_MAX_VAL;
|
||||
+ *cval = -bankMax;
|
||||
break;
|
||||
|
||||
case M_CLIMBRIGHT:
|
||||
*cnum = CONTROL_YVEL;
|
||||
- *cval = -CONTROL_MAX_VAL;
|
||||
+ *cval = -pitchMax;
|
||||
if (abs(poll_controls[*cnum]) < abs(*cval))
|
||||
poll_controls[*cnum] = *cval;
|
||||
*cnum = CONTROL_XYROT;
|
||||
- *cval = CONTROL_MAX_VAL;
|
||||
+ *cval = bankMax;
|
||||
break;
|
||||
|
||||
case M_DIVERIGHT:
|
||||
*cnum = CONTROL_YVEL;
|
||||
- *cval = CONTROL_MAX_VAL;
|
||||
+ *cval = pitchMax;
|
||||
if (abs(poll_controls[*cnum]) < abs(*cval))
|
||||
poll_controls[*cnum] = *cval;
|
||||
*cnum = CONTROL_XYROT;
|
||||
- *cval = CONTROL_MAX_VAL;
|
||||
+ *cval = bankMax;
|
||||
break;
|
||||
|
||||
case M_DIVELEFT:
|
||||
*cnum = CONTROL_YVEL;
|
||||
- *cval = CONTROL_MAX_VAL;
|
||||
+ *cval = pitchMax;
|
||||
if (abs(poll_controls[*cnum]) < abs(*cval))
|
||||
poll_controls[*cnum] = *cval;
|
||||
*cnum = CONTROL_XYROT;
|
||||
- *cval = -CONTROL_MAX_VAL;
|
||||
+ *cval = -bankMax;
|
||||
break;
|
||||
default:
|
||||
// Unhandled movement. What I gonna do?
|
||||
@@ -0,0 +1,74 @@
|
||||
--- a/src/GameSrc/hkeyfunc.c
|
||||
+++ b/src/GameSrc/hkeyfunc.c
|
||||
@@ -1465,3 +1465,71 @@
|
||||
#pragma enable_message(202)
|
||||
|
||||
#endif // NOT_YET
|
||||
+
|
||||
+#ifdef __ANDROID__
|
||||
+// Tops up parts of the player's state; android/app/src/main/cpp/qs_config.c
|
||||
+// calls it once per frame with the "unlimited" cheats that are switched on.
|
||||
+// `what` is a bitmask: 1 health, 2 energy, 4 ammo, 8 items (the same values as
|
||||
+// QS_CHEAT_MASK_* in qs_config.c). Only conventional guns use ammo: beam and
|
||||
+// melee weapons keep heat in the same field, so they are left alone (beams draw
|
||||
+// on energy). Spare ammo clips, grenades and drugs are only refilled for kinds
|
||||
+// the player already holds, so the cheat never creates items.
|
||||
+void qs_cheat_refill(int what) {
|
||||
+ const int kAmmoFloor = 99;
|
||||
+ const int kItemFloor = 99;
|
||||
+ uchar vitalsChanged = FALSE;
|
||||
+ uchar inventoryChanged = FALSE;
|
||||
+
|
||||
+ if (player_struct.dead)
|
||||
+ return;
|
||||
+ if ((what & 1) && player_struct.hit_points < PLAYER_MAX_HP) {
|
||||
+ player_struct.hit_points = PLAYER_MAX_HP;
|
||||
+ vitalsChanged = TRUE;
|
||||
+ }
|
||||
+ if ((what & 1) && player_struct.cspace_hp < PLAYER_MAX_HP) {
|
||||
+ player_struct.cspace_hp = PLAYER_MAX_HP;
|
||||
+ vitalsChanged = TRUE;
|
||||
+ }
|
||||
+ if ((what & 2) && player_struct.energy < 255) {
|
||||
+ player_struct.energy = 255;
|
||||
+ vitalsChanged = TRUE;
|
||||
+ }
|
||||
+ if (vitalsChanged)
|
||||
+ chg_set_flg(VITALS_UPDATE);
|
||||
+
|
||||
+ if (what & 4) {
|
||||
+ for (int i = 0; i < NUM_WEAPON_SLOTS; i++) {
|
||||
+ weapon_slot *slot = &player_struct.weapons[i];
|
||||
+ if (slot->type != EMPTY_WEAPON_SLOT && slot->type <= GUN_SUBCLASS_SPECIAL &&
|
||||
+ slot->ammo < kAmmoFloor) {
|
||||
+ slot->ammo = kAmmoFloor;
|
||||
+ inventoryChanged = TRUE;
|
||||
+ }
|
||||
+ }
|
||||
+ for (int i = 0; i < NUM_AMMO_TYPES; i++) {
|
||||
+ if (player_struct.cartridges[i] > 0 && player_struct.cartridges[i] < kItemFloor) {
|
||||
+ player_struct.cartridges[i] = kItemFloor;
|
||||
+ inventoryChanged = TRUE;
|
||||
+ }
|
||||
+ }
|
||||
+ }
|
||||
+ if (what & 8) {
|
||||
+ for (int i = 0; i < NUM_GRENADEZ; i++) {
|
||||
+ if (player_struct.grenades[i] > 0 && player_struct.grenades[i] < kItemFloor) {
|
||||
+ player_struct.grenades[i] = kItemFloor;
|
||||
+ inventoryChanged = TRUE;
|
||||
+ }
|
||||
+ }
|
||||
+ for (int i = 0; i < NUM_DRUGZ; i++) {
|
||||
+ if (player_struct.drugs[i] > 0 && player_struct.drugs[i] < kItemFloor) {
|
||||
+ player_struct.drugs[i] = kItemFloor;
|
||||
+ inventoryChanged = TRUE;
|
||||
+ }
|
||||
+ }
|
||||
+ }
|
||||
+ if (inventoryChanged) {
|
||||
+ chg_set_flg(INVENTORY_UPDATE);
|
||||
+ mfd_force_update();
|
||||
+ }
|
||||
+}
|
||||
+#endif
|
||||
+4
-3
@@ -1,6 +1,7 @@
|
||||
#Thu Nov 11 18:20:34 PST 2021
|
||||
#Sat Sep 05 16:12:16 CEST 2026
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
|
||||
distributionPath=wrapper/dists
|
||||
zipStorePath=wrapper/dists
|
||||
distributionSha256Sum=544c35d6bd849ae8a5ed0bcea39ba677dc40f49df7d1835561582da2009b961d
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
|
||||
@@ -81,7 +81,7 @@ fi
|
||||
echo "prebuiltDir=$PREBUILT_DIR_PROP"
|
||||
} > "$ANDROID_DIR/engine.properties"
|
||||
|
||||
echo "== Staging bundled assets (shaders, soundfont, get-assets text) =="
|
||||
echo "== Staging bundled assets (shaders, soundfont, get-assets text, default config) =="
|
||||
ASSETS_DIR="$ANDROID_DIR/app/src/main/assets"
|
||||
rm -rf "$ASSETS_DIR"
|
||||
mkdir -p "$ASSETS_DIR/shaders" "$ASSETS_DIR/res"
|
||||
@@ -91,6 +91,8 @@ mkdir -p "$ASSETS_DIR/shaders" "$ASSETS_DIR/res"
|
||||
cp -a "$ANDROID_DIR/gles-shaders/." "$ASSETS_DIR/shaders/"
|
||||
cp "/opt/prebuilt/soundfont/default.sf2" "$ASSETS_DIR/res/soundfont.sf2"
|
||||
cp "$REPO_ROOT/res/assets/GET_ASSETS_QUEST.txt" "$ASSETS_DIR/GET_ASSETS_QUEST.txt"
|
||||
cp "$REPO_ROOT/res/questshock.config.default.json" "$ASSETS_DIR/questshock.config.default.json"
|
||||
cp -a "$REPO_ROOT/res/controller_profiles" "$ASSETS_DIR/controller_profiles"
|
||||
|
||||
echo "== Staging prebuilt Android SDL2/SDL2_mixer/fluidsynth-lite/openxr .so's into jniLibs =="
|
||||
# gl4es is deliberately absent here - it's no longer prebuilt, it's compiled
|
||||
|
||||
@@ -13,10 +13,23 @@
|
||||
# inside it in sshock.kpf, which is just a zip file. Its res/pc/hd/ and
|
||||
# res/pc/cdrom/ trees together hold every classic-game data/sound file
|
||||
# Shockolate's res/ folder expects (res/pc/hd wins the couple of
|
||||
# filenames present in both: intro.res, objprop.dat). Needs innoextract
|
||||
# and unzip; if they're not installed locally, this script does the
|
||||
# extraction inside a throwaway Ubuntu container instead (needs docker in
|
||||
# that case, nothing else).
|
||||
# filenames present in both: intro.res, objprop.dat), EXCEPT
|
||||
# mfdfrn.res/mfdger.res (French/German MFD art - see CONFIG.md/README.md),
|
||||
# which that installer doesn't include at all - see "Optional: French/
|
||||
# German MFD art" below for where those instead come from. Needs
|
||||
# innoextract and unzip; if they're not installed locally, this script
|
||||
# does the extraction inside a throwaway Ubuntu container instead (needs
|
||||
# docker in that case, nothing else).
|
||||
#
|
||||
# Optional: French/German MFD art
|
||||
# The Enhanced Edition installer's data set doesn't include
|
||||
# mfdfrn.res/mfdger.res, so French/German are otherwise missing their
|
||||
# MFD (Multi-Function Display) art and the game refuses to switch to
|
||||
# them (see CONFIG.md). System Shock: Classic (also gog.com) does
|
||||
# include both files. If you also own it, drop its offline installer
|
||||
# (e.g. setup_system_shock_classic_2.0.0.3.exe) in this directory too -
|
||||
# entirely optional, this script still runs fine without it - and this
|
||||
# script pulls just those two files out of it into ss_ee/data/ as well.
|
||||
set -euo pipefail
|
||||
|
||||
cd "$(dirname "${BASH_SOURCE[0]}")"
|
||||
@@ -27,6 +40,7 @@ fail() { echo "PREFLIGHT FAIL: $*" >&2; exit 1; }
|
||||
|
||||
shopt -s nullglob
|
||||
installers=(setup_system_shock_enhanced_edition*.exe)
|
||||
classic_installers=(setup_system_shock_classic*.exe)
|
||||
shopt -u nullglob
|
||||
case "${#installers[@]}" in
|
||||
0) fail "no setup_system_shock_enhanced_edition*.exe found in $ASSETS_DIR - buy System Shock: Enhanced Edition on gog.com, download the offline installer, and drop it here" ;;
|
||||
@@ -35,6 +49,15 @@ case "${#installers[@]}" in
|
||||
esac
|
||||
INSTALLER="${installers[0]}"
|
||||
|
||||
# Optional - see "Optional: French/German MFD art" above. Empty (not
|
||||
# missing/failed) when absent; only a genuine ambiguity (more than one
|
||||
# candidate file) is a hard failure.
|
||||
case "${#classic_installers[@]}" in
|
||||
0) CLASSIC_INSTALLER="" ;;
|
||||
1) CLASSIC_INSTALLER="${classic_installers[0]}" ;;
|
||||
*) fail "multiple setup_system_shock_classic*.exe files found in $ASSETS_DIR - keep only one: ${classic_installers[*]}" ;;
|
||||
esac
|
||||
|
||||
# Extracts sshock.kpf from $1 (an installer .exe) and assembles $2 (an
|
||||
# ss_ee output directory) from its res/pc/{hd,cdrom} trees. Defined as a
|
||||
# function so the exact same logic can run either natively or, via
|
||||
@@ -69,9 +92,38 @@ run_extraction() {
|
||||
cp -a "$work/kpf/res/pc/hd/sound/." "$out_dir/sound/"
|
||||
}
|
||||
|
||||
# Extracts mfdfrn.res/mfdger.res from $1 (a System Shock: Classic installer
|
||||
# .exe) into $2 (an existing ss_ee output directory's data/ subfolder) -
|
||||
# see "Optional: French/German MFD art" above. Unlike the Enhanced Edition
|
||||
# installer, Classic's data files sit directly in the Inno Setup package
|
||||
# (no intermediate zip), so this is just a targeted innoextract --include,
|
||||
# no unzip step needed. Same declare -f-into-docker structure as
|
||||
# run_extraction() above.
|
||||
run_classic_mfd_extraction() {
|
||||
set -euo pipefail
|
||||
local installer="$1" out_dir="$2"
|
||||
work="$(mktemp -d)"
|
||||
trap 'rm -rf "${work:-}"' EXIT
|
||||
|
||||
echo "== Extracting mfdfrn.res/mfdger.res from classic installer =="
|
||||
innoextract --silent \
|
||||
--include 'app/SSHOCK/DATA/MFDFRN.RES' --include 'app/SSHOCK/DATA/MFDGER.RES' \
|
||||
-d "$work/classic" "$installer"
|
||||
|
||||
# Original DOS-era filenames are uppercase; Shockolate's resource
|
||||
# loader expects the lowercase names already used for every other
|
||||
# res/data/*.res file (case-sensitive on Linux, unlike the DOS/Windows
|
||||
# filesystems these came from).
|
||||
cp "$work/classic/app/SSHOCK/DATA/MFDFRN.RES" "$out_dir/data/mfdfrn.res"
|
||||
cp "$work/classic/app/SSHOCK/DATA/MFDGER.RES" "$out_dir/data/mfdger.res"
|
||||
}
|
||||
|
||||
if command -v innoextract >/dev/null 2>&1 && command -v unzip >/dev/null 2>&1; then
|
||||
echo "== Using local innoextract/unzip =="
|
||||
run_extraction "$ASSETS_DIR/$INSTALLER" "$OUT_DIR"
|
||||
if [ -n "$CLASSIC_INSTALLER" ]; then
|
||||
run_classic_mfd_extraction "$ASSETS_DIR/$CLASSIC_INSTALLER" "$OUT_DIR"
|
||||
fi
|
||||
else
|
||||
echo "== innoextract/unzip not found locally - using a throwaway docker container =="
|
||||
command -v docker >/dev/null 2>&1 \
|
||||
@@ -86,12 +138,18 @@ else
|
||||
apt-get update -qq >/dev/null
|
||||
apt-get install -y -qq innoextract unzip >/dev/null
|
||||
$(declare -f run_extraction)
|
||||
$(declare -f run_classic_mfd_extraction)
|
||||
run_extraction '/assets/$INSTALLER' '/assets/ss_ee'
|
||||
$([ -n "$CLASSIC_INSTALLER" ] && echo "run_classic_mfd_extraction '/assets/$CLASSIC_INSTALLER' '/assets/ss_ee'")
|
||||
chown -R \"\$HOST_UID:\$HOST_GID\" /assets/ss_ee
|
||||
"
|
||||
fi
|
||||
|
||||
echo "== Done =="
|
||||
echo "Assets extracted to $OUT_DIR"
|
||||
echo "Note: mfdfrn.res/mfdger.res (French/German MFD art) are not present in this"
|
||||
echo "installer and are only needed for those localizations - not for English play."
|
||||
if [ -n "$CLASSIC_INSTALLER" ]; then
|
||||
echo "Also extracted mfdfrn.res/mfdger.res (French/German MFD art) from $CLASSIC_INSTALLER."
|
||||
else
|
||||
echo "Note: mfdfrn.res/mfdger.res (French/German MFD art) are not present - only needed for"
|
||||
echo "French/German (see CONFIG.md); drop a System Shock: Classic installer here too to get them."
|
||||
fi
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"name": "Generic OpenXR Controller",
|
||||
"interaction_profile": "/interaction_profiles/khr/simple_controller",
|
||||
"image": "generic.png",
|
||||
"controls": [
|
||||
{"id": "left_trigger", "label": "Select (Left)", "anchor_x": 0.30, "anchor_y": 0.60},
|
||||
{"id": "right_trigger", "label": "Select (Right)", "anchor_x": 0.30, "anchor_y": 0.60}
|
||||
]
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 27 KiB |
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "Meta Quest Touch",
|
||||
"interaction_profile": "/interaction_profiles/oculus/touch_controller",
|
||||
"image": "touch.png",
|
||||
"controls": [
|
||||
{"id": "left_trigger", "label": "Trigger", "anchor_x": 0.30, "anchor_y": 0.45},
|
||||
{"id": "right_trigger", "label": "Trigger", "anchor_x": 0.72, "anchor_y": 0.45},
|
||||
{"id": "left_squeeze", "label": "Grip", "anchor_x": 0.12, "anchor_y": 0.55},
|
||||
{"id": "right_squeeze", "label": "Grip", "anchor_x": 0.58, "anchor_y": 0.55},
|
||||
{"id": "left_x", "label": "X", "anchor_x": 0.14, "anchor_y": 0.33},
|
||||
{"id": "left_y", "label": "Y", "anchor_x": 0.24, "anchor_y": 0.35},
|
||||
{"id": "right_a", "label": "A", "anchor_x": 0.68, "anchor_y": 0.35},
|
||||
{"id": "right_b", "label": "B", "anchor_x": 0.75, "anchor_y": 0.33},
|
||||
{"id": "left_thumbstick", "label": "Thumbstick", "anchor_x": 0.20, "anchor_y": 0.28},
|
||||
{"id": "right_thumbstick", "label": "Thumbstick", "anchor_x": 0.62, "anchor_y": 0.30},
|
||||
{"id": "left_thumbstick_click", "label": "Thumbstick Click", "anchor_x": 0.20, "anchor_y": 0.28},
|
||||
{"id": "right_thumbstick_click", "label": "Thumbstick Click", "anchor_x": 0.62, "anchor_y": 0.30}
|
||||
]
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 62 KiB |
@@ -0,0 +1,15 @@
|
||||
{
|
||||
"name": "HTC Vive Wand",
|
||||
"interaction_profile": "/interaction_profiles/htc/vive_controller",
|
||||
"image": "vive.png",
|
||||
"controls": [
|
||||
{"id": "left_trigger", "label": "Trigger", "anchor_x": 0.13, "anchor_y": 0.62},
|
||||
{"id": "right_trigger", "label": "Trigger", "anchor_x": 0.78, "anchor_y": 0.62},
|
||||
{"id": "left_squeeze", "label": "Grip", "anchor_x": 0.08, "anchor_y": 0.68},
|
||||
{"id": "right_squeeze", "label": "Grip", "anchor_x": 0.85, "anchor_y": 0.68},
|
||||
{"id": "left_thumbstick", "label": "Trackpad", "anchor_x": 0.20, "anchor_y": 0.42},
|
||||
{"id": "right_thumbstick", "label": "Trackpad", "anchor_x": 0.72, "anchor_y": 0.42},
|
||||
{"id": "left_thumbstick_click", "label": "Trackpad Click", "anchor_x": 0.20, "anchor_y": 0.42},
|
||||
{"id": "right_thumbstick_click", "label": "Trackpad Click", "anchor_x": 0.72, "anchor_y": 0.42}
|
||||
]
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 77 KiB |
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"video_options": {
|
||||
"renderer": "opengl",
|
||||
"resolution": "1024x768",
|
||||
"initial_screen_width_m": 1.600000,
|
||||
"initial_screen_distance_m": 2.000000,
|
||||
"game_screen_width_m": 3.400000,
|
||||
"game_screen_distance_m": 2.000000,
|
||||
"screen_width_offset_m": 1.000000,
|
||||
"screen_width_step_m": 0.600000,
|
||||
"screen_distance_offset_m": 1.000000,
|
||||
"screen_distance_step_m": 0.500000
|
||||
},
|
||||
"general": {
|
||||
"language": "english"
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 283 KiB |
@@ -1,132 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<!-- Created with Inkscape (http://www.inkscape.org/) -->
|
||||
|
||||
<svg
|
||||
width="210mm"
|
||||
height="297mm"
|
||||
viewBox="0 0 210 297"
|
||||
version="1.1"
|
||||
id="svg1"
|
||||
inkscape:version="1.3.2 (091e20e, 2023-11-25)"
|
||||
sodipodi:docname="sketch_main_menu.svg"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:svg="http://www.w3.org/2000/svg">
|
||||
<sodipodi:namedview
|
||||
id="namedview1"
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1.0"
|
||||
inkscape:showpageshadow="2"
|
||||
inkscape:pageopacity="0.0"
|
||||
inkscape:pagecheckerboard="0"
|
||||
inkscape:deskcolor="#d1d1d1"
|
||||
inkscape:document-units="mm"
|
||||
inkscape:zoom="2.5287798"
|
||||
inkscape:cx="167.47208"
|
||||
inkscape:cy="123.18194"
|
||||
inkscape:window-width="1920"
|
||||
inkscape:window-height="962"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="33"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="layer1" />
|
||||
<defs
|
||||
id="defs1" />
|
||||
<g
|
||||
inkscape:label="Layer 1"
|
||||
inkscape:groupmode="layer"
|
||||
id="layer1">
|
||||
<rect
|
||||
style="fill:#000080;stroke-width:0.193167"
|
||||
id="rect1"
|
||||
width="63.682735"
|
||||
height="4.0229344"
|
||||
x="4.4946499"
|
||||
y="3.4182527" />
|
||||
<rect
|
||||
style="fill:#b3b3b3;stroke-width:0.543629"
|
||||
id="rect1-5"
|
||||
width="63.682735"
|
||||
height="31.862694"
|
||||
x="4.5049582"
|
||||
y="7.3757277" />
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:1.41111px;line-height:1.25;font-family:FreeSans;-inkscape-font-specification:FreeSans;stroke-width:0.264583"
|
||||
x="25.181696"
|
||||
y="20.839491"
|
||||
id="text2"><tspan
|
||||
sodipodi:role="line"
|
||||
id="tspan2"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:FreeSans;-inkscape-font-specification:FreeSans;stroke-width:0.264583"
|
||||
x="25.181696"
|
||||
y="20.839491">Menu content here</tspan></text>
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:1.41111px;line-height:1.25;font-family:FreeSans;-inkscape-font-specification:FreeSans;fill:#ffffff;stroke-width:0.264583"
|
||||
x="6.1205692"
|
||||
y="5.8075914"
|
||||
id="text3"><tspan
|
||||
sodipodi:role="line"
|
||||
id="tspan3"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:FreeSans;-inkscape-font-specification:FreeSans;fill:#ffffff;stroke-width:0.264583"
|
||||
x="6.1205692"
|
||||
y="5.8075914">Questshock (v3.0.2)</tspan></text>
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:1.41111px;line-height:1.25;font-family:FreeSans;-inkscape-font-specification:FreeSans;fill:#ffffff;stroke-width:0.264583"
|
||||
x="60.855247"
|
||||
y="5.7559261"
|
||||
id="text4"><tspan
|
||||
sodipodi:role="line"
|
||||
id="tspan4"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:FreeSans;-inkscape-font-specification:FreeSans;fill:#ffffff;stroke-width:0.264583"
|
||||
x="60.855247"
|
||||
y="5.7559261">[FPS: 70]</tspan></text>
|
||||
<rect
|
||||
style="fill:#000080;stroke-width:0.156477"
|
||||
id="rect1-2"
|
||||
width="63.682735"
|
||||
height="2.6398373"
|
||||
x="4.471632"
|
||||
y="39.1059" />
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:1.41111px;line-height:1.25;font-family:FreeSans;-inkscape-font-specification:FreeSans;fill:#ffffff;stroke-width:0.264583"
|
||||
x="5.4945946"
|
||||
y="40.859875"
|
||||
id="text3-7"><tspan
|
||||
sodipodi:role="line"
|
||||
id="tspan3-5"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:FreeSans;-inkscape-font-specification:FreeSans;fill:#ffffff;stroke-width:0.264583"
|
||||
x="5.4945946"
|
||||
y="40.859875">Main Menu</tspan></text>
|
||||
<text
|
||||
xml:space="preserve"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:1.41111px;line-height:1.25;font-family:FreeSans;-inkscape-font-specification:FreeSans;fill:#ffffff;stroke-width:0.264583"
|
||||
x="13.718193"
|
||||
y="40.915668"
|
||||
id="text3-7-8"><tspan
|
||||
sodipodi:role="line"
|
||||
id="tspan3-5-9"
|
||||
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:FreeSans;-inkscape-font-specification:FreeSans;fill:#ffffff;stroke-width:0.264583"
|
||||
x="13.718193"
|
||||
y="40.915668">Video Options</tspan></text>
|
||||
<rect
|
||||
style="fill:#1a1a1a;stroke:#ffffff;stroke-width:0.256016"
|
||||
id="rect4"
|
||||
width="0.055807162"
|
||||
height="2.4157476"
|
||||
x="12.918808"
|
||||
y="39.218266" />
|
||||
<rect
|
||||
style="fill:#1a1a1a;stroke:#ffffff;stroke-width:0.256016"
|
||||
id="rect4-1"
|
||||
width="0.055807162"
|
||||
height="2.4157476"
|
||||
x="22.843752"
|
||||
y="39.203552" />
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 5.2 KiB |
Reference in New Issue
Block a user