Compare commits
45
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5cf81aa238 | ||
|
|
b3623c84a5 | ||
|
|
45c1f9004b | ||
|
|
845a395ff1 | ||
|
|
f63653c307 | ||
|
|
5b523c68a7 | ||
|
|
03efbe0681 | ||
|
|
cebd3d81e7 | ||
|
|
de53bebeb8 | ||
|
|
6ccaedd48f | ||
|
|
707856fcf2 | ||
|
|
3c3dc35e1d | ||
|
|
f9820bd226 | ||
|
|
fe2ef92ef3 | ||
|
|
9364768397 | ||
|
|
9c28d5a3b7 | ||
|
|
d5078b978c | ||
|
|
d49594d3fb | ||
|
|
619ce932f9 | ||
|
|
b564d0b1c1 | ||
|
|
fc1fc9f170 | ||
|
|
fd5bcfae90 | ||
|
|
3ee0a53688 | ||
|
|
62c081ecf2 | ||
|
|
d9beb647c1 | ||
|
|
f8f8a80a21 | ||
|
|
ac8023d50f | ||
|
|
769f2f5702 | ||
|
|
2f6839bcc4 | ||
|
|
d37109f5f7 | ||
|
|
15bd9fc43c | ||
|
|
8049e90853 | ||
|
|
e47a2c3e5c | ||
|
|
9512c22e1f | ||
|
|
8a77001016 | ||
|
|
9b0214ee55 | ||
|
|
7ad735552a | ||
|
|
ea35472ef8 | ||
|
|
50c5621d8a | ||
|
|
da275cfd52 | ||
|
|
0f4ee5d965 | ||
|
|
af8c0f5ccd | ||
|
|
8ea370a1d1 | ||
|
|
fcf0de72af | ||
|
|
320c5e6ce5 |
No files matched your search
+2
-1
@@ -106,4 +106,5 @@ yarn.lock
|
||||
/build*
|
||||
/assets/test
|
||||
/tools_old
|
||||
/assets/test.png
|
||||
/assets/test.png
|
||||
/assets/audio/boa.mp3
|
||||
+33
-15
@@ -8,7 +8,10 @@ cmake_minimum_required(VERSION 3.13)
|
||||
|
||||
set(CMAKE_C_STANDARD 11)
|
||||
set(CMAKE_C_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
|
||||
set(CMAKE_MODULE_PATH
|
||||
${CMAKE_MODULE_PATH}
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules
|
||||
)
|
||||
cmake_policy(SET CMP0079 NEW)
|
||||
# set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
|
||||
|
||||
@@ -18,7 +21,9 @@ option(DUSK_NETWORK "Enable network support" ON)
|
||||
set(DUSK_GAME_NAME "Dusk" CACHE STRING "Game display name")
|
||||
set(DUSK_GAME_AUTHOR "YourWishes" CACHE STRING "Game author / coder")
|
||||
set(DUSK_GAME_SHORT_DESCRIPTION "Dusk game" CACHE STRING "One-line description")
|
||||
set(DUSK_GAME_LONG_DESCRIPTION "No description yet." CACHE STRING "Full description")
|
||||
set(DUSK_GAME_LONG_DESCRIPTION
|
||||
"No description yet." CACHE STRING "Full description"
|
||||
)
|
||||
|
||||
# Prep cache
|
||||
set(DUSK_CACHE_TARGET "dusk-target")
|
||||
@@ -32,13 +37,19 @@ set(DUSK_TEMP_DIR "${DUSK_BUILD_DIR}/temp")
|
||||
set(DUSK_TOOLS_DIR "${DUSK_ROOT_DIR}/tools")
|
||||
set(DUSK_DATA_DIR "${DUSK_ROOT_DIR}/data")
|
||||
set(DUSK_ASSETS_DIR "${DUSK_ROOT_DIR}/assets")
|
||||
set(DUSK_BUILT_ASSETS_DIR "${DUSK_BUILD_DIR}/built_assets" CACHE INTERNAL ${DUSK_CACHE_TARGET})
|
||||
set(DUSK_BUILT_ASSETS_DIR "${DUSK_BUILD_DIR}/built_assets"
|
||||
CACHE INTERNAL ${DUSK_CACHE_TARGET}
|
||||
)
|
||||
set(DUSK_GENERATED_HEADERS_DIR "${DUSK_BUILD_DIR}/generated")
|
||||
set(DUSK_BUILD_BINARY ${DUSK_BUILD_DIR}/Dusk CACHE INTERNAL ${DUSK_CACHE_TARGET})
|
||||
set(DUSK_BUILD_BINARY ${DUSK_BUILD_DIR}/Dusk
|
||||
CACHE INTERNAL ${DUSK_CACHE_TARGET}
|
||||
)
|
||||
set(DUSK_ASSETS "" CACHE INTERNAL ${DUSK_CACHE_TARGET})
|
||||
set(DUSK_LIBRARY_TARGET_NAME "DuskCore" CACHE INTERNAL ${DUSK_CACHE_TARGET})
|
||||
set(DUSK_BINARY_TARGET_NAME "Dusk" CACHE INTERNAL ${DUSK_CACHE_TARGET})
|
||||
set(DUSK_ASSETS_ZIP "${DUSK_BUILD_DIR}/dusk.dsk" CACHE INTERNAL ${DUSK_CACHE_TARGET})
|
||||
set(DUSK_ASSETS_ZIP "${DUSK_BUILD_DIR}/dusk.dsk"
|
||||
CACHE INTERNAL ${DUSK_CACHE_TARGET}
|
||||
)
|
||||
|
||||
if(NOT DEFINED DUSK_TARGET_SYSTEM)
|
||||
set(DUSK_TARGET_SYSTEM "linux")
|
||||
@@ -73,7 +84,9 @@ if(DUSK_BUILD_TESTS)
|
||||
${DUSK_LIBRARY_TARGET_NAME}
|
||||
)
|
||||
else()
|
||||
set(DUSK_LIBRARY_TARGET_NAME "${DUSK_BINARY_TARGET_NAME}" CACHE INTERNAL ${DUSK_CACHE_TARGET})
|
||||
set(DUSK_LIBRARY_TARGET_NAME "${DUSK_BINARY_TARGET_NAME}"
|
||||
CACHE INTERNAL ${DUSK_CACHE_TARGET}
|
||||
)
|
||||
endif()
|
||||
|
||||
if(NOT DEFINED DUSK_VERSION)
|
||||
@@ -122,16 +135,21 @@ if(DUSK_BUILD_TESTS)
|
||||
add_subdirectory(test)
|
||||
endif()
|
||||
|
||||
# Build assets
|
||||
file(GLOB_RECURSE DUSK_ASSET_FILES CONFIGURE_DEPENDS "${DUSK_ASSETS_DIR}/*")
|
||||
add_custom_command(
|
||||
OUTPUT "${DUSK_ASSETS_ZIP}"
|
||||
# Build assets. Runs unconditionally on every build (rather than being
|
||||
# gated behind a custom_command's file-level DEPENDS list) because
|
||||
# CONFIGURE_DEPENDS globs only pick up added/removed files on the next
|
||||
# CMake configure, so that approach could miss/lag a rebuild behind an
|
||||
# asset edit. tools.asset.pack itself decides whether anything actually
|
||||
# changed (see its manifest check) and no-ops quickly when nothing did,
|
||||
# so this stays cheap on a build where assets are untouched.
|
||||
add_custom_target(DUSK_ASSETS_BUILT ALL
|
||||
COMMAND ${CMAKE_COMMAND} -E make_directory "${DUSK_ASSETS_DIR}"
|
||||
COMMAND ${CMAKE_COMMAND} -E rm -f "${DUSK_ASSETS_ZIP}"
|
||||
COMMAND ${CMAKE_COMMAND} -E tar "cf" "${DUSK_ASSETS_ZIP}" --format=zip -- .
|
||||
WORKING_DIRECTORY "${DUSK_ASSETS_DIR}"
|
||||
DEPENDS ${DUSK_ASSET_FILES}
|
||||
COMMAND ${Python3_EXECUTABLE} -m tools.asset.pack
|
||||
--input "${DUSK_ASSETS_DIR}"
|
||||
--output "${DUSK_ASSETS_ZIP}"
|
||||
WORKING_DIRECTORY "${DUSK_ROOT_DIR}"
|
||||
BYPRODUCTS "${DUSK_ASSETS_ZIP}"
|
||||
COMMENT "Packing assets into dusk.dsk"
|
||||
VERBATIM
|
||||
)
|
||||
add_custom_target(DUSK_ASSETS_BUILT DEPENDS "${DUSK_ASSETS_ZIP}")
|
||||
add_dependencies(${DUSK_LIBRARY_TARGET_NAME} DUSK_ASSETS_BUILT)
|
||||
@@ -9,15 +9,18 @@ following packages, depending on your system;
|
||||
|
||||
Fedora;
|
||||
```
|
||||
sudo dnf install git make gcc cmake python python-polib python3-pillow python3-dotenv python3-numpy python-qt5 python3-pyopengl SDL2-devel zlib-devel libzip-devel bzip2-devel openssl-devel lzma-sdk-devel xz xz-devel lua-devel
|
||||
sudo dnf install git make gcc cmake python python-polib python3-pillow python3-dotenv python3-numpy python-qt5 python3-pyopengl SDL2-devel zlib-devel libzip-devel bzip2-devel openssl-devel lzma-sdk-devel xz xz-devel lua-devel libmad-devel
|
||||
```
|
||||
`libmad-devel` (used for MP3 decoding) is GPL-licensed and ships in the
|
||||
[RPM Fusion](https://rpmfusion.org/) free repository rather than Fedora's
|
||||
base repos - make sure RPM Fusion is enabled first.
|
||||
|
||||
Ubuntu;
|
||||
```
|
||||
sudo apt-get install git build-essential gcc python python-polib python3-pillow python3-dotenv python3-numpy python3-pyqt5 python3-opengl
|
||||
sudo apt-get install git build-essential gcc python python-polib python3-pillow python3-dotenv python3-numpy python3-pyqt5 python3-opengl libmad0-dev
|
||||
```
|
||||
|
||||
Arch Linux;
|
||||
```
|
||||
sudo pacman -S git base-devel gcc python python-polib python-pillow python-dotenv python-numpy python-pyqt5 python-opengl
|
||||
sudo pacman -S git base-devel gcc python python-polib python-pillow python-dotenv python-numpy python-pyqt5 python-opengl libmad
|
||||
```
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,7 +1,6 @@
|
||||
{
|
||||
"items": [
|
||||
// Boot check: make sure a save device is available before handing off
|
||||
// to the main menu.
|
||||
// First thing, try and find a save device, used for settings and what not.
|
||||
{
|
||||
"type": "MODAL",
|
||||
"title": "initial.checking_save.title",
|
||||
@@ -14,13 +13,13 @@
|
||||
{
|
||||
"type": "SAVE_DEVICE_CHECK",
|
||||
"successMarker": "CONTINUE",
|
||||
"failureMarker": "NO_DEVICE"
|
||||
"failureMarker": "SAVE_DEVICE_NOT_FOUND"
|
||||
},
|
||||
|
||||
// No save device found - offer to retry or continue without saving.
|
||||
// No save device found
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "NO_DEVICE"
|
||||
"name": "SAVE_DEVICE_NOT_FOUND"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_CLOSE"
|
||||
@@ -32,7 +31,7 @@
|
||||
"options": [
|
||||
{
|
||||
"text": "initial.no_device.retry",
|
||||
"marker": "RETRY"
|
||||
"marker": "SAVE_DEVICE_RETRY"
|
||||
},
|
||||
{
|
||||
"text": "initial.no_device.continue",
|
||||
@@ -41,9 +40,10 @@
|
||||
]
|
||||
},
|
||||
|
||||
// Save device not found, user to retry, just close modal and loop
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "RETRY"
|
||||
"name": "SAVE_DEVICE_RETRY"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_CLOSE"
|
||||
@@ -52,8 +52,7 @@
|
||||
"type": "RESTART"
|
||||
},
|
||||
|
||||
// Save device found (or continuing without one) - hand off to the
|
||||
// main menu scene.
|
||||
// Save device found (or continuing without one)
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "CONTINUE"
|
||||
@@ -62,8 +61,8 @@
|
||||
"type": "MODAL_CLOSE"
|
||||
},
|
||||
{
|
||||
"type": "SCENE",
|
||||
"sceneType": "MAIN_MENU"
|
||||
"type": "CUTSCENE",
|
||||
"name": "main_menu"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "MAIN_MENU_IDLE"
|
||||
},
|
||||
{
|
||||
"type": "UI_SHOW",
|
||||
"name": "main_menu"
|
||||
},
|
||||
|
||||
// Options button goes here - no options screen yet, so this is just
|
||||
// an alias landing right back on the idle loop below.
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "OPTIONS"
|
||||
},
|
||||
{
|
||||
"type": "IDLE"
|
||||
},
|
||||
|
||||
// New Game button goes here.
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "NEW_GAME"
|
||||
},
|
||||
{
|
||||
"type": "MODAL",
|
||||
"title": "main_menu.checking_save.title",
|
||||
"message": "main_menu.checking_save.message"
|
||||
},
|
||||
{
|
||||
"type": "WAIT",
|
||||
"seconds": 0.2
|
||||
},
|
||||
{
|
||||
"type": "SAVE_DEVICE_CHECK",
|
||||
"successMarker": "SAVE_DEVICE_FOUND",
|
||||
"failureMarker": "SAVE_DEVICE_NOT_FOUND"
|
||||
},
|
||||
|
||||
// Save device not found
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "SAVE_DEVICE_NOT_FOUND"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_CLOSE"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_OPTIONS_MARKERS",
|
||||
"title": "main_menu.no_device.title",
|
||||
"message": "main_menu.no_device.message",
|
||||
"options": [
|
||||
{
|
||||
"text": "main_menu.no_device.retry",
|
||||
"marker": "NEW_GAME"
|
||||
},
|
||||
{
|
||||
"text": "main_menu.no_device.continue",
|
||||
"marker": "SAVE_DEVICE_FOUND"
|
||||
}
|
||||
]
|
||||
},
|
||||
|
||||
// Save data failed to load (e.g. corrupt/unreadable) - only option is
|
||||
// to retry, no "continue without saving" here since we already know a
|
||||
// device is present.
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "LOAD_ERROR"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_OPTIONS_MARKERS",
|
||||
"title": "main_menu.save_load_error.title",
|
||||
"message": "main_menu.save_load_error.message",
|
||||
"options": [
|
||||
{
|
||||
"text": "main_menu.save_load_error.retry",
|
||||
"marker": "NEW_GAME"
|
||||
}
|
||||
]
|
||||
},
|
||||
|
||||
// Quit Game button goes here. Cancelling jumps back to
|
||||
// MAIN_MENU_IDLE; confirming falls through to QUIT_GAME, which
|
||||
// ends the process directly.
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "QUIT"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_OPTIONS_MARKERS",
|
||||
"title": "main_menu.quit_confirm",
|
||||
"options": [
|
||||
{
|
||||
"text": "ui.confirm.confirm",
|
||||
"marker": "QUIT_CONFIRMED"
|
||||
},
|
||||
{
|
||||
"text": "ui.confirm.cancel",
|
||||
"marker": "MAIN_MENU_IDLE"
|
||||
}
|
||||
]
|
||||
},
|
||||
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "QUIT_CONFIRMED"
|
||||
},
|
||||
{
|
||||
"type": "QUIT_GAME"
|
||||
},
|
||||
|
||||
// main menu just listens for cutscene ending to show the select save modal
|
||||
// so we have that here.
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "SAVE_DEVICE_FOUND"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_CLOSE"
|
||||
},
|
||||
{
|
||||
"type": "SAVE_LOAD_ALL_SLOTS",
|
||||
"successMarker": "LOADED",
|
||||
"failureMarker": "LOAD_ERROR"
|
||||
},
|
||||
|
||||
// Must be the very last item - falling off the end here is what
|
||||
// completes the cutscene and fires uiMainMenuOpenSelectSave (see
|
||||
// cutsceneSystemSetOnComplete in ui/screen/mainmenu/uimainmenu.c).
|
||||
// Placing this anywhere earlier would fall through into whatever
|
||||
// comes next instead (e.g. the QUIT block, if placed just before it).
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "LOADED"
|
||||
}
|
||||
]
|
||||
}
|
||||
Binary file not shown.
@@ -1,92 +0,0 @@
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"type": "MODAL",
|
||||
"title": "main_menu.checking_save.title",
|
||||
"message": "main_menu.checking_save.message"
|
||||
},
|
||||
{
|
||||
"type": "WAIT",
|
||||
"seconds": 0.2
|
||||
},
|
||||
{
|
||||
"type": "SAVE_DEVICE_CHECK",
|
||||
"successMarker": "CONTINUE",
|
||||
"failureMarker": "NO_DEVICE"
|
||||
},
|
||||
|
||||
// No save device found - offer to retry or continue without saving.
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "NO_DEVICE"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_CLOSE"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_OPTIONS_MARKERS",
|
||||
"title": "main_menu.no_device.title",
|
||||
"message": "main_menu.no_device.message",
|
||||
"options": [
|
||||
{
|
||||
"text": "main_menu.no_device.retry",
|
||||
"marker": "RETRY"
|
||||
},
|
||||
{
|
||||
"text": "main_menu.no_device.continue",
|
||||
"marker": "CONTINUE"
|
||||
}
|
||||
]
|
||||
},
|
||||
|
||||
// Retry
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "RETRY"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_CLOSE"
|
||||
},
|
||||
{
|
||||
"type": "RESTART"
|
||||
},
|
||||
|
||||
// Save device found - attempt to load all save slots.
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "CONTINUE"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_CLOSE"
|
||||
},
|
||||
{
|
||||
"type": "SAVE_LOAD_ALL_SLOTS",
|
||||
"successMarker": "LOADED",
|
||||
"failureMarker": "LOAD_ERROR"
|
||||
},
|
||||
|
||||
// Save data failed to load (e.g. corrupt/unreadable) - only option is
|
||||
// to retry, no "continue without saving" here since we already know a
|
||||
// device is present.
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "LOAD_ERROR"
|
||||
},
|
||||
{
|
||||
"type": "MODAL_OPTIONS_MARKERS",
|
||||
"title": "main_menu.save_load_error.title",
|
||||
"message": "main_menu.save_load_error.message",
|
||||
"options": [
|
||||
{
|
||||
"text": "main_menu.save_load_error.retry",
|
||||
"marker": "RETRY"
|
||||
}
|
||||
]
|
||||
},
|
||||
|
||||
{
|
||||
"type": "MARKER",
|
||||
"name": "LOADED"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
# Copyright (c) 2026 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# NOTE: libmad itself is GPL-licensed (see https://www.underbit.com/products/mad/),
|
||||
# not MIT like the rest of this project. Any binary linking it must comply
|
||||
# with the GPL - a deliberate tradeoff accepted for MP3 decode correctness
|
||||
# (see audiostreammp3decodersw.c's own comment on why minimp3 wasn't enough).
|
||||
|
||||
find_path(LIBMAD_INCLUDE_DIR NAMES mad.h)
|
||||
mark_as_advanced(LIBMAD_INCLUDE_DIR)
|
||||
|
||||
find_library(LIBMAD_LIBRARY NAMES mad)
|
||||
mark_as_advanced(LIBMAD_LIBRARY)
|
||||
|
||||
include(FindPackageHandleStandardArgs)
|
||||
find_package_handle_standard_args(
|
||||
libmad
|
||||
REQUIRED_VARS
|
||||
LIBMAD_LIBRARY
|
||||
LIBMAD_INCLUDE_DIR
|
||||
)
|
||||
|
||||
if(libmad_FOUND AND NOT TARGET libmad::mad)
|
||||
add_library(libmad::mad UNKNOWN IMPORTED)
|
||||
set_target_properties(libmad::mad
|
||||
PROPERTIES
|
||||
INTERFACE_INCLUDE_DIRECTORIES ${LIBMAD_INCLUDE_DIR}
|
||||
IMPORTED_LOCATION ${LIBMAD_LIBRARY}
|
||||
)
|
||||
endif()
|
||||
@@ -61,6 +61,8 @@ target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
|
||||
zstd
|
||||
z
|
||||
lzma
|
||||
asnd
|
||||
mad
|
||||
)
|
||||
|
||||
if(DUSK_DOLPHIN_BUILD_TYPE STREQUAL "ISO")
|
||||
|
||||
@@ -30,6 +30,7 @@ target_link_libraries(${DUSK_BINARY_TARGET_NAME} PUBLIC
|
||||
pspgu
|
||||
pspaudio
|
||||
pspaudiolib
|
||||
pspmp3
|
||||
psputility
|
||||
pspvfpu
|
||||
pspvram
|
||||
|
||||
@@ -5,7 +5,7 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
|
||||
)
|
||||
|
||||
# Wii save storage method - see src/duskdolphin/save/savedeviceplatform.h.
|
||||
set(DUSK_SAVE_WII_METHOD "NAND" CACHE STRING
|
||||
set(DUSK_SAVE_WII_METHOD "SD" CACHE STRING
|
||||
"Wii save storage: NAND (internal storage via ISFS), CARD (GameCube-\
|
||||
compatible memory card emulation), or SD (SD card via libfat)"
|
||||
)
|
||||
|
||||
+7
-2
@@ -13,6 +13,7 @@ if(DUSK_TARGET_SYSTEM STREQUAL "linux" OR DUSK_TARGET_SYSTEM STREQUAL "knulli")
|
||||
add_subdirectory(dusklinux)
|
||||
add_subdirectory(dusksdl2)
|
||||
add_subdirectory(duskgl)
|
||||
add_subdirectory(duskmad)
|
||||
|
||||
elseif(DUSK_TARGET_SYSTEM STREQUAL "psp")
|
||||
add_subdirectory(duskpsp)
|
||||
@@ -24,7 +25,11 @@ elseif(DUSK_TARGET_SYSTEM STREQUAL "vita")
|
||||
add_subdirectory(dusksdl2)
|
||||
add_subdirectory(duskgl)
|
||||
|
||||
elseif(DUSK_TARGET_SYSTEM STREQUAL "wii" OR DUSK_TARGET_SYSTEM STREQUAL "gamecube")
|
||||
elseif(
|
||||
DUSK_TARGET_SYSTEM STREQUAL "wii" OR
|
||||
DUSK_TARGET_SYSTEM STREQUAL "gamecube"
|
||||
)
|
||||
add_subdirectory(duskdolphin)
|
||||
|
||||
add_subdirectory(duskmad)
|
||||
|
||||
endif()
|
||||
+14
-2
@@ -14,12 +14,21 @@ if(NOT libzip_FOUND)
|
||||
target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC zip)
|
||||
endif()
|
||||
|
||||
# assetdsk.c calls crc32() directly (to verify dusk.dsk archive checksums).
|
||||
# find_package(libzip) above already resolves ZLIB as a side effect, so
|
||||
# ZLIB_FOUND may already be true without ZLIB::ZLIB having been linked to
|
||||
# our target - link it unconditionally rather than guarding on ZLIB_FOUND.
|
||||
find_package(ZLIB REQUIRED)
|
||||
target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC ZLIB::ZLIB)
|
||||
|
||||
if(NOT stb_image_FOUND)
|
||||
find_package(stb REQUIRED)
|
||||
if(STB_IMAGE_FOUND)
|
||||
target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC stb_image)
|
||||
else()
|
||||
message(FATAL_ERROR "stb_image not found. Please ensure stb is correctly fetched.")
|
||||
message(FATAL_ERROR
|
||||
"stb_image not found. Please ensure stb is correctly fetched."
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
@@ -28,7 +37,9 @@ if(NOT yyjson_FOUND)
|
||||
if(yyjson_FOUND)
|
||||
target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC yyjson::yyjson)
|
||||
else()
|
||||
message(FATAL_ERROR "yyjson not found. Please ensure yyjson is correctly fetched.")
|
||||
message(FATAL_ERROR
|
||||
"yyjson not found. Please ensure yyjson is correctly fetched."
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
@@ -55,6 +66,7 @@ target_sources(${DUSK_BINARY_TARGET_NAME}
|
||||
add_subdirectory(animation)
|
||||
add_subdirectory(assert)
|
||||
add_subdirectory(asset)
|
||||
add_subdirectory(audio)
|
||||
add_subdirectory(console)
|
||||
add_subdirectory(display)
|
||||
add_subdirectory(log)
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
// Copyright (c) 2026 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "animation.h"
|
||||
#include "assert/assert.h"
|
||||
@@ -14,9 +16,9 @@ void animationInit(
|
||||
uint16_t *keyframeCounts,
|
||||
const uint16_t layerCount
|
||||
) {
|
||||
assertNotNull(anim, "Animation pointer cannot be null.");
|
||||
assertNotNull(keyframes, "Keyframes pointer cannot be null.");
|
||||
assertNotNull(keyframeCounts, "Keyframe counts pointer cannot be null.");
|
||||
assertNotNull(anim, "Animation pointer cannot be NULL.");
|
||||
assertNotNull(keyframes, "Keyframes pointer cannot be NULL.");
|
||||
assertNotNull(keyframeCounts, "Keyframe counts pointer cannot be NULL.");
|
||||
assertTrue(layerCount > 0, "Layer count must be greater than zero.");
|
||||
|
||||
memoryZero(anim, sizeof(animation_t));
|
||||
@@ -49,7 +51,7 @@ void animationInit(
|
||||
}
|
||||
|
||||
float_t animationGetLayerValue(const animation_t *anim, const uint16_t layer) {
|
||||
assertNotNull(anim, "Animation pointer cannot be null.");
|
||||
assertNotNull(anim, "Animation pointer cannot be NULL.");
|
||||
assertTrue(layer < anim->layerCount, "Layer index out of bounds.");
|
||||
|
||||
uint16_t keyframeCount = anim->keyframeCounts[layer];
|
||||
@@ -61,7 +63,7 @@ void animationUpdate(
|
||||
animation_t *anim,
|
||||
const float_t deltaTime
|
||||
) {
|
||||
assertNotNull(anim, "Animation pointer cannot be null.");
|
||||
assertNotNull(anim, "Animation pointer cannot be NULL.");
|
||||
assertTrue(deltaTime >= 0, "Delta time must be non-negative.");
|
||||
|
||||
bool_t justCompleted = false;
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
// Copyright (c) 2026 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "keyframe.h"
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
// Copyright (c) 2026 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "easing.h"
|
||||
#include "assert/assert.h"
|
||||
|
||||
+123
-4
@@ -1,7 +1,9 @@
|
||||
// Copyright (c) 2026 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "dusk.h"
|
||||
@@ -45,19 +47,136 @@ extern const easingfn_t EASING_FUNCTIONS[EASING_COUNT];
|
||||
*/
|
||||
float_t easingApply(const easingtype_t type, const float_t t);
|
||||
|
||||
/**
|
||||
* No easing - returns t unchanged.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, equal to t.
|
||||
*/
|
||||
float_t easingLinear(const float_t t);
|
||||
|
||||
/**
|
||||
* Sinusoidal easing in: starts slow, accelerates to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingInSine(const float_t t);
|
||||
|
||||
/**
|
||||
* Sinusoidal easing out: starts fast, decelerates to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingOutSine(const float_t t);
|
||||
|
||||
/**
|
||||
* Sinusoidal easing in and out: slow at both ends, fastest in
|
||||
* the middle.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingInOutSine(const float_t t);
|
||||
|
||||
/**
|
||||
* Quadratic easing in: starts slow, accelerates to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingInQuad(const float_t t);
|
||||
|
||||
/**
|
||||
* Quadratic easing out: starts fast, decelerates to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingOutQuad(const float_t t);
|
||||
|
||||
/**
|
||||
* Quadratic easing in and out: slow at both ends, fastest in the
|
||||
* middle.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingInOutQuad(const float_t t);
|
||||
|
||||
/**
|
||||
* Cubic easing in: starts slow, accelerates to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingInCubic(const float_t t);
|
||||
|
||||
/**
|
||||
* Cubic easing out: starts fast, decelerates to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingOutCubic(const float_t t);
|
||||
|
||||
/**
|
||||
* Cubic easing in and out: slow at both ends, fastest in the
|
||||
* middle.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingInOutCubic(const float_t t);
|
||||
|
||||
/**
|
||||
* Quartic easing in: starts slow, accelerates to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingInQuart(const float_t t);
|
||||
|
||||
/**
|
||||
* Quartic easing out: starts fast, decelerates to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingOutQuart(const float_t t);
|
||||
|
||||
/**
|
||||
* Quartic easing in and out: slow at both ends, fastest in the
|
||||
* middle.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, in the range [0, 1].
|
||||
*/
|
||||
float_t easingInOutQuart(const float_t t);
|
||||
|
||||
/**
|
||||
* Back easing in: overshoots backwards before moving to the end.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, which may fall below 0.
|
||||
*/
|
||||
float_t easingInBack(const float_t t);
|
||||
|
||||
/**
|
||||
* Back easing out: overshoots past the end before settling on it.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, which may rise above 1.
|
||||
*/
|
||||
float_t easingOutBack(const float_t t);
|
||||
|
||||
/**
|
||||
* Back easing in and out: overshoots backwards at the start and
|
||||
* past the end before settling on it.
|
||||
*
|
||||
* @param t The input time, in the range [0, 1].
|
||||
* @return The eased value, which may fall below 0 or rise above 1.
|
||||
*/
|
||||
float_t easingInOutBack(const float_t t);
|
||||
|
||||
@@ -14,7 +14,7 @@ float_t keyframeGetValue(
|
||||
const uint32_t keyframeCount,
|
||||
const float_t time
|
||||
) {
|
||||
assertNotNull(keyframes, "Keyframes pointer cannot be null.");
|
||||
assertNotNull(keyframes, "Keyframes pointer cannot be NULL.");
|
||||
assertTrue(keyframeCount > 0, "Keyframe count must be more than 0.");
|
||||
assertTrue(time >= 0, "Time must be non-negative.");
|
||||
#ifdef DUSK_ASSERTIONS
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
// Copyright (c) 2026 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "easing.h"
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
asset.c
|
||||
assetdsk.c
|
||||
assetfile.c
|
||||
)
|
||||
|
||||
|
||||
+33
-8
@@ -19,13 +19,17 @@ asset_t ASSET;
|
||||
errorret_t assetInit(void) {
|
||||
memoryZero(&ASSET, sizeof(asset_t));
|
||||
|
||||
threadMutexInit(&ASSET.zipLock);
|
||||
|
||||
for(size_t i = 0; i < ASSET_LOADING_COUNT_MAX; i++) {
|
||||
threadMutexInit(&ASSET.loading[i].mutex);
|
||||
}
|
||||
|
||||
// assetInitPlatform must either define ASSET.zip or throw an error.
|
||||
// assetInitPlatform must either define both ASSET.zip/ASSET.zipStored or
|
||||
// throw an error.
|
||||
errorChain(assetInitPlatform());
|
||||
assertNotNull(ASSET.zip, "Asset zip null without error.");
|
||||
assertNotNull(ASSET.zip, "Asset zip NULL without error.");
|
||||
assertNotNull(ASSET.zipStored, "Asset stored zip NULL without error.");
|
||||
threadInit(&ASSET.loadThread, assetUpdateAsync);
|
||||
threadStart(&ASSET.loadThread);
|
||||
|
||||
@@ -35,9 +39,12 @@ errorret_t assetInit(void) {
|
||||
bool_t assetFileExists(const char_t *filename) {
|
||||
assertStrLenMax(filename, ASSET_FILE_NAME_MAX, "Filename too long.");
|
||||
|
||||
zip_int64_t idx = zip_name_locate(ASSET.zip, filename, 0);
|
||||
if(idx < 0) return false;
|
||||
return true;
|
||||
threadMutexLock(&ASSET.zipLock);
|
||||
bool_t found =
|
||||
zip_name_locate(ASSET.zip, filename, 0) >= 0 ||
|
||||
zip_name_locate(ASSET.zipStored, filename, 0) >= 0;
|
||||
threadMutexUnlock(&ASSET.zipLock);
|
||||
return found;
|
||||
}
|
||||
|
||||
assetentry_t * assetGetEntry(
|
||||
@@ -117,6 +124,15 @@ errorret_t assetRequireLoaded(assetentry_t *entry) {
|
||||
assetEntryLock(entry);
|
||||
|
||||
while(entry->state != ASSET_ENTRY_STATE_LOADED) {
|
||||
// A failed load transitions to ERROR, not LOADED - without this check
|
||||
// this loop spins forever on any load failure (assetUpdate() itself
|
||||
// still returns OK, since a single asset failing isn't meant to halt
|
||||
// the whole update loop - see its ASSET_ENTRY_STATE_ERROR handling).
|
||||
if(entry->state == ASSET_ENTRY_STATE_ERROR) {
|
||||
assetEntryUnlock(entry);
|
||||
errorThrow("Failed to load asset: %s", entry->name);
|
||||
}
|
||||
|
||||
usleep(1000);
|
||||
errorret_t ret = assetUpdate();
|
||||
if(errorIsNotOk(ret)) {
|
||||
@@ -348,7 +364,9 @@ errorret_t assetUpdate(void) {
|
||||
assetentry_t *errEntry = loading->entry;
|
||||
loading->entry = NULL;
|
||||
threadMutexUnlock(&loading->mutex);
|
||||
if(errEntry->onError) errEntry->onError(errEntry, errEntry->onErrorUser);
|
||||
if(errEntry->onError) {
|
||||
errEntry->onError(errEntry, errEntry->onErrorUser);
|
||||
}
|
||||
loading++;
|
||||
break;
|
||||
}
|
||||
@@ -427,14 +445,21 @@ errorret_t assetDispose(void) {
|
||||
|
||||
errorChain(assetReapUnused());
|
||||
|
||||
// Cleanup zip file.
|
||||
// Cleanup zip files.
|
||||
if(ASSET.zip != NULL) {
|
||||
if(zip_close(ASSET.zip) != 0) {
|
||||
errorThrow("Failed to close asset zip archive.");
|
||||
errorThrow("Failed to close compressed asset zip archive.");
|
||||
}
|
||||
ASSET.zip = NULL;
|
||||
}
|
||||
if(ASSET.zipStored != NULL) {
|
||||
if(zip_close(ASSET.zipStored) != 0) {
|
||||
errorThrow("Failed to close stored asset zip archive.");
|
||||
}
|
||||
ASSET.zipStored = NULL;
|
||||
}
|
||||
|
||||
errorChain(assetDisposePlatform());
|
||||
threadMutexDispose(&ASSET.zipLock);
|
||||
errorOk();
|
||||
}
|
||||
@@ -26,10 +26,44 @@
|
||||
#define ASSET_LOADING_COUNT_MAX 10
|
||||
#define ASSET_ENTRY_COUNT_MAX 64
|
||||
|
||||
#define ASSET_BASE_DIRECTORY_MAX 256
|
||||
|
||||
typedef struct asset_s {
|
||||
// Compressed (DEFLATE) archive - expected to hold the bulk of a game's
|
||||
// binary assets. Looked up first by assetFileInit().
|
||||
zip_t *zip;
|
||||
|
||||
// Stored (uncompressed) archive - expected to hold small files that need
|
||||
// reliable repeated seeking/re-opening (e.g. locale strings), which
|
||||
// libzip only supports reliably for uncompressed entries. Looked up by
|
||||
// assetFileInit() only if the name isn't found in `zip`.
|
||||
zip_t *zipStored;
|
||||
|
||||
// Directory dusk.dsk was actually found/opened in (on PSP, the directory
|
||||
// EBOOT.PBP lives in, since dusk.dsk is embedded inside it rather than a
|
||||
// loose file) - populated by each platform's own assetInitXxx() once it
|
||||
// locates the file. Save devices that persist to a real filesystem path
|
||||
// (Linux, PSP, Wii SD) use this as their base directory instead of a
|
||||
// separate hardcoded location, so saves live next to wherever the game
|
||||
// itself was actually launched from rather than some unrelated fixed
|
||||
// path. Not meaningful for devices with no filesystem-path concept at
|
||||
// all (GameCube/Wii memory card, Wii NAND's ISFS namespace).
|
||||
char_t baseDirectory[ASSET_BASE_DIRECTORY_MAX];
|
||||
|
||||
assetplatform_t platform;
|
||||
|
||||
// Guards every libzip call against ASSET.zip/ASSET.zipStored (zip_fopen,
|
||||
// zip_fread, zip_fclose, zip_fseek, zip_stat, zip_name_locate - see
|
||||
// assetfile.c/assetFileExists). libzip is documented as not thread-safe,
|
||||
// and this asset system genuinely calls it from multiple real threads at
|
||||
// once (main thread, the background load thread below, and - on
|
||||
// platforms that stream PCM from an asset on their own thread, like PSP
|
||||
// - an audio feeder thread too). Confirmed necessary on real PSP
|
||||
// hardware: without this lock, concurrent zip_fopen/zip_fread calls from
|
||||
// different threads corrupted reads (EINVAL, then zlib data errors) once
|
||||
// dusk.dsk stopped being read entirely into memory up front.
|
||||
threadmutex_t zipLock;
|
||||
|
||||
// Background loading thread.
|
||||
thread_t loadThread;
|
||||
|
||||
|
||||
@@ -0,0 +1,289 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "assetdsk.h"
|
||||
#include "util/memory.h"
|
||||
#include "util/endian.h"
|
||||
#include "assert/assert.h"
|
||||
#include <zlib.h>
|
||||
|
||||
errorret_t assetDskParseHeader(
|
||||
const uint8_t *bytes,
|
||||
const size_t bytesSize,
|
||||
assetdskheader_t *outHeader
|
||||
) {
|
||||
assertNotNull(bytes, "Bytes cannot be NULL.");
|
||||
assertNotNull(outHeader, "Out header cannot be NULL.");
|
||||
|
||||
if(bytesSize < ASSET_DSK_HEADER_SIZE) {
|
||||
errorThrow("dusk.dsk header is truncated.");
|
||||
}
|
||||
|
||||
if(memoryCompare(bytes, ASSET_DSK_MAGIC, ASSET_DSK_MAGIC_SIZE) != 0) {
|
||||
errorThrow("dusk.dsk has an invalid magic header.");
|
||||
}
|
||||
|
||||
// Every field is a little-endian uint32_t regardless of host - convert
|
||||
// to host order (a no-op on little-endian hosts, a real byteswap on
|
||||
// Dolphin's big-endian PowerPC).
|
||||
uint32_t fields[7];
|
||||
memoryCopy(fields, bytes + ASSET_DSK_MAGIC_SIZE, sizeof(fields));
|
||||
for(uint8_t i = 0; i < 7; i++) {
|
||||
fields[i] = endianLittleToHost32(fields[i]);
|
||||
}
|
||||
|
||||
const uint32_t version = fields[0];
|
||||
if(version != ASSET_DSK_VERSION) {
|
||||
errorThrow("dusk.dsk has an unsupported version: %u", version);
|
||||
}
|
||||
|
||||
outHeader->compressedOffset = fields[1];
|
||||
outHeader->compressedSize = fields[2];
|
||||
outHeader->compressedChecksum = fields[3];
|
||||
outHeader->storedOffset = fields[4];
|
||||
outHeader->storedSize = fields[5];
|
||||
outHeader->storedChecksum = fields[6];
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetDskOpenFromPath(
|
||||
const char_t *path,
|
||||
zip_t **outCompressed,
|
||||
zip_t **outStored
|
||||
) {
|
||||
errorChain(assetDskOpenFromPathRange(
|
||||
path, 0, SIZE_MAX, outCompressed, outStored
|
||||
));
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetDskOpenFromPathRange(
|
||||
const char_t *path,
|
||||
const size_t baseOffset,
|
||||
const size_t baseSize,
|
||||
zip_t **outCompressed,
|
||||
zip_t **outStored
|
||||
) {
|
||||
assertNotNull(path, "Path cannot be NULL.");
|
||||
assertNotNull(outCompressed, "Out compressed cannot be NULL.");
|
||||
assertNotNull(outStored, "Out stored cannot be NULL.");
|
||||
|
||||
*outCompressed = NULL;
|
||||
*outStored = NULL;
|
||||
|
||||
FILE *headerFile = fopen(path, "rb");
|
||||
if(headerFile == NULL) {
|
||||
errorThrow("Failed to open dusk.dsk: %s", path);
|
||||
}
|
||||
|
||||
if(fseek(headerFile, (long) baseOffset, SEEK_SET) != 0) {
|
||||
fclose(headerFile);
|
||||
errorThrow("Failed to seek to dusk.dsk range in file: %s", path);
|
||||
}
|
||||
|
||||
uint8_t headerBytes[ASSET_DSK_HEADER_SIZE];
|
||||
size_t headerRead = fread(headerBytes, 1, sizeof(headerBytes), headerFile);
|
||||
fclose(headerFile);
|
||||
if(headerRead != sizeof(headerBytes)) {
|
||||
errorThrow("Failed to read dusk.dsk header: %s", path);
|
||||
}
|
||||
|
||||
assetdskheader_t header;
|
||||
errorChain(assetDskParseHeader(headerBytes, sizeof(headerBytes), &header));
|
||||
|
||||
if(
|
||||
(size_t) header.compressedOffset + header.compressedSize > baseSize ||
|
||||
(size_t) header.storedOffset + header.storedSize > baseSize
|
||||
) {
|
||||
errorThrow("dusk.dsk header describes ranges beyond its containing file.");
|
||||
}
|
||||
|
||||
zip_error_t zipError;
|
||||
zip_error_init(&zipError);
|
||||
|
||||
zip_source_t *compressedSource = zip_source_file_create(
|
||||
path,
|
||||
(zip_uint64_t) (baseOffset + header.compressedOffset),
|
||||
(zip_int64_t) header.compressedSize,
|
||||
&zipError
|
||||
);
|
||||
if(compressedSource == NULL) {
|
||||
errorThrow(
|
||||
"Failed to create compressed dusk.dsk source: %s",
|
||||
zip_error_strerror(&zipError)
|
||||
);
|
||||
}
|
||||
|
||||
*outCompressed =
|
||||
zip_open_from_source(compressedSource, ZIP_RDONLY, &zipError);
|
||||
if(*outCompressed == NULL) {
|
||||
zip_source_free(compressedSource);
|
||||
errorThrow(
|
||||
"Failed to open compressed dusk.dsk archive: %s",
|
||||
zip_error_strerror(&zipError)
|
||||
);
|
||||
}
|
||||
|
||||
zip_source_t *storedSource = zip_source_file_create(
|
||||
path,
|
||||
(zip_uint64_t) (baseOffset + header.storedOffset),
|
||||
(zip_int64_t) header.storedSize,
|
||||
&zipError
|
||||
);
|
||||
if(storedSource == NULL) {
|
||||
zip_close(*outCompressed);
|
||||
*outCompressed = NULL;
|
||||
errorThrow(
|
||||
"Failed to create stored dusk.dsk source: %s",
|
||||
zip_error_strerror(&zipError)
|
||||
);
|
||||
}
|
||||
|
||||
*outStored = zip_open_from_source(storedSource, ZIP_RDONLY, &zipError);
|
||||
if(*outStored == NULL) {
|
||||
zip_source_free(storedSource);
|
||||
zip_close(*outCompressed);
|
||||
*outCompressed = NULL;
|
||||
errorThrow(
|
||||
"Failed to open stored dusk.dsk archive: %s",
|
||||
zip_error_strerror(&zipError)
|
||||
);
|
||||
}
|
||||
|
||||
// The stored archive is small by convention, so verifying its checksum
|
||||
// here (one extra small read) is cheap; the compressed archive isn't
|
||||
// checked since it's meant to be read lazily/on-demand from here on.
|
||||
uint8_t *storedBytes = (uint8_t *) memoryAllocate(header.storedSize);
|
||||
FILE *storedFile = fopen(path, "rb");
|
||||
if(storedFile == NULL) {
|
||||
memoryFree(storedBytes);
|
||||
zip_close(*outStored);
|
||||
zip_close(*outCompressed);
|
||||
*outStored = NULL;
|
||||
*outCompressed = NULL;
|
||||
errorThrow(
|
||||
"Failed to re-open dusk.dsk to verify stored checksum: %s", path
|
||||
);
|
||||
}
|
||||
fseek(storedFile, (long) (baseOffset + header.storedOffset), SEEK_SET);
|
||||
size_t storedRead = fread(storedBytes, 1, header.storedSize, storedFile);
|
||||
fclose(storedFile);
|
||||
if(storedRead != header.storedSize) {
|
||||
memoryFree(storedBytes);
|
||||
zip_close(*outStored);
|
||||
zip_close(*outCompressed);
|
||||
*outStored = NULL;
|
||||
*outCompressed = NULL;
|
||||
errorThrow(
|
||||
"Failed to read dusk.dsk stored archive to verify checksum: %s", path
|
||||
);
|
||||
}
|
||||
|
||||
uint32_t checksum =
|
||||
(uint32_t) crc32(0L, storedBytes, (uInt) header.storedSize);
|
||||
memoryFree(storedBytes);
|
||||
if(checksum != header.storedChecksum) {
|
||||
zip_close(*outStored);
|
||||
zip_close(*outCompressed);
|
||||
*outStored = NULL;
|
||||
*outCompressed = NULL;
|
||||
errorThrow(
|
||||
"dusk.dsk stored archive failed checksum verification: %s", path
|
||||
);
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetDskOpenFromBuffer(
|
||||
uint8_t *buffer,
|
||||
const size_t bufferSize,
|
||||
zip_t **outCompressed,
|
||||
zip_t **outStored
|
||||
) {
|
||||
assertNotNull(buffer, "Buffer cannot be NULL.");
|
||||
assertNotNull(outCompressed, "Out compressed cannot be NULL.");
|
||||
assertNotNull(outStored, "Out stored cannot be NULL.");
|
||||
|
||||
*outCompressed = NULL;
|
||||
*outStored = NULL;
|
||||
|
||||
assetdskheader_t header;
|
||||
errorChain(assetDskParseHeader(buffer, bufferSize, &header));
|
||||
|
||||
if(
|
||||
(size_t) header.compressedOffset + header.compressedSize > bufferSize ||
|
||||
(size_t) header.storedOffset + header.storedSize > bufferSize
|
||||
) {
|
||||
errorThrow("dusk.dsk header describes ranges beyond the buffer.");
|
||||
}
|
||||
|
||||
uint32_t compressedChecksum = (uint32_t) crc32(
|
||||
0L, buffer + header.compressedOffset, (uInt) header.compressedSize
|
||||
);
|
||||
if(compressedChecksum != header.compressedChecksum) {
|
||||
errorThrow("dusk.dsk compressed archive failed checksum verification.");
|
||||
}
|
||||
|
||||
uint32_t storedChecksum = (uint32_t) crc32(
|
||||
0L, buffer + header.storedOffset, (uInt) header.storedSize
|
||||
);
|
||||
if(storedChecksum != header.storedChecksum) {
|
||||
errorThrow("dusk.dsk stored archive failed checksum verification.");
|
||||
}
|
||||
|
||||
zip_error_t zipError;
|
||||
zip_error_init(&zipError);
|
||||
|
||||
// freep=0 for both - they're non-owning windows into the same caller-owned
|
||||
// buffer, not independent allocations libzip should free.
|
||||
zip_source_t *compressedSource = zip_source_buffer_create(
|
||||
buffer + header.compressedOffset, header.compressedSize, 0, &zipError
|
||||
);
|
||||
if(compressedSource == NULL) {
|
||||
errorThrow(
|
||||
"Failed to create compressed dusk.dsk source: %s",
|
||||
zip_error_strerror(&zipError)
|
||||
);
|
||||
}
|
||||
|
||||
*outCompressed =
|
||||
zip_open_from_source(compressedSource, ZIP_RDONLY, &zipError);
|
||||
if(*outCompressed == NULL) {
|
||||
zip_source_free(compressedSource);
|
||||
errorThrow(
|
||||
"Failed to open compressed dusk.dsk archive: %s",
|
||||
zip_error_strerror(&zipError)
|
||||
);
|
||||
}
|
||||
|
||||
zip_source_t *storedSource = zip_source_buffer_create(
|
||||
buffer + header.storedOffset, header.storedSize, 0, &zipError
|
||||
);
|
||||
if(storedSource == NULL) {
|
||||
zip_close(*outCompressed);
|
||||
*outCompressed = NULL;
|
||||
errorThrow(
|
||||
"Failed to create stored dusk.dsk source: %s",
|
||||
zip_error_strerror(&zipError)
|
||||
);
|
||||
}
|
||||
|
||||
*outStored = zip_open_from_source(storedSource, ZIP_RDONLY, &zipError);
|
||||
if(*outStored == NULL) {
|
||||
zip_source_free(storedSource);
|
||||
zip_close(*outCompressed);
|
||||
*outCompressed = NULL;
|
||||
errorThrow(
|
||||
"Failed to open stored dusk.dsk archive: %s",
|
||||
zip_error_strerror(&zipError)
|
||||
);
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
#include <zip.h>
|
||||
|
||||
// "DSK2" - distinct from a plain zip's "PK\x03\x04" so a stray plain zip
|
||||
// never gets misread as a valid dusk.dsk.
|
||||
#define ASSET_DSK_MAGIC_SIZE 4
|
||||
#define ASSET_DSK_MAGIC "DSK2"
|
||||
#define ASSET_DSK_VERSION 1
|
||||
|
||||
// magic(4) + version(4) + compressedOffset(4) + compressedSize(4) +
|
||||
// compressedChecksum(4) + storedOffset(4) + storedSize(4) +
|
||||
// storedChecksum(4), all little-endian regardless of host - see
|
||||
// assetDskParseHeader.
|
||||
#define ASSET_DSK_HEADER_SIZE 32
|
||||
|
||||
/**
|
||||
* Parsed dusk.dsk (DSK2 format) header. dusk.dsk is two independent, back
|
||||
* to back zip archives (see tools/asset/pack) rather than a single plain
|
||||
* zip: a "compressed" one (DEFLATE, expected to hold the bulk of a game's
|
||||
* binary assets, opened lazily/on-demand) and a "stored" one (uncompressed,
|
||||
* expected to hold small files - locale strings, config - that need
|
||||
* reliable repeated seeking/re-opening, which libzip only supports for
|
||||
* uncompressed entries).
|
||||
*/
|
||||
typedef struct {
|
||||
uint32_t compressedOffset;
|
||||
uint32_t compressedSize;
|
||||
uint32_t compressedChecksum;
|
||||
uint32_t storedOffset;
|
||||
uint32_t storedSize;
|
||||
uint32_t storedChecksum;
|
||||
} assetdskheader_t;
|
||||
|
||||
/**
|
||||
* Parses a DSK2 header from a raw byte buffer (at least
|
||||
* ASSET_DSK_HEADER_SIZE bytes), validating the magic/version and
|
||||
* byte-swapping the little-endian fields to host order.
|
||||
*
|
||||
* @param bytes Buffer containing the header (and beyond).
|
||||
* @param bytesSize Number of bytes available at `bytes`.
|
||||
* @param outHeader Filled with the parsed header on success.
|
||||
* @return OK on success, error if too short, bad magic, or unsupported version.
|
||||
*/
|
||||
errorret_t assetDskParseHeader(
|
||||
const uint8_t *bytes,
|
||||
const size_t bytesSize,
|
||||
assetdskheader_t *outHeader
|
||||
);
|
||||
|
||||
/**
|
||||
* Opens both archives of a dusk.dsk file given a filesystem path, using
|
||||
* lazy/windowed file-backed zip sources - no more memory used than the
|
||||
* existing per-platform small read buffers, matching the memory
|
||||
* characteristics of a plain zip_open() on the whole file. Verifies the
|
||||
* (small, by convention) stored archive's checksum; the compressed
|
||||
* archive's checksum is intentionally not verified here since doing so
|
||||
* would require reading the bulk of the game's assets just to compute it.
|
||||
*
|
||||
* See assetDskOpenFromPathRange() for the case where the DSK2 blob isn't
|
||||
* the whole file (e.g. embedded inside another container).
|
||||
*
|
||||
* @param path Filesystem path to the dusk.dsk file.
|
||||
* @param outCompressed Set to the opened compressed archive on success.
|
||||
* @param outStored Set to the opened stored archive on success.
|
||||
* @return OK on success, error if the file is missing, too short, has a
|
||||
* bad header, or either archive fails to open/verify.
|
||||
*/
|
||||
errorret_t assetDskOpenFromPath(
|
||||
const char_t *path,
|
||||
zip_t **outCompressed,
|
||||
zip_t **outStored
|
||||
);
|
||||
|
||||
/**
|
||||
* Same as assetDskOpenFromPath(), but the DSK2 blob doesn't start at the
|
||||
* beginning of `path` - it's a byte range embedded inside a larger
|
||||
* container file (e.g. the PSAR region of an EBOOT.PBP). Every offset the
|
||||
* header describes is relative to `baseOffset`; `baseSize` bounds them
|
||||
* (the size of the embedded blob, not the whole container file) - pass
|
||||
* SIZE_MAX to skip that check when the caller doesn't know/care.
|
||||
*
|
||||
* @param path Filesystem path to the container file.
|
||||
* @param baseOffset Byte offset within `path` where the DSK2 blob starts.
|
||||
* @param baseSize Number of bytes available at `baseOffset`.
|
||||
* @param outCompressed Set to the opened compressed archive on success.
|
||||
* @param outStored Set to the opened stored archive on success.
|
||||
* @return OK on success, error if the file is missing, too short, has a
|
||||
* bad header, or either archive fails to open/verify.
|
||||
*/
|
||||
errorret_t assetDskOpenFromPathRange(
|
||||
const char_t *path,
|
||||
const size_t baseOffset,
|
||||
const size_t baseSize,
|
||||
zip_t **outCompressed,
|
||||
zip_t **outStored
|
||||
);
|
||||
|
||||
/**
|
||||
* Opens both archives of a dusk.dsk file already fully resident in memory
|
||||
* (e.g. a PSAR embedded in an EBOOT.PBP, or an ISO-embedded file already
|
||||
* read via DVD_ReadAbs - platforms that already buffer the whole file for
|
||||
* reasons unrelated to this format). Neither archive takes ownership of
|
||||
* `buffer` (both are opened as non-owning sub-ranges of it) - the caller
|
||||
* remains responsible for freeing it, and must keep it alive for as long
|
||||
* as either archive stays open. Verifies both archives' checksums, since
|
||||
* the bytes are already resident.
|
||||
*
|
||||
* @param buffer The whole dusk.dsk file's bytes.
|
||||
* @param bufferSize Number of bytes at `buffer`.
|
||||
* @param outCompressed Set to the opened compressed archive on success.
|
||||
* @param outStored Set to the opened stored archive on success.
|
||||
* @return OK on success, error if too short, has a bad header/checksum, or
|
||||
* either archive fails to open.
|
||||
*/
|
||||
errorret_t assetDskOpenFromBuffer(
|
||||
uint8_t *buffer,
|
||||
const size_t bufferSize,
|
||||
zip_t **outCompressed,
|
||||
zip_t **outStored
|
||||
);
|
||||
+68
-23
@@ -24,9 +24,20 @@ errorret_t assetFileInit(
|
||||
file->params = params;
|
||||
file->output = output;
|
||||
|
||||
// Stat the file
|
||||
// Stat the file, trying the compressed archive first and falling back to
|
||||
// the stored one - remember which matched so assetFileOpen opens it from
|
||||
// the right archive.
|
||||
zip_stat_init(&file->stat);
|
||||
if(!zip_stat(ASSET.zip, filename, 0, &file->stat) == 0) {
|
||||
threadMutexLock(&ASSET.zipLock);
|
||||
if(zip_stat(ASSET.zip, filename, 0, &file->stat) == 0) {
|
||||
file->sourceZip = ASSET.zip;
|
||||
} else if(zip_stat(ASSET.zipStored, filename, 0, &file->stat) == 0) {
|
||||
file->sourceZip = ASSET.zipStored;
|
||||
} else {
|
||||
file->sourceZip = NULL;
|
||||
}
|
||||
threadMutexUnlock(&ASSET.zipLock);
|
||||
if(file->sourceZip == NULL) {
|
||||
errorThrow("Failed to stat asset file: %s", filename);
|
||||
}
|
||||
|
||||
@@ -47,6 +58,25 @@ errorret_t assetFileRewind(assetfile_t *file) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
// Prefer seeking within the still-open handle over closing and
|
||||
// re-opening it. Repeatedly closing/re-opening the same compressed zip
|
||||
// entry (once per rewind - e.g. once per locale string lookup) was
|
||||
// confirmed unreliable on at least one platform's zip backend, silently
|
||||
// skipping ranges of the decompressed content on some re-opens after
|
||||
// the first. A real seek avoids that failure mode entirely, with no
|
||||
// extra memory cost over the close+reopen fallback.
|
||||
threadMutexLock(&ASSET.zipLock);
|
||||
bool_t seekable = zip_file_is_seekable(file->zipFile);
|
||||
int seekResult = seekable ? zip_fseek(file->zipFile, 0, SEEK_SET) : -1;
|
||||
threadMutexUnlock(&ASSET.zipLock);
|
||||
if(seekable) {
|
||||
if(seekResult != 0) {
|
||||
errorThrow("Failed to seek asset file: %s", file->filename);
|
||||
}
|
||||
file->position = 0;
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorChain(assetFileClose(file));
|
||||
errorChain(assetFileOpen(file));
|
||||
errorOk();
|
||||
@@ -55,10 +85,12 @@ errorret_t assetFileRewind(assetfile_t *file) {
|
||||
errorret_t assetFileOpen(assetfile_t *file) {
|
||||
assertNotNull(file, "Asset file cannot be NULL.");
|
||||
assertNotNull(file->filename, "Asset file filename cannot be NULL.");
|
||||
assertNotNull(ASSET.zip, "Asset zip cannot be NULL.");
|
||||
assertNotNull(file->sourceZip, "Asset file must be inited before opening.");
|
||||
assertNull(file->zipFile, "Asset file already open.");
|
||||
|
||||
file->zipFile = zip_fopen(ASSET.zip, file->filename, 0);
|
||||
threadMutexLock(&ASSET.zipLock);
|
||||
file->zipFile = zip_fopen(file->sourceZip, file->filename, 0);
|
||||
threadMutexUnlock(&ASSET.zipLock);
|
||||
if(file->zipFile == NULL) {
|
||||
errorThrow("Failed to open asset file: %s", file->filename);
|
||||
}
|
||||
@@ -79,8 +111,10 @@ errorret_t assetFileRead(
|
||||
uint8_t tempBuffer[256];
|
||||
while(bytesRemaining > 0) {
|
||||
size_t chunkSize = mathMin(bytesRemaining, sizeof(tempBuffer));
|
||||
// The recursive call below already advances file->position by
|
||||
// chunkSize (the non-NULL branch does this itself) - do not also
|
||||
// advance it here, or every skip ends up double-counted.
|
||||
errorChain(assetFileRead(file, tempBuffer, chunkSize));
|
||||
file->position += chunkSize;
|
||||
bytesRemaining -= chunkSize;
|
||||
}
|
||||
file->lastRead = bufferSize;
|
||||
@@ -97,15 +131,27 @@ errorret_t assetFileRead(
|
||||
size_t chunkSize = mathMin(
|
||||
bufferSize - totalRead, ASSET_FILE_READ_CHUNK_MAX
|
||||
);
|
||||
threadMutexLock(&ASSET.zipLock);
|
||||
zip_int64_t bytesRead = zip_fread(
|
||||
file->zipFile, dest + totalRead, chunkSize
|
||||
);
|
||||
errorret_t readError = errorOkImpl();
|
||||
if(bytesRead < 0) {
|
||||
errorThrow(
|
||||
// Built (not thrown) while still holding the lock, so
|
||||
// zip_file_strerror() reads the just-failed zipFile's error state
|
||||
// before another thread can touch it - errorThrow() itself isn't
|
||||
// used here since it returns immediately, which would leave
|
||||
// ASSET.zipLock held forever.
|
||||
readError = errorThrowImpl(
|
||||
&ERROR_STATE, ERROR_NOT_OK, __FILE__, __func__, __LINE__,
|
||||
"Failed to read from asset file: %s (%s)",
|
||||
file->filename, zip_file_strerror(file->zipFile)
|
||||
);
|
||||
}
|
||||
threadMutexUnlock(&ASSET.zipLock);
|
||||
if(errorIsNotOk(readError)) {
|
||||
errorChain(readError);
|
||||
}
|
||||
if(bytesRead == 0) break;
|
||||
totalRead += (size_t)bytesRead;
|
||||
}
|
||||
@@ -118,7 +164,10 @@ errorret_t assetFileClose(assetfile_t *file) {
|
||||
assertNotNull(file, "Asset file cannot be NULL.");
|
||||
assertNotNull(file->zipFile, "Asset file must be opened before closing.");
|
||||
|
||||
if(zip_fclose(file->zipFile) != 0) {
|
||||
threadMutexLock(&ASSET.zipLock);
|
||||
int closeResult = zip_fclose(file->zipFile);
|
||||
threadMutexUnlock(&ASSET.zipLock);
|
||||
if(closeResult != 0) {
|
||||
errorThrow("Failed to close asset file: %s", file->filename);
|
||||
}
|
||||
file->zipFile = NULL;
|
||||
@@ -218,7 +267,7 @@ const uint8_t *assetFileLineReaderUnreadPtr(
|
||||
return reader->readBuffer + reader->bufferStart;
|
||||
}
|
||||
|
||||
static errorret_t assetFileLineReaderAppend(
|
||||
errorret_t assetFileLineReaderAppend(
|
||||
assetfilelinereader_t *reader,
|
||||
const uint8_t *src,
|
||||
size_t srcLength
|
||||
@@ -230,7 +279,7 @@ static errorret_t assetFileLineReaderAppend(
|
||||
errorOk();
|
||||
}
|
||||
|
||||
/* reserve room for optional NUL terminator */
|
||||
// reserve room for optional NUL terminator
|
||||
if(reader->lineLength + srcLength >= reader->outBufferSize) {
|
||||
errorThrow("Line length exceeds output buffer size.");
|
||||
}
|
||||
@@ -240,7 +289,7 @@ static errorret_t assetFileLineReaderAppend(
|
||||
errorOk();
|
||||
}
|
||||
|
||||
static void assetFileLineReaderTerminate(assetfilelinereader_t *reader) {
|
||||
void assetFileLineReaderTerminate(assetfilelinereader_t *reader) {
|
||||
assertNotNull(reader, "Reader cannot be NULL.");
|
||||
assertNotNull(reader->outBuffer, "Out buffer cannot be NULL.");
|
||||
assertTrue(
|
||||
@@ -250,7 +299,7 @@ static void assetFileLineReaderTerminate(assetfilelinereader_t *reader) {
|
||||
reader->outBuffer[reader->lineLength] = '\0';
|
||||
}
|
||||
|
||||
static ssize_t assetFileLineReaderFindNewline(
|
||||
ssize_t assetFileLineReaderFindNewline(
|
||||
const assetfilelinereader_t *reader
|
||||
) {
|
||||
size_t i;
|
||||
@@ -279,7 +328,7 @@ errorret_t assetFileLineReaderFill(assetfilelinereader_t *reader) {
|
||||
|
||||
size_t unreadBytes = assetFileLineReaderUnreadBytes(reader);
|
||||
|
||||
/* If buffer is fully consumed, refill from start. */
|
||||
// If buffer is fully consumed, refill from start.
|
||||
if(unreadBytes == 0) {
|
||||
reader->bufferStart = 0;
|
||||
reader->bufferEnd = 0;
|
||||
@@ -300,18 +349,14 @@ errorret_t assetFileLineReaderFill(assetfilelinereader_t *reader) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
/*
|
||||
* There are unread bytes left but no newline in them.
|
||||
* If bufferStart > 0, slide unread bytes to front so we can read more.
|
||||
* This only happens when necessary to make space.
|
||||
*/
|
||||
// There are unread bytes left but no newline in them.
|
||||
// If bufferStart > 0, slide unread bytes to front so we can read more.
|
||||
// This only happens when necessary to make space.
|
||||
if(reader->bufferEnd == reader->readBufferSize) {
|
||||
if(reader->bufferStart == 0) {
|
||||
/*
|
||||
* Entire read buffer is unread and contains no newline.
|
||||
* Caller must have a large enough outBuffer to accumulate across fills,
|
||||
* so we consume these bytes into outBuffer before refilling.
|
||||
*/
|
||||
// Entire read buffer is unread and contains no newline.
|
||||
// Caller must have a large enough outBuffer to accumulate across fills,
|
||||
// so we consume these bytes into outBuffer before refilling.
|
||||
errorOk();
|
||||
}
|
||||
|
||||
@@ -354,7 +399,7 @@ errorret_t assetFileLineReaderNext(assetfilelinereader_t *reader) {
|
||||
size_t chunkLength = (size_t)newlineIndex - reader->bufferStart;
|
||||
errorret_t ret;
|
||||
|
||||
/* strip CR in CRLF */
|
||||
// strip CR in CRLF
|
||||
if(
|
||||
chunkLength > 0 &&
|
||||
reader->readBuffer[(size_t)newlineIndex - 1] == '\r'
|
||||
|
||||
@@ -32,6 +32,11 @@ typedef struct assetfile_s {
|
||||
zip_int64_t position;
|
||||
zip_int64_t lastRead;
|
||||
zip_file_t *zipFile;
|
||||
|
||||
// The archive this file was found in (ASSET.zip or ASSET.zipStored),
|
||||
// set by assetFileInit and used by assetFileOpen so lookups fall back
|
||||
// correctly between the two dusk.dsk archives.
|
||||
zip_t *sourceZip;
|
||||
} assetfile_t;
|
||||
|
||||
/**
|
||||
@@ -150,10 +155,67 @@ void assetFileLineReaderInit(
|
||||
const size_t outBufferSize
|
||||
);
|
||||
|
||||
/**
|
||||
* Returns the number of bytes still unread in the line reader's read buffer.
|
||||
*
|
||||
* @param reader The line reader to check.
|
||||
* @return Number of unread bytes remaining in the read buffer.
|
||||
*/
|
||||
size_t assetFileLineReaderUnreadBytes(const assetfilelinereader_t *reader);
|
||||
|
||||
/**
|
||||
* Returns a pointer to the first unread byte in the line reader's read
|
||||
* buffer.
|
||||
*
|
||||
* @param reader The line reader to check.
|
||||
* @return Pointer to the first unread byte.
|
||||
*/
|
||||
const uint8_t *assetFileLineReaderUnreadPtr(
|
||||
const assetfilelinereader_t *reader
|
||||
);
|
||||
|
||||
/**
|
||||
* Appends src to the line reader's current line buffer, growing lineLength.
|
||||
*
|
||||
* @param reader The line reader whose out buffer to append to.
|
||||
* @param src Bytes to append.
|
||||
* @param srcLength Number of bytes in src.
|
||||
* @return Error state if any (the line would exceed the output buffer).
|
||||
*/
|
||||
errorret_t assetFileLineReaderAppend(
|
||||
assetfilelinereader_t *reader,
|
||||
const uint8_t *src,
|
||||
size_t srcLength
|
||||
);
|
||||
|
||||
/**
|
||||
* Null-terminates the line reader's current line buffer at lineLength.
|
||||
*
|
||||
* @param reader The line reader whose out buffer to terminate.
|
||||
*/
|
||||
void assetFileLineReaderTerminate(assetfilelinereader_t *reader);
|
||||
|
||||
/**
|
||||
* Searches the line reader's unread buffered bytes for a newline character.
|
||||
*
|
||||
* @param reader The line reader to search.
|
||||
* @return The index of the newline within readBuffer, or -1 if not found.
|
||||
*/
|
||||
ssize_t assetFileLineReaderFindNewline(const assetfilelinereader_t *reader);
|
||||
|
||||
/**
|
||||
* Refills the line reader's read buffer from the underlying file once its
|
||||
* buffered bytes are fully consumed. A no-op once the file is at EOF.
|
||||
*
|
||||
* @param reader The line reader to refill.
|
||||
* @return Error state if any.
|
||||
*/
|
||||
errorret_t assetFileLineReaderFill(assetfilelinereader_t *reader);
|
||||
|
||||
/**
|
||||
* Reads the next line from the asset file into the line buffer. The line
|
||||
* buffer is null-terminated and does not include the newline character.
|
||||
*
|
||||
*
|
||||
* @param reader The line reader to read from.
|
||||
* @return An error code if a failure occurs, or errorOk() if a line was read
|
||||
* successfully. If the end of the file is reached, errorEndOfFile() is
|
||||
|
||||
@@ -17,4 +17,6 @@ add_subdirectory(locale)
|
||||
add_subdirectory(json)
|
||||
add_subdirectory(chunk)
|
||||
add_subdirectory(dmf)
|
||||
add_subdirectory(cutscene)
|
||||
add_subdirectory(cutscene)
|
||||
add_subdirectory(wav)
|
||||
add_subdirectory(mp3)
|
||||
@@ -57,4 +57,16 @@ assetloadercallbacks_t ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_COUNT] = {
|
||||
.loadAsync = assetCutsceneLoaderAsync,
|
||||
.dispose = assetCutsceneDispose
|
||||
},
|
||||
|
||||
[ASSET_LOADER_TYPE_WAV] = {
|
||||
.loadSync = assetWavLoaderSync,
|
||||
.loadAsync = assetWavLoaderAsync,
|
||||
.dispose = assetWavDispose
|
||||
},
|
||||
|
||||
[ASSET_LOADER_TYPE_MP3] = {
|
||||
.loadSync = assetMp3LoaderSync,
|
||||
.loadAsync = assetMp3LoaderAsync,
|
||||
.dispose = assetMp3Dispose
|
||||
},
|
||||
};
|
||||
@@ -14,6 +14,8 @@
|
||||
#include "asset/loader/json/assetjsonloader.h"
|
||||
#include "asset/loader/chunk/assetchunkloader.h"
|
||||
#include "asset/loader/cutscene/assetcutsceneloader.h"
|
||||
#include "asset/loader/wav/assetwavloader.h"
|
||||
#include "asset/loader/mp3/assetmp3loader.h"
|
||||
|
||||
typedef enum {
|
||||
ASSET_LOADER_TYPE_NULL,
|
||||
@@ -26,6 +28,8 @@ typedef enum {
|
||||
ASSET_LOADER_TYPE_JSON,
|
||||
ASSET_LOADER_TYPE_CHUNK,
|
||||
ASSET_LOADER_TYPE_CUTSCENE,
|
||||
ASSET_LOADER_TYPE_WAV,
|
||||
ASSET_LOADER_TYPE_MP3,
|
||||
|
||||
ASSET_LOADER_TYPE_COUNT
|
||||
} assetloadertype_t;
|
||||
@@ -39,6 +43,8 @@ typedef union {
|
||||
assetjsonloaderloading_t json;
|
||||
assetchunkloaderloading_t chunk;
|
||||
assetcutsceneloaderloading_t cutscene;
|
||||
assetwavloaderloading_t wav;
|
||||
assetmp3loaderloading_t mp3;
|
||||
} assetloaderloading_t;
|
||||
|
||||
typedef union {
|
||||
@@ -50,6 +56,8 @@ typedef union {
|
||||
assetjsonoutput_t json;
|
||||
assetchunkoutput_t chunk;
|
||||
assetcutsceneoutput_t cutscene;
|
||||
assetwavoutput_t wav;
|
||||
assetmp3output_t mp3;
|
||||
} assetloaderoutput_t;
|
||||
|
||||
typedef union {
|
||||
@@ -59,6 +67,8 @@ typedef union {
|
||||
assetjsonloaderinput_t json;
|
||||
assetchunkloaderinput_t chunk;
|
||||
assetcutsceneloaderinput_t cutscene;
|
||||
assetwavloaderinput_t wav;
|
||||
assetmp3loaderinput_t mp3;
|
||||
} assetloaderinput_t;
|
||||
|
||||
typedef struct assetloading_s assetloading_t;
|
||||
|
||||
@@ -13,26 +13,7 @@
|
||||
#include "asset/loader/assetentry.h"
|
||||
#include "asset/loader/assetloader.h"
|
||||
#include "asset/asset.h"
|
||||
|
||||
// Reads a little-endian int16 from a potentially-unaligned offset into a
|
||||
// worldunit_t, advancing *offset past it.
|
||||
static worldunit_t assetChunkReadWorldUnit(
|
||||
const uint8_t *data,
|
||||
size_t *offset
|
||||
) {
|
||||
int16_t value;
|
||||
memoryCopy(&value, data + *offset, sizeof(int16_t));
|
||||
*offset += sizeof(int16_t);
|
||||
return (worldunit_t)endianLittleToHost16((uint16_t)value);
|
||||
}
|
||||
|
||||
static worldpos_t assetChunkReadWorldPos(const uint8_t *data, size_t *offset) {
|
||||
worldpos_t pos;
|
||||
pos.x = assetChunkReadWorldUnit(data, offset);
|
||||
pos.y = assetChunkReadWorldUnit(data, offset);
|
||||
pos.z = assetChunkReadWorldUnit(data, offset);
|
||||
return pos;
|
||||
}
|
||||
#include "rpg/overworld/worldpos.h"
|
||||
|
||||
errorret_t assetChunkLoaderAsync(assetloading_t *loading) {
|
||||
assertNotNull(loading, "Loading cannot be NULL");
|
||||
@@ -196,7 +177,7 @@ errorret_t assetChunkLoaderSync(assetloading_t *loading) {
|
||||
spawn->itemQuantity = 0;
|
||||
}
|
||||
|
||||
spawn->position = assetChunkReadWorldPos(data, &offset);
|
||||
spawn->position = worldPosReadLE(data, &offset);
|
||||
}
|
||||
|
||||
out->areaSpawnCount = data[offset];
|
||||
@@ -208,8 +189,8 @@ errorret_t assetChunkLoaderSync(assetloading_t *loading) {
|
||||
|
||||
for(uint8_t s = 0; s < out->areaSpawnCount; s++) {
|
||||
chunkareaspawn_t *area = &out->areaSpawns[s];
|
||||
area->min = assetChunkReadWorldPos(data, &offset);
|
||||
area->max = assetChunkReadWorldPos(data, &offset);
|
||||
area->min = worldPosReadLE(data, &offset);
|
||||
area->max = worldPosReadLE(data, &offset);
|
||||
|
||||
uint16_t callbackId;
|
||||
memoryCopy(&callbackId, data + offset, sizeof(uint16_t));
|
||||
|
||||
@@ -8,121 +8,125 @@
|
||||
#include "assetcutsceneloader.h"
|
||||
#include "assert/assert.h"
|
||||
#include "util/memory.h"
|
||||
#include "util/endian.h"
|
||||
#include "util/string.h"
|
||||
#include "asset/loader/assetloading.h"
|
||||
#include "asset/loader/assetentry.h"
|
||||
#include "asset/loader/assetloader.h"
|
||||
#include "asset/asset.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonpauseflags.h"
|
||||
|
||||
// DCTS header: magic "DCTS" (4), version u32 LE (4), pauseType u8 (1),
|
||||
// itemCount u8 (1), poolSize u16 LE (2) = 12 bytes.
|
||||
#define ASSET_CUTSCENE_HEADER_SIZE 12
|
||||
|
||||
static uint8_t assetCutsceneReadU8(const uint8_t *data, size_t *offset) {
|
||||
uint8_t value = data[*offset];
|
||||
*offset += sizeof(uint8_t);
|
||||
return value;
|
||||
}
|
||||
|
||||
static uint16_t assetCutsceneReadU16(const uint8_t *data, size_t *offset) {
|
||||
uint16_t value;
|
||||
memoryCopy(&value, data + *offset, sizeof(uint16_t));
|
||||
*offset += sizeof(uint16_t);
|
||||
return endianLittleToHost16(value);
|
||||
}
|
||||
|
||||
static uint32_t assetCutsceneReadU32(const uint8_t *data, size_t *offset) {
|
||||
uint32_t value;
|
||||
memoryCopy(&value, data + *offset, sizeof(uint32_t));
|
||||
*offset += sizeof(uint32_t);
|
||||
return endianLittleToHost32(value);
|
||||
}
|
||||
|
||||
static float_t assetCutsceneReadFloat(const uint8_t *data, size_t *offset) {
|
||||
float_t value;
|
||||
memoryCopy(&value, data + *offset, sizeof(float_t));
|
||||
*offset += sizeof(float_t);
|
||||
return endianLittleToHostFloat(value);
|
||||
}
|
||||
|
||||
static worldunit_t assetCutsceneReadWorldUnit(
|
||||
const uint8_t *data,
|
||||
size_t *offset
|
||||
errorret_t assetCutsceneParseItem(
|
||||
assetloading_t *loading,
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset,
|
||||
const uint8_t index
|
||||
) {
|
||||
uint16_t value = assetCutsceneReadU16(data, offset);
|
||||
return (worldunit_t)value;
|
||||
if(!yyjson_is_obj(itemObj)) {
|
||||
assetLoaderErrorThrow(
|
||||
loading,
|
||||
"Cutscene item %u is not an object",
|
||||
(uint32_t)index
|
||||
);
|
||||
}
|
||||
|
||||
const char_t *typeName = yyjson_get_str(yyjson_obj_get(itemObj, "type"));
|
||||
if(!cutsceneItemLookupType(typeName, &item->type)) {
|
||||
assetLoaderErrorThrow(
|
||||
loading,
|
||||
"Cutscene item %u: missing/unsupported item type %s",
|
||||
(uint32_t)index,
|
||||
typeName
|
||||
);
|
||||
}
|
||||
|
||||
cutsceneitemloadcallback_t *load = CUTSCENE_ITEM_CALLBACKS[item->type].load;
|
||||
if(load == NULL) {
|
||||
assetLoaderErrorThrow(
|
||||
loading, "Cutscene item %u: unhandled item type %u", (uint32_t)index,
|
||||
(uint32_t)item->type
|
||||
);
|
||||
}
|
||||
|
||||
errorret_t result = load(itemObj, item, pool, poolOffset);
|
||||
if(errorIsNotOk(result)) {
|
||||
loading->entry->state = ASSET_ENTRY_STATE_ERROR;
|
||||
errorChain(result);
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
static worldpos_t assetCutsceneReadWorldPos(
|
||||
const uint8_t *data,
|
||||
size_t *offset
|
||||
) {
|
||||
worldpos_t pos;
|
||||
pos.x = assetCutsceneReadWorldUnit(data, offset);
|
||||
pos.y = assetCutsceneReadWorldUnit(data, offset);
|
||||
pos.z = assetCutsceneReadWorldUnit(data, offset);
|
||||
return pos;
|
||||
size_t assetCutsceneComputePoolSize(yyjson_val *itemsArr) {
|
||||
size_t size = 0;
|
||||
yyjson_arr_iter iter = yyjson_arr_iter_with(itemsArr);
|
||||
yyjson_val *itemVal;
|
||||
while((itemVal = yyjson_arr_iter_next(&iter)) != NULL) {
|
||||
const char_t *typeName = yyjson_get_str(yyjson_obj_get(itemVal, "type"));
|
||||
cutsceneitemtype_t type;
|
||||
if(!cutsceneItemLookupType(typeName, &type)) continue;
|
||||
|
||||
cutsceneitempoolsizecallback_t *poolSize =
|
||||
CUTSCENE_ITEM_CALLBACKS[type].poolSize;
|
||||
if(poolSize == NULL) continue;
|
||||
|
||||
size = cutsceneJsonPoolAlign(size) + poolSize(itemVal);
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
// Copies a length-prefixed string directly into an item's own embedded
|
||||
// char_t[destCapacity] field (CUTSCENE_TEXT_MAX_CHARS and friends) - these
|
||||
// are never pool references, see the item-field inventory in the runtime
|
||||
// cutscene file design.
|
||||
static void assetCutsceneReadEmbeddedString(
|
||||
const uint8_t *data,
|
||||
size_t *offset,
|
||||
char_t *dest,
|
||||
const size_t destCapacity
|
||||
) {
|
||||
uint8_t len = assetCutsceneReadU8(data, offset);
|
||||
assertTrue(len < destCapacity, "Cutscene string exceeds field capacity");
|
||||
memoryCopy(dest, data + *offset, len);
|
||||
dest[len] = '\0';
|
||||
*offset += len;
|
||||
}
|
||||
|
||||
// Resolves a u16 pool offset (read from the item stream) to a real pointer
|
||||
// into the entry's own persistent pool allocation.
|
||||
static const char_t * assetCutsceneReadPoolString(
|
||||
const uint8_t *data,
|
||||
size_t *offset,
|
||||
const char_t *pool
|
||||
) {
|
||||
uint16_t poolOffset = assetCutsceneReadU16(data, offset);
|
||||
return pool + poolOffset;
|
||||
void assetCutsceneFreeParsed(assetcutsceneoutput_t *out) {
|
||||
if(out->items != NULL) {
|
||||
memoryFree(out->items);
|
||||
out->items = NULL;
|
||||
}
|
||||
if(out->pool != NULL) {
|
||||
memoryFree(out->pool);
|
||||
out->pool = NULL;
|
||||
}
|
||||
if(out->doc != NULL) {
|
||||
yyjson_doc_free(out->doc);
|
||||
out->doc = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
errorret_t assetCutsceneLoaderAsync(assetloading_t *loading) {
|
||||
assertNotNull(loading, "Loading cannot be NULL");
|
||||
assertNotMainThread("Should be called from an async thread.");
|
||||
|
||||
if(loading->loading.cutscene.state != ASSET_CUTSCENE_LOADING_STATE_READ_FILE) {
|
||||
if(
|
||||
loading->loading.cutscene.state != ASSET_CUTSCENE_LOADING_STATE_READ_FILE
|
||||
) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
assertNull(loading->loading.cutscene.data, "Data already defined?");
|
||||
assertNull(loading->loading.cutscene.buffer, "Buffer already defined?");
|
||||
|
||||
assetfile_t *file = &loading->loading.cutscene.file;
|
||||
assetLoaderErrorChain(loading,
|
||||
assetFileInit(file, loading->entry->name, NULL, NULL)
|
||||
);
|
||||
|
||||
uint8_t *data = memoryAllocate(file->size);
|
||||
if(file->size > ASSET_CUTSCENE_FILE_SIZE_MAX) {
|
||||
assetLoaderErrorThrow(
|
||||
loading, "Cutscene JSON exceeds maximum allowed size"
|
||||
);
|
||||
}
|
||||
|
||||
size_t fileSize = (size_t)file->size;
|
||||
uint8_t *buffer = memoryAllocate(fileSize);
|
||||
assetLoaderErrorChain(loading, assetFileOpen(file));
|
||||
assetLoaderErrorChain(loading, assetFileRead(file, data, file->size));
|
||||
assetLoaderErrorChain(loading, assetFileRead(file, buffer, fileSize));
|
||||
assertTrue(
|
||||
file->lastRead == file->size,
|
||||
"Failed to read entire cutscene file."
|
||||
);
|
||||
// Saved before assetFileDispose zeroes the whole assetfile_t struct
|
||||
// (including .size) - the sync phase needs the file's total length to
|
||||
// locate the pool region, which starts poolSize bytes before the end.
|
||||
loading->loading.cutscene.dataSize = (size_t)file->size;
|
||||
|
||||
assetLoaderErrorChain(loading, assetFileClose(file));
|
||||
assetLoaderErrorChain(loading, assetFileDispose(file));
|
||||
|
||||
loading->loading.cutscene.data = data;
|
||||
loading->loading.cutscene.buffer = buffer;
|
||||
loading->loading.cutscene.size = fileSize;
|
||||
loading->loading.cutscene.state = ASSET_CUTSCENE_LOADING_STATE_PARSE;
|
||||
loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
|
||||
errorOk();
|
||||
@@ -140,306 +144,70 @@ errorret_t assetCutsceneLoaderSync(assetloading_t *loading) {
|
||||
}
|
||||
|
||||
assetcutsceneoutput_t *out = &loading->entry->data.cutscene;
|
||||
uint8_t *data = loading->loading.cutscene.data;
|
||||
assertNotNull(data, "Cutscene data should have been loaded by now.");
|
||||
uint8_t *buffer = loading->loading.cutscene.buffer;
|
||||
assertNotNull(buffer, "Cutscene data should have been loaded by now.");
|
||||
size_t bufferSize = loading->loading.cutscene.size;
|
||||
|
||||
size_t fileSize = loading->loading.cutscene.dataSize;
|
||||
yyjson_doc *doc = yyjson_read(
|
||||
(char *)buffer, bufferSize,
|
||||
YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS
|
||||
);
|
||||
memoryFree(buffer);
|
||||
loading->loading.cutscene.buffer = NULL;
|
||||
|
||||
if(data[0] != 'D' || data[1] != 'C' || data[2] != 'T' || data[3] != 'S') {
|
||||
memoryFree(data);
|
||||
assetLoaderErrorThrow(loading, "Invalid cutscene file header");
|
||||
if(doc == NULL) {
|
||||
assetLoaderErrorThrow(loading, "Failed to parse cutscene JSON");
|
||||
}
|
||||
out->doc = doc;
|
||||
|
||||
yyjson_val *root = yyjson_doc_get_root(doc);
|
||||
yyjson_val *itemsArr = yyjson_obj_get(root, "items");
|
||||
if(!yyjson_is_arr(itemsArr)) {
|
||||
assetCutsceneFreeParsed(out);
|
||||
assetLoaderErrorThrow(loading, "Cutscene JSON is missing an 'items' array");
|
||||
}
|
||||
|
||||
size_t offset = 4;
|
||||
uint32_t version = assetCutsceneReadU32(data, &offset);
|
||||
if(version != ASSET_CUTSCENE_FILE_VERSION) {
|
||||
memoryFree(data);
|
||||
assetLoaderErrorThrow(
|
||||
loading, "Unsupported cutscene file version %u", version
|
||||
);
|
||||
size_t itemCount = yyjson_arr_size(itemsArr);
|
||||
if(itemCount > UINT8_MAX) {
|
||||
assetCutsceneFreeParsed(out);
|
||||
assetLoaderErrorThrow(loading, "Cutscene has more than 255 items");
|
||||
}
|
||||
|
||||
cutscenepause_t pauseType = (cutscenepause_t)assetCutsceneReadU8(data, &offset);
|
||||
uint8_t itemCount = assetCutsceneReadU8(data, &offset);
|
||||
uint16_t poolSize = assetCutsceneReadU16(data, &offset);
|
||||
assertTrue(offset == ASSET_CUTSCENE_HEADER_SIZE, "Cutscene header size mismatch");
|
||||
|
||||
out->pool = poolSize > 0 ? memoryAllocate(poolSize) : NULL;
|
||||
if(poolSize > 0) {
|
||||
size_t poolStart = fileSize - (size_t)poolSize;
|
||||
memoryCopy(out->pool, data + poolStart, poolSize);
|
||||
cutscenepause_t pause = CUTSCENE_PAUSE_DEFAULT;
|
||||
yyjson_val *pauseArr = yyjson_obj_get(root, "pause");
|
||||
if(yyjson_is_arr(pauseArr)) {
|
||||
if(!cutsceneJsonParsePauseFlags(pauseArr, &pause)) {
|
||||
assetCutsceneFreeParsed(out);
|
||||
assetLoaderErrorThrow(
|
||||
loading, "Cutscene JSON has an invalid 'pause' flag"
|
||||
);
|
||||
}
|
||||
}
|
||||
const char_t *pool = out->pool;
|
||||
|
||||
out->items = memoryAllocate(itemCount * sizeof(cutsceneitem_t));
|
||||
memoryZero(out->items, itemCount * sizeof(cutsceneitem_t));
|
||||
|
||||
for(uint8_t i = 0; i < itemCount; i++) {
|
||||
cutsceneitem_t *item = &out->items[i];
|
||||
item->type = (cutsceneitemtype_t)assetCutsceneReadU8(data, &offset);
|
||||
size_t poolSize = assetCutsceneComputePoolSize(itemsArr);
|
||||
out->pool = poolSize > 0 ? memoryAllocate(poolSize) : NULL;
|
||||
|
||||
switch(item->type) {
|
||||
case CUTSCENE_ITEM_TYPE_TEXT:
|
||||
assetCutsceneReadEmbeddedString(
|
||||
data, &offset, item->text.text, CUTSCENE_TEXT_MAX_CHARS
|
||||
);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_TEXT_MINI:
|
||||
assetCutsceneReadEmbeddedString(
|
||||
data, &offset, item->textMini.text, CUTSCENE_TEXT_MINI_MAX_CHARS
|
||||
);
|
||||
item->textMini.position[0] = assetCutsceneReadFloat(data, &offset);
|
||||
item->textMini.position[1] = assetCutsceneReadFloat(data, &offset);
|
||||
item->textMini.position[2] = assetCutsceneReadFloat(data, &offset);
|
||||
item->textMini.duration = assetCutsceneReadFloat(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_TEXT_MINI_HIDE:
|
||||
item->textMiniHide.index = assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_WAIT:
|
||||
item->wait = assetCutsceneReadFloat(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_ENTITY_TELEPORT:
|
||||
item->entityTeleport.entityIndex = assetCutsceneReadU8(data, &offset);
|
||||
item->entityTeleport.target = assetCutsceneReadWorldPos(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO: {
|
||||
item->entityWalkTo.entityIndex = assetCutsceneReadU8(data, &offset);
|
||||
item->entityWalkTo.walkAround = assetCutsceneReadU8(data, &offset) != 0;
|
||||
uint8_t count = assetCutsceneReadU8(data, &offset);
|
||||
uint16_t poolOffset = assetCutsceneReadU16(data, &offset);
|
||||
item->entityWalkTo.count = count;
|
||||
item->entityWalkTo.positions = (const worldpos_t *)(pool + poolOffset);
|
||||
break;
|
||||
}
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_FADE:
|
||||
item->fade.from.r = assetCutsceneReadU8(data, &offset);
|
||||
item->fade.from.g = assetCutsceneReadU8(data, &offset);
|
||||
item->fade.from.b = assetCutsceneReadU8(data, &offset);
|
||||
item->fade.from.a = assetCutsceneReadU8(data, &offset);
|
||||
item->fade.to.r = assetCutsceneReadU8(data, &offset);
|
||||
item->fade.to.g = assetCutsceneReadU8(data, &offset);
|
||||
item->fade.to.b = assetCutsceneReadU8(data, &offset);
|
||||
item->fade.to.a = assetCutsceneReadU8(data, &offset);
|
||||
item->fade.duration = assetCutsceneReadFloat(data, &offset);
|
||||
item->fade.easing = (easingtype_t)assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_SET_PAUSE:
|
||||
item->setPause = (cutscenepause_t)assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_ITEM_GIVE:
|
||||
item->itemGive.item = (itemid_t)assetCutsceneReadU16(data, &offset);
|
||||
item->itemGive.quantity = assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_ENTITY_REMOVE:
|
||||
item->entityRemove.entityIndex = assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_ENTITY_ADD:
|
||||
item->entityAdd.entityType = assetCutsceneReadU8(data, &offset);
|
||||
item->entityAdd.position = assetCutsceneReadWorldPos(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_ENTITY_TURN:
|
||||
item->entityTurn.entityIndex = assetCutsceneReadU8(data, &offset);
|
||||
item->entityTurn.direction =
|
||||
(entitydir_t)assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO_ENTITY:
|
||||
item->entityWalkToEntity.entityIndex =
|
||||
assetCutsceneReadU8(data, &offset);
|
||||
item->entityWalkToEntity.targetEntityIndex =
|
||||
assetCutsceneReadU8(data, &offset);
|
||||
item->entityWalkToEntity.offsetX =
|
||||
assetCutsceneReadWorldUnit(data, &offset);
|
||||
item->entityWalkToEntity.offsetY =
|
||||
assetCutsceneReadWorldUnit(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_MAP_AREA_REMOVE:
|
||||
item->mapAreaRemove.areaId = assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_MAP_AREA_WAIT: {
|
||||
uint8_t count = assetCutsceneReadU8(data, &offset);
|
||||
uint16_t poolOffset = assetCutsceneReadU16(data, &offset);
|
||||
assertTrue(
|
||||
count <= CUTSCENE_MAP_AREA_WAIT_MAX,
|
||||
"Cutscene map area wait count exceeds maximum"
|
||||
);
|
||||
item->mapAreaWait.count = count;
|
||||
item->mapAreaWait.areaIds = (const uint8_t *)(pool + poolOffset);
|
||||
break;
|
||||
}
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_START_BATTLE: {
|
||||
item->startBattle.encounterType =
|
||||
(battleencountertype_t)assetCutsceneReadU8(data, &offset);
|
||||
item->startBattle.fleeAvailable =
|
||||
assetCutsceneReadU8(data, &offset) != 0;
|
||||
uint8_t enemyCount = assetCutsceneReadU8(data, &offset);
|
||||
assertTrue(
|
||||
enemyCount <= CUTSCENE_START_BATTLE_ENEMY_COUNT_MAX,
|
||||
"Cutscene battle enemy count exceeds maximum"
|
||||
);
|
||||
item->startBattle.enemyCount = enemyCount;
|
||||
for(uint8_t e = 0; e < enemyCount; e++) {
|
||||
cutscenestartbattleenemy_t *enemy = &item->startBattle.enemies[e];
|
||||
enemy->stats.attack = assetCutsceneReadU16(data, &offset);
|
||||
enemy->stats.defense = assetCutsceneReadU16(data, &offset);
|
||||
enemy->stats.magic = assetCutsceneReadU16(data, &offset);
|
||||
enemy->stats.speed = assetCutsceneReadU16(data, &offset);
|
||||
enemy->stats.luck = assetCutsceneReadU16(data, &offset);
|
||||
enemy->healthMax = assetCutsceneReadU16(data, &offset);
|
||||
enemy->mpMax = assetCutsceneReadU16(data, &offset);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_EMOJI:
|
||||
item->emoji.entityIndex = assetCutsceneReadU8(data, &offset);
|
||||
item->emoji.duration = assetCutsceneReadFloat(data, &offset);
|
||||
item->emoji.emojiType = (uiemojitype_t)assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_SHAKE:
|
||||
item->shake.amount = assetCutsceneReadU8(data, &offset);
|
||||
item->shake.duration = assetCutsceneReadFloat(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_BATTLE_WAIT_STATE:
|
||||
item->battleWaitState.state =
|
||||
(battlestate_t)assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_BATTLE_FORCE_ACTION:
|
||||
item->battleForceAction.fighterIndex = assetCutsceneReadU8(data, &offset);
|
||||
item->battleForceAction.targetIndex = assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_MODAL: {
|
||||
assetCutsceneReadEmbeddedString(
|
||||
data, &offset, item->modal.title, CUTSCENE_MODAL_TITLE_MAX_CHARS
|
||||
);
|
||||
assetCutsceneReadEmbeddedString(
|
||||
data, &offset, item->modal.message, CUTSCENE_MODAL_MESSAGE_MAX_CHARS
|
||||
);
|
||||
// v1 only supports the message-only form: MODAL and MODAL_OPTIONS
|
||||
// share this same tag with no separate discriminator, and there is
|
||||
// no native-callback registry yet to resolve an options callback.
|
||||
// Read into a local first (not inline in the check below) - on a
|
||||
// release build with DUSK_ASSERTIONS_FAKED, an assert's condition
|
||||
// is never evaluated at all, so a byte-consuming call inside one
|
||||
// would silently desync every item after it. This is untrusted
|
||||
// file content anyway, so it gets a real error, not an assert.
|
||||
uint8_t optionCount = assetCutsceneReadU8(data, &offset);
|
||||
if(optionCount != 0) {
|
||||
memoryFree(data);
|
||||
memoryFree(out->items);
|
||||
out->items = NULL;
|
||||
if(out->pool != NULL) {
|
||||
memoryFree(out->pool);
|
||||
out->pool = NULL;
|
||||
}
|
||||
assetLoaderErrorThrow(
|
||||
loading,
|
||||
"Cutscene MODAL item with options is not supported in "
|
||||
"file-based cutscenes yet - use MODAL_OPTIONS_MARKERS instead"
|
||||
);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_MODAL_OPTIONS_MARKERS: {
|
||||
assetCutsceneReadEmbeddedString(
|
||||
data, &offset, item->modalOptionsMarkers.title,
|
||||
CUTSCENE_MODAL_TITLE_MAX_CHARS
|
||||
);
|
||||
assetCutsceneReadEmbeddedString(
|
||||
data, &offset, item->modalOptionsMarkers.message,
|
||||
CUTSCENE_MODAL_MESSAGE_MAX_CHARS
|
||||
);
|
||||
uint8_t optionCount = assetCutsceneReadU8(data, &offset);
|
||||
assertTrue(
|
||||
optionCount <= CUTSCENE_MODAL_OPTIONS_MARKERS_MAX,
|
||||
"Cutscene modal option count exceeds maximum"
|
||||
);
|
||||
item->modalOptionsMarkers.optionCount = optionCount;
|
||||
for(uint8_t o = 0; o < optionCount; o++) {
|
||||
item->modalOptionsMarkers.options[o] =
|
||||
assetCutsceneReadPoolString(data, &offset, pool);
|
||||
item->modalOptionsMarkers.markers[o] =
|
||||
assetCutsceneReadPoolString(data, &offset, pool);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_MODAL_CLOSE:
|
||||
case CUTSCENE_ITEM_TYPE_RESTART:
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_PRINT:
|
||||
assetCutsceneReadEmbeddedString(
|
||||
data, &offset, item->print.text, CUTSCENE_PRINT_MAX_CHARS
|
||||
);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_MARKER:
|
||||
item->marker.name = assetCutsceneReadPoolString(data, &offset, pool);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_SCENE:
|
||||
item->sceneChange.type = (scenetype_t)assetCutsceneReadU8(data, &offset);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_SAVE_DEVICE_CHECK:
|
||||
item->saveDeviceCheck.successMarker =
|
||||
assetCutsceneReadPoolString(data, &offset, pool);
|
||||
item->saveDeviceCheck.failureMarker =
|
||||
assetCutsceneReadPoolString(data, &offset, pool);
|
||||
break;
|
||||
|
||||
case CUTSCENE_ITEM_TYPE_SAVE_LOAD_ALL_SLOTS:
|
||||
item->saveLoadAllSlots.successMarker =
|
||||
assetCutsceneReadPoolString(data, &offset, pool);
|
||||
item->saveLoadAllSlots.failureMarker =
|
||||
assetCutsceneReadPoolString(data, &offset, pool);
|
||||
break;
|
||||
|
||||
default:
|
||||
memoryFree(data);
|
||||
memoryFree(out->items);
|
||||
out->items = NULL;
|
||||
if(out->pool != NULL) {
|
||||
memoryFree(out->pool);
|
||||
out->pool = NULL;
|
||||
}
|
||||
assetLoaderErrorThrow(
|
||||
loading,
|
||||
"Cutscene item type %u is not supported in file-based cutscenes "
|
||||
"(item %u/%u, offset %u/%u, poolSize %u)",
|
||||
(uint32_t)item->type, (uint32_t)i, (uint32_t)itemCount,
|
||||
(uint32_t)offset, (uint32_t)fileSize, (uint32_t)poolSize
|
||||
);
|
||||
size_t poolOffset = 0;
|
||||
yyjson_arr_iter itemIter = yyjson_arr_iter_with(itemsArr);
|
||||
yyjson_val *itemVal;
|
||||
uint8_t index = 0;
|
||||
while((itemVal = yyjson_arr_iter_next(&itemIter)) != NULL) {
|
||||
errorret_t itemResult = assetCutsceneParseItem(
|
||||
loading, itemVal, &out->items[index], out->pool, &poolOffset, index
|
||||
);
|
||||
if(errorIsNotOk(itemResult)) {
|
||||
assetCutsceneFreeParsed(out);
|
||||
errorChain(itemResult);
|
||||
}
|
||||
index++;
|
||||
}
|
||||
|
||||
memoryFree(data);
|
||||
loading->loading.cutscene.data = NULL;
|
||||
|
||||
out->cutscene.items = out->items;
|
||||
out->cutscene.itemCount = itemCount;
|
||||
out->cutscene.pause = pauseType;
|
||||
out->cutscene.itemCount = (uint8_t)itemCount;
|
||||
out->cutscene.pause = pause;
|
||||
out->cutscene.dataSize = 0;
|
||||
|
||||
loading->entry->state = ASSET_ENTRY_STATE_LOADED;
|
||||
@@ -451,17 +219,7 @@ errorret_t assetCutsceneDispose(assetentry_t *entry) {
|
||||
assertTrue(entry->type == ASSET_LOADER_TYPE_CUTSCENE, "Invalid type.");
|
||||
assertIsMainThread("Must be called from the main thread.");
|
||||
|
||||
assetcutsceneoutput_t *out = &entry->data.cutscene;
|
||||
|
||||
if(out->items != NULL) {
|
||||
memoryFree(out->items);
|
||||
out->items = NULL;
|
||||
}
|
||||
|
||||
if(out->pool != NULL) {
|
||||
memoryFree(out->pool);
|
||||
out->pool = NULL;
|
||||
}
|
||||
assetCutsceneFreeParsed(&entry->data.cutscene);
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -9,8 +9,10 @@
|
||||
#include "asset/assetfile.h"
|
||||
#include "rpg/cutscene/cutscene.h"
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonpool.h"
|
||||
#include "yyjson.h"
|
||||
|
||||
#define ASSET_CUTSCENE_FILE_VERSION 1
|
||||
#define ASSET_CUTSCENE_FILE_SIZE_MAX (1024 * 64)
|
||||
|
||||
typedef struct assetloading_s assetloading_t;
|
||||
typedef struct assetentry_s assetentry_t;
|
||||
@@ -28,22 +30,56 @@ typedef enum {
|
||||
typedef struct {
|
||||
assetfile_t file;
|
||||
assetcutsceneloadingstate_t state;
|
||||
uint8_t *data;
|
||||
size_t dataSize;// Saved before assetFileDispose zeroes file.size.
|
||||
uint8_t *buffer;
|
||||
size_t size;
|
||||
} assetcutsceneloaderloading_t;
|
||||
|
||||
// Runtime-loaded cutscene: items/pool are heap-allocated to the file's
|
||||
// actual declared sizes (not fixed-capacity), so an entry that never holds
|
||||
// a cutscene costs nothing extra in the shared assetloaderoutput_t union -
|
||||
// see assetchunkoutput_t.tiles for the same pattern.
|
||||
typedef struct {
|
||||
cutscene_t cutscene; // .items points at the items array below
|
||||
cutscene_t cutscene;
|
||||
cutsceneitem_t *items;
|
||||
char_t *pool;
|
||||
uint8_t *pool;
|
||||
yyjson_doc *doc;
|
||||
} assetcutsceneoutput_t;
|
||||
|
||||
/**
|
||||
* Asynchronous loader for cutscene assets. Reads the raw DCTS file bytes
|
||||
* Parses one cutscene item object into item, writing any pool-backed
|
||||
* array data (entityWalkTo positions, mapAreaWait areaIds) into pool at
|
||||
* *poolOffset and advancing it. Every field/enum name is validated as
|
||||
* real (untrusted, authored) file content - failures are real errors, not
|
||||
* asserts. Dispatches to the matching type's Load callback (see
|
||||
* CUTSCENE_ITEM_CALLBACKS in rpg/cutscene/item/cutsceneitem.h) - the
|
||||
* per-type parsing logic itself lives there now, colocated with that
|
||||
* type's runtime behavior.
|
||||
*
|
||||
* @param loading Loading information for the asset being loaded.
|
||||
* @param itemObj The item's JSON object.
|
||||
* @param item Destination item, already zeroed by the caller.
|
||||
* @param pool Base pointer of the entry's pool allocation (may be NULL if
|
||||
* assetCutsceneComputePoolSize returned 0).
|
||||
* @param poolOffset In/out cursor into pool.
|
||||
* @param index Index of this item within the cutscene, for error messages.
|
||||
* @return Error code indicating success or failure of the parse.
|
||||
*/
|
||||
errorret_t assetCutsceneParseItem(
|
||||
assetloading_t *loading,
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset,
|
||||
const uint8_t index
|
||||
);
|
||||
|
||||
/**
|
||||
* Frees whatever of out->items/out->pool/out->doc is currently non-NULL
|
||||
* and clears them - shared by both the normal disposer and every parse
|
||||
* failure path's cleanup.
|
||||
*
|
||||
* @param out The output to free.
|
||||
*/
|
||||
void assetCutsceneFreeParsed(assetcutsceneoutput_t *out);
|
||||
|
||||
/**
|
||||
* Asynchronous loader for cutscene assets. Reads the raw JSONC file bytes
|
||||
* into the loading buffer so the sync phase can parse without blocking the
|
||||
* main thread on I/O.
|
||||
*
|
||||
@@ -53,9 +89,8 @@ typedef struct {
|
||||
errorret_t assetCutsceneLoaderAsync(assetloading_t *loading);
|
||||
|
||||
/**
|
||||
* Synchronous loader for cutscene assets. Validates the DCTS binary
|
||||
* previously read by the async phase and decodes it into a heap-allocated
|
||||
* cutsceneitem_t array + string/data pool.
|
||||
* Synchronous loader for cutscene assets. Parses the JSONC previously read
|
||||
* by the async phase into a heap-allocated cutsceneitem_t array + pool.
|
||||
*
|
||||
* @param loading Loading information for the asset being loaded.
|
||||
* @return Error code indicating success or failure of the load operation.
|
||||
|
||||
@@ -62,7 +62,7 @@ errorret_t assetModelLoaderSync(assetloading_t *loading) {
|
||||
|
||||
// Parse required mesh path.
|
||||
yyjson_val *meshVal = yyjson_obj_get(root, "mesh");
|
||||
if(!meshVal || !yyjson_is_str(meshVal)) {
|
||||
if(meshVal == NULL || !yyjson_is_str(meshVal)) {
|
||||
assetUnlockEntry(jsonEntry);
|
||||
loading->entry->state = ASSET_ENTRY_STATE_ERROR;
|
||||
errorThrow("Model JSON missing 'mesh' string");
|
||||
@@ -115,7 +115,8 @@ errorret_t assetModelLoaderSync(assetloading_t *loading) {
|
||||
assetUnlockEntry(jsonEntry);
|
||||
|
||||
// Lock and load the mesh sub-asset.
|
||||
assetentry_t *meshEntry = assetLock(meshName, ASSET_LOADER_TYPE_MESH, NULL);
|
||||
assetentry_t *meshEntry =
|
||||
assetLock(meshName, ASSET_LOADER_TYPE_MESH, NULL);
|
||||
ret = assetRequireLoaded(meshEntry);
|
||||
if(errorIsNotOk(ret)) {
|
||||
assetUnlockEntry(meshEntry);
|
||||
|
||||
@@ -32,7 +32,7 @@ typedef struct {
|
||||
* on the main thread; this callback is never reached.
|
||||
*
|
||||
* @param loading Loading information for the asset being loaded.
|
||||
* @returns Always success.
|
||||
* @return Always success.
|
||||
*/
|
||||
errorret_t assetModelLoaderAsync(assetloading_t *loading);
|
||||
|
||||
@@ -44,7 +44,7 @@ errorret_t assetModelLoaderAsync(assetloading_t *loading);
|
||||
* within ASSET_LOADING_COUNT_MAX slot limits.
|
||||
*
|
||||
* @param loading Loading information for the asset being loaded.
|
||||
* @returns Error code indicating success or failure.
|
||||
* @return Error code indicating success or failure.
|
||||
*/
|
||||
errorret_t assetModelLoaderSync(assetloading_t *loading);
|
||||
|
||||
@@ -53,6 +53,6 @@ errorret_t assetModelLoaderSync(assetloading_t *loading);
|
||||
* sub-asset entries.
|
||||
*
|
||||
* @param entry Asset entry containing the model to dispose.
|
||||
* @returns Error code indicating success or failure.
|
||||
* @return Error code indicating success or failure.
|
||||
*/
|
||||
errorret_t assetModelDispose(assetentry_t *entry);
|
||||
@@ -77,7 +77,7 @@ errorret_t assetJsonLoaderSync(assetloading_t *loading) {
|
||||
memoryFree(buffer);
|
||||
loading->loading.json.buffer = NULL;
|
||||
|
||||
if(!loading->entry->data.json) {
|
||||
if(loading->entry->data.json == NULL) {
|
||||
assetLoaderErrorThrow(loading, "Failed to parse JSON");
|
||||
}
|
||||
|
||||
|
||||
@@ -41,6 +41,32 @@ typedef struct {
|
||||
|
||||
typedef yyjson_doc * assetjsonoutput_t;
|
||||
|
||||
/**
|
||||
* Asynchronous loader callback. Opens the JSON file and reads the whole of
|
||||
* it into a heap buffer, so the main thread is not blocked on I/O. The
|
||||
* buffer is parsed later, on the main thread, by assetJsonLoaderSync. Sets
|
||||
* the entry state to `ASSET_ENTRY_STATE_PENDING_SYNC` on success.
|
||||
*
|
||||
* @param loading The loading slot for this asset entry.
|
||||
* @return OK on success, error otherwise.
|
||||
*/
|
||||
errorret_t assetJsonLoaderAsync(assetloading_t *loading);
|
||||
|
||||
/**
|
||||
* Synchronous loader callback. Drives the load state machine: on the first
|
||||
* call it queues the async read, and once that has completed it parses the
|
||||
* buffer into a `yyjson_doc` (comments and trailing commas allowed), frees
|
||||
* the buffer and marks the entry `ASSET_ENTRY_STATE_LOADED`.
|
||||
*
|
||||
* @param loading The loading slot for this asset entry.
|
||||
* @return OK on success, error otherwise.
|
||||
*/
|
||||
errorret_t assetJsonLoaderSync(assetloading_t *loading);
|
||||
|
||||
/**
|
||||
* Dispose callback. Frees the parsed `yyjson_doc` held by the entry.
|
||||
*
|
||||
* @param entry The asset entry to dispose.
|
||||
* @return OK on success, error otherwise.
|
||||
*/
|
||||
errorret_t assetJsonDispose(assetentry_t *entry);
|
||||
@@ -30,8 +30,8 @@ errorret_t assetLocaleLoaderAsync(assetloading_t *loading) {
|
||||
assetLoaderErrorChain(loading, assetFileOpen(&localeFile->file));
|
||||
|
||||
char_t buffer[1024];
|
||||
assetLoaderErrorChain(loading, assetLocaleGetString(
|
||||
localeFile, "", 0, buffer, sizeof(buffer)
|
||||
assetLoaderErrorChain(loading, assetLocaleGetHeader(
|
||||
localeFile, buffer, sizeof(buffer)
|
||||
));
|
||||
assetLoaderErrorChain(loading, assetLocaleParseHeader(
|
||||
localeFile, buffer, sizeof(buffer)
|
||||
@@ -71,6 +71,12 @@ errorret_t assetLocaleDispose(assetentry_t *entry) {
|
||||
assertIsMainThread("Must be called from the main thread.");
|
||||
|
||||
assetlocalefile_t *localeFile = &entry->data.locale;
|
||||
|
||||
if(localeFile->cache != NULL) {
|
||||
memoryFree(localeFile->cache);
|
||||
localeFile->cache = NULL;
|
||||
}
|
||||
|
||||
errorChain(assetFileClose(&localeFile->file));
|
||||
return assetFileDispose(&localeFile->file);
|
||||
}
|
||||
@@ -87,7 +93,7 @@ errorret_t assetLocaleParseHeader(
|
||||
|
||||
// Find "Plural-Forms: " line and parse out plural form info
|
||||
char_t *pluralFormsLine = strstr(headerBuffer, "Plural-Forms:");
|
||||
if(!pluralFormsLine) {
|
||||
if(pluralFormsLine == NULL) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
@@ -95,7 +101,7 @@ errorret_t assetLocaleParseHeader(
|
||||
|
||||
// Expect nplurals
|
||||
char_t *npluralsStr = strstr(pluralFormsLine, "nplurals=");
|
||||
if(!npluralsStr) {
|
||||
if(npluralsStr == NULL) {
|
||||
errorThrow("Failed to find nplurals in Plural-Forms header.");
|
||||
}
|
||||
npluralsStr += strlen("nplurals=");
|
||||
@@ -114,7 +120,7 @@ errorret_t assetLocaleParseHeader(
|
||||
|
||||
// Expect plural=
|
||||
char_t *pluralStr = strstr(pluralFormsLine, "plural=");
|
||||
if(!pluralStr) {
|
||||
if(pluralStr == NULL) {
|
||||
errorThrow("Failed to find plural in Plural-Forms header.");
|
||||
}
|
||||
pluralStr += strlen("plural=");
|
||||
@@ -122,7 +128,7 @@ errorret_t assetLocaleParseHeader(
|
||||
// Expect ( [expressions] )
|
||||
char_t *openParen = strchr(pluralStr, '(');
|
||||
char_t *closeParen = strrchr(pluralStr, ')');
|
||||
if(!openParen || !closeParen || closeParen < openParen) {
|
||||
if(openParen == NULL || closeParen == NULL || closeParen < openParen) {
|
||||
errorThrow("Failed to find plural expression in Plural-Forms header.");
|
||||
}
|
||||
|
||||
@@ -393,12 +399,12 @@ errorret_t assetLocaleLineUnbuffer(
|
||||
|
||||
// At the point this funciton is called, we are looking for an opening quote.
|
||||
char_t *start = strchr((char_t *)lineBuffer, '"');
|
||||
if(!start) {
|
||||
if(start == NULL) {
|
||||
errorThrow("Expected open (0) \"");
|
||||
}
|
||||
|
||||
char *end = strchr(start + 1, '"');
|
||||
if(!end) {
|
||||
if(end == NULL) {
|
||||
errorThrow("Expected close (0) \"");
|
||||
}
|
||||
*end = '\0';
|
||||
@@ -470,7 +476,94 @@ errorret_t assetLocaleLineUnbuffer(
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetLocaleGetString(
|
||||
errorret_t assetLocaleCacheFind(
|
||||
assetlocalefile_t *file,
|
||||
const char_t *messageId,
|
||||
const int32_t pluralCount,
|
||||
char_t *stringBuffer,
|
||||
const size_t stringBufferSize,
|
||||
bool_t *outHit
|
||||
) {
|
||||
assertNotNull(file, "Asset file cannot be NULL.");
|
||||
assertNotNull(messageId, "Message ID cannot be NULL.");
|
||||
assertNotNull(outHit, "outHit cannot be NULL.");
|
||||
assertStrLenMin(messageId, 1, "Message ID cannot be empty.");
|
||||
|
||||
*outHit = false;
|
||||
if(file->cache == NULL) errorOk();
|
||||
|
||||
assetlocalecache_t *cache = file->cache;
|
||||
for(uint8_t i = 0; i < ASSET_LOCALE_CACHE_COUNT; i++) {
|
||||
assetlocalecacheentry_t *entry = &cache->entries[i];
|
||||
if(entry->messageId[0] == '\0') break;// unused tail - nothing further
|
||||
if(entry->pluralCount != pluralCount) continue;
|
||||
if(!stringEquals(entry->messageId, messageId)) continue;
|
||||
|
||||
// Move to the front of the LRU order (a no-op when already there).
|
||||
if(i > 0) {
|
||||
assetlocalecacheentry_t hit = *entry;
|
||||
memoryMove(
|
||||
&cache->entries[1], &cache->entries[0],
|
||||
i * sizeof(assetlocalecacheentry_t)
|
||||
);
|
||||
cache->entries[0] = hit;
|
||||
}
|
||||
|
||||
size_t len = strlen(cache->entries[0].value);
|
||||
if(len >= stringBufferSize) errorThrow("String buffer overflow");
|
||||
memoryCopy(stringBuffer, cache->entries[0].value, len + 1);
|
||||
*outHit = true;
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
void assetLocaleCacheInsert(
|
||||
assetlocalefile_t *file,
|
||||
const char_t *messageId,
|
||||
const int32_t pluralCount,
|
||||
const char_t *value
|
||||
) {
|
||||
assertNotNull(file, "Asset file cannot be NULL.");
|
||||
assertNotNull(messageId, "Message ID cannot be NULL.");
|
||||
assertNotNull(value, "Value cannot be NULL.");
|
||||
assertStrLenMin(messageId, 1, "Message ID cannot be empty.");
|
||||
|
||||
// Caching is a pure optimization - a message ID or value too long for a
|
||||
// fixed cache slot is just never cached, not an error.
|
||||
if(strlen(messageId) >= ASSET_LOCALE_CACHE_KEY_MAX) return;
|
||||
if(strlen(value) >= ASSET_LOCALE_CACHE_VALUE_MAX) return;
|
||||
|
||||
if(file->cache == NULL) {
|
||||
file->cache =
|
||||
(assetlocalecache_t *)memoryAllocate(sizeof(assetlocalecache_t));
|
||||
memoryZero(file->cache, sizeof(assetlocalecache_t));
|
||||
}
|
||||
|
||||
// Shift every entry down one slot, dropping the least-recently-used one
|
||||
// off the end, to make room for the new entry at the front. This assumes
|
||||
// messageId is never already present elsewhere in the cache, which holds
|
||||
// as long as callers only insert after a confirmed assetLocaleCacheFind
|
||||
// miss (a hit would have returned before reaching this point).
|
||||
memoryMove(
|
||||
&file->cache->entries[1], &file->cache->entries[0],
|
||||
(ASSET_LOCALE_CACHE_COUNT - 1) * sizeof(assetlocalecacheentry_t)
|
||||
);
|
||||
|
||||
assetlocalecacheentry_t *entry = &file->cache->entries[0];
|
||||
stringCopy(entry->messageId, messageId, ASSET_LOCALE_CACHE_KEY_MAX);
|
||||
entry->pluralCount = pluralCount;
|
||||
stringCopy(entry->value, value, ASSET_LOCALE_CACHE_VALUE_MAX);
|
||||
}
|
||||
|
||||
// Shared by assetLocaleGetString (external callers, messageId required
|
||||
// non-empty) and assetLocaleGetHeader (messageId "", the PO format's own
|
||||
// sentinel for its header entry - see assetLocaleGetHeader). Caching is
|
||||
// skipped entirely for an empty messageId: assetLocaleCacheFind/Insert
|
||||
// both reject one outright (same guard as assetLocaleGetString's own),
|
||||
// and it's a one-shot boot-time read anyway, not worth caching.
|
||||
errorret_t assetLocaleGetStringLookup(
|
||||
assetlocalefile_t *file,
|
||||
const char_t *messageId,
|
||||
const int32_t pluralCount,
|
||||
@@ -482,6 +575,15 @@ errorret_t assetLocaleGetString(
|
||||
assertTrue(pluralCount >= 0, "Plural index cannot be negative.");
|
||||
assertNotNull(stringBuffer, "String buffer cannot be NULL.");
|
||||
assertTrue(stringBufferSize > 0, "String buffer size must be > 0");
|
||||
|
||||
bool_t cacheHit = false;
|
||||
if(messageId[0] != '\0') {
|
||||
errorChain(assetLocaleCacheFind(
|
||||
file, messageId, pluralCount, stringBuffer, stringBufferSize, &cacheHit
|
||||
));
|
||||
if(cacheHit) errorOk();
|
||||
}
|
||||
|
||||
assetfilelinereader_t reader;
|
||||
|
||||
bool_t msgidFound = false, msgidPluralFound = false, msgstrFound = false;
|
||||
@@ -588,7 +690,7 @@ errorret_t assetLocaleGetString(
|
||||
|
||||
// Parse until ]
|
||||
char *end = strchr(ptr, ']');
|
||||
if(!end) {
|
||||
if(end == NULL) {
|
||||
errorThrow("Expected ] for plural form, found: %s", lineBuffer);
|
||||
}
|
||||
*end = '\0';
|
||||
@@ -625,9 +727,38 @@ errorret_t assetLocaleGetString(
|
||||
errorThrow("Failed to find msgstr for message ID: %s", messageId);
|
||||
}
|
||||
|
||||
if(messageId[0] != '\0') {
|
||||
assetLocaleCacheInsert(file, messageId, pluralCount, stringBuffer);
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetLocaleGetString(
|
||||
assetlocalefile_t *file,
|
||||
const char_t *messageId,
|
||||
const int32_t pluralCount,
|
||||
char_t *stringBuffer,
|
||||
const size_t stringBufferSize
|
||||
) {
|
||||
assertNotNull(messageId, "Message ID cannot be NULL.");
|
||||
assertStrLenMin(messageId, 1, "Message ID cannot be empty.");
|
||||
|
||||
return assetLocaleGetStringLookup(
|
||||
file, messageId, pluralCount, stringBuffer, stringBufferSize
|
||||
);
|
||||
}
|
||||
|
||||
errorret_t assetLocaleGetHeader(
|
||||
assetlocalefile_t *file,
|
||||
char_t *stringBuffer,
|
||||
const size_t stringBufferSize
|
||||
) {
|
||||
return assetLocaleGetStringLookup(
|
||||
file, "", 0, stringBuffer, stringBufferSize
|
||||
);
|
||||
}
|
||||
|
||||
errorret_t assetLocaleGetStringWithVA(
|
||||
assetlocalefile_t *file,
|
||||
const char_t *messageId,
|
||||
@@ -723,7 +854,7 @@ errorret_t assetLocaleGetStringWithArgs(
|
||||
|
||||
inIndex++;
|
||||
|
||||
/* Escaped percent */
|
||||
// Escaped percent
|
||||
if(format[inIndex] == '%') {
|
||||
if(outIndex + 1 >= bufferSize) {
|
||||
memoryFree(format);
|
||||
@@ -749,7 +880,7 @@ errorret_t assetLocaleGetStringWithArgs(
|
||||
|
||||
specBuffer[specLength++] = '%';
|
||||
|
||||
/* Allow flags / width / precision */
|
||||
// Allow flags / width / precision
|
||||
while(format[inIndex] != '\0') {
|
||||
char_t ch = format[inIndex];
|
||||
|
||||
|
||||
@@ -70,6 +70,41 @@ typedef struct {
|
||||
};
|
||||
} assetlocalearg_t;
|
||||
|
||||
/** Number of recently resolved strings @ref assetlocalecache_t remembers. */
|
||||
#define ASSET_LOCALE_CACHE_COUNT 128
|
||||
|
||||
/** Max length (excluding null terminator) of a cacheable message ID. */
|
||||
#define ASSET_LOCALE_CACHE_KEY_MAX 64
|
||||
|
||||
/** Max length (excluding null terminator) of a cacheable resolved string. */
|
||||
#define ASSET_LOCALE_CACHE_VALUE_MAX 256
|
||||
|
||||
/** One (messageId, pluralCount) -> resolved string cache slot. */
|
||||
typedef struct {
|
||||
char_t messageId[ASSET_LOCALE_CACHE_KEY_MAX];
|
||||
int32_t pluralCount;
|
||||
char_t value[ASSET_LOCALE_CACHE_VALUE_MAX];
|
||||
} assetlocalecacheentry_t;
|
||||
|
||||
/**
|
||||
* Fixed-size move-to-front LRU cache of recently resolved locale strings.
|
||||
* assetLocaleGetString() re-scans and re-decompresses the whole PO file on
|
||||
* every miss, which is expensive to repeat for strings a screen fetches
|
||||
* every time it opens (menu labels, etc) - this cache lets identical
|
||||
* (messageId, pluralCount) lookups skip that entirely.
|
||||
*
|
||||
* Lazily allocated on the first cache insert (see assetlocalefile_t.cache)
|
||||
* so locale entries that are never queried, or a file that's disposed
|
||||
* before anything is cached, never pay for it.
|
||||
*/
|
||||
typedef struct {
|
||||
/**
|
||||
* Entries ordered most-recently-used first. An entry with
|
||||
* messageId[0] == '\0' (and every entry after it) is unused.
|
||||
*/
|
||||
assetlocalecacheentry_t entries[ASSET_LOCALE_CACHE_COUNT];
|
||||
} assetlocalecache_t;
|
||||
|
||||
/**
|
||||
* Runtime state for an open locale file.
|
||||
*
|
||||
@@ -98,6 +133,16 @@ typedef struct {
|
||||
|
||||
/** Form index used when no conditional clause matches. */
|
||||
uint8_t pluralDefaultIndex;
|
||||
|
||||
/**
|
||||
* Recently resolved string cache, or NULL if nothing has been cached yet.
|
||||
* Heap-allocated rather than embedded because assetlocalefile_t lives
|
||||
* inside the shared assetloaderoutput_t union alongside every other
|
||||
* asset type - embedding a 128-entry cache there would size that union
|
||||
* (and therefore every one of the ASSET_ENTRY_COUNT_MAX asset slots,
|
||||
* regardless of what type of asset occupies it) up by the same amount.
|
||||
*/
|
||||
assetlocalecache_t *cache;
|
||||
} assetlocalefile_t;
|
||||
|
||||
/** Convenience alias - the loaded output type of a locale asset entry. */
|
||||
@@ -204,14 +249,92 @@ errorret_t assetLocaleLineUnbuffer(
|
||||
);
|
||||
|
||||
/**
|
||||
* Looks up a translated string by message ID from the open locale file.
|
||||
* Searches a locale file's cache for a previously resolved
|
||||
* (messageId, pluralCount) pair.
|
||||
*
|
||||
* Rewinds the file and scans from the beginning on every call. For plural
|
||||
* entries (`msgid_plural`) the `pluralCount` is evaluated against the loaded
|
||||
* plural rules to select the correct `msgstr[N]` form.
|
||||
* On a hit, copies the cached value into `stringBuffer` (erroring if it
|
||||
* doesn't fit, same contract as @ref assetLocaleGetString) and moves the
|
||||
* entry to the front of the cache's move-to-front LRU order. On a miss,
|
||||
* `stringBuffer` is left untouched.
|
||||
*
|
||||
* @param file Locale file whose cache to search. Its cache may be NULL
|
||||
* (nothing cached yet), which is treated as a miss.
|
||||
* @param messageId Message ID to look up.
|
||||
* @param pluralCount Plural count the original lookup used.
|
||||
* @param stringBuffer Destination buffer, filled only on a hit.
|
||||
* @param stringBufferSize Capacity of `stringBuffer` in bytes.
|
||||
* @param outHit Set to true on a cache hit, false on a miss.
|
||||
* @return OK on success (hit or miss), error if a hit's cached value does
|
||||
* not fit `stringBuffer`.
|
||||
*/
|
||||
errorret_t assetLocaleCacheFind(
|
||||
assetlocalefile_t *file,
|
||||
const char_t *messageId,
|
||||
const int32_t pluralCount,
|
||||
char_t *stringBuffer,
|
||||
const size_t stringBufferSize,
|
||||
bool_t *outHit
|
||||
);
|
||||
|
||||
/**
|
||||
* Records a resolved (messageId, pluralCount) -> value string at the front
|
||||
* of the cache's move-to-front LRU order, evicting the least-recently-used
|
||||
* entry if the cache is already full. Lazily allocates the cache (see
|
||||
* assetlocalefile_t.cache) on the first call.
|
||||
*
|
||||
* Caching is a pure optimization: if `messageId` or `value` is too long to
|
||||
* fit the cache's fixed-size slots, this silently does nothing rather than
|
||||
* erroring or growing the cache.
|
||||
*
|
||||
* @param file Locale file whose cache to insert into.
|
||||
* @param messageId Message ID that was looked up.
|
||||
* @param pluralCount Plural count the lookup was made with.
|
||||
* @param value Resolved string to cache.
|
||||
*/
|
||||
void assetLocaleCacheInsert(
|
||||
assetlocalefile_t *file,
|
||||
const char_t *messageId,
|
||||
const int32_t pluralCount,
|
||||
const char_t *value
|
||||
);
|
||||
|
||||
/**
|
||||
* Shared lookup core behind assetLocaleGetString and assetLocaleGetHeader:
|
||||
* checks the file's cache first (see @ref assetLocaleCacheFind; skipped
|
||||
* entirely for an empty messageId, since the cache rejects one), on a
|
||||
* miss rewinds the file and scans from the beginning, then caches the
|
||||
* result (see @ref assetLocaleCacheInsert, same empty-messageId skip)
|
||||
* before returning. For plural entries (`msgid_plural`) the
|
||||
* `pluralCount` is evaluated against the loaded plural rules to select
|
||||
* the correct `msgstr[N]` form.
|
||||
*
|
||||
* Unlike assetLocaleGetString, messageId may be `""` here (see
|
||||
* assetLocaleGetHeader) - this is the shared implementation both of
|
||||
* them delegate to, not a public entry point of its own in practice.
|
||||
*
|
||||
* @param file Locale file to search. Must be open.
|
||||
* @param messageId PO message ID to find (`""` retrieves the header entry).
|
||||
* @param messageId PO message ID to find, or `""` for the header entry.
|
||||
* @param pluralCount Count used to select the plural form (ignored for
|
||||
* singular entries).
|
||||
* @param stringBuffer Buffer to receive the translated string.
|
||||
* @param stringBufferSize Capacity of `stringBuffer` in bytes.
|
||||
* @return OK on success, error if the message ID is not found or I/O fails.
|
||||
*/
|
||||
errorret_t assetLocaleGetStringLookup(
|
||||
assetlocalefile_t *file,
|
||||
const char_t *messageId,
|
||||
const int32_t pluralCount,
|
||||
char_t *stringBuffer,
|
||||
const size_t stringBufferSize
|
||||
);
|
||||
|
||||
/**
|
||||
* Looks up a translated string by message ID from the open locale file.
|
||||
* See @ref assetLocaleGetStringLookup for the lookup/caching mechanics.
|
||||
*
|
||||
* @param file Locale file to search. Must be open.
|
||||
* @param messageId PO message ID to find. Must be non-empty - use
|
||||
* @ref assetLocaleGetHeader to read the header entry.
|
||||
* @param pluralCount Count used to select the plural form (ignored for
|
||||
* singular entries).
|
||||
* @param stringBuffer Buffer to receive the translated string.
|
||||
@@ -226,6 +349,27 @@ errorret_t assetLocaleGetString(
|
||||
const size_t stringBufferSize
|
||||
);
|
||||
|
||||
/**
|
||||
* Reads the PO file's header entry (the `msgid ""` block every PO file
|
||||
* starts with, holding metadata like the plural-forms rule) - see @ref
|
||||
* assetLocaleParseHeader, its caller. A dedicated function rather than
|
||||
* calling assetLocaleGetString(file, "", ...) since messageId "" is a
|
||||
* PO-format-internal sentinel, not a real (untrusted) caller-supplied
|
||||
* message ID, so it doesn't go through assetLocaleGetString's normal
|
||||
* non-empty validation.
|
||||
*
|
||||
* @param file Locale file to search. Must be open.
|
||||
* @param stringBuffer Buffer to receive the raw header block.
|
||||
* @param stringBufferSize Capacity of `stringBuffer` in bytes.
|
||||
* @return OK on success, error if the header entry is missing or I/O
|
||||
* fails.
|
||||
*/
|
||||
errorret_t assetLocaleGetHeader(
|
||||
assetlocalefile_t *file,
|
||||
char_t *stringBuffer,
|
||||
const size_t stringBufferSize
|
||||
);
|
||||
|
||||
/**
|
||||
* Looks up a translated string and formats it with a `printf`-style variadic
|
||||
* argument list.
|
||||
|
||||
@@ -5,5 +5,5 @@
|
||||
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
scenemainmenu.c
|
||||
assetmp3loader.c
|
||||
)
|
||||
@@ -0,0 +1,255 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "assetmp3loader.h"
|
||||
#include "util/memory.h"
|
||||
#include "util/math.h"
|
||||
#include "assert/assert.h"
|
||||
#include "asset/loader/assetloading.h"
|
||||
#include "asset/loader/assetentry.h"
|
||||
|
||||
// How far into the file (after any ID3v2 tag) assetMp3ParseHeader() will
|
||||
// search for the first valid MPEG frame sync. Real encoders write it
|
||||
// within the first handful of bytes; this is a generous sane upper bound
|
||||
// (matching assetwavloader.c's own approach to bounding a stack buffer)
|
||||
// rather than a real expectation of needing that much.
|
||||
#define ASSET_MP3_HEADER_SEARCH_MAX 8192
|
||||
|
||||
// MPEG-1 Layer III bitrates (kbps), indexed by the header's 4-bit bitrate
|
||||
// index. Index 0 ("free format") and 15 (reserved) aren't supported.
|
||||
static const uint16_t ASSET_MP3_BITRATE_MPEG1_L3[16] = {
|
||||
0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0
|
||||
};
|
||||
|
||||
// MPEG-2/2.5 Layer III bitrates (kbps) - a different table from MPEG-1's.
|
||||
static const uint16_t ASSET_MP3_BITRATE_MPEG2_L3[16] = {
|
||||
0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0
|
||||
};
|
||||
|
||||
static const uint32_t ASSET_MP3_SAMPLE_RATE_MPEG1[4] = {
|
||||
44100, 48000, 32000, 0
|
||||
};
|
||||
static const uint32_t ASSET_MP3_SAMPLE_RATE_MPEG2[4] = {
|
||||
22050, 24000, 16000, 0
|
||||
};
|
||||
static const uint32_t ASSET_MP3_SAMPLE_RATE_MPEG25[4] = {
|
||||
11025, 12000, 8000, 0
|
||||
};
|
||||
|
||||
errorret_t assetMp3LoaderAsync(assetloading_t *loading) {
|
||||
assertNotNull(loading, "Loading cannot be NULL");
|
||||
assertNotMainThread("Async loader should not be on main thread.");
|
||||
|
||||
if(loading->loading.mp3.state != ASSET_MP3_LOADER_STATE_READ_HEADER) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
assetmp3file_t *mp3File = &loading->entry->data.mp3;
|
||||
memoryZero(mp3File, sizeof(assetmp3file_t));
|
||||
|
||||
assetfile_t file;
|
||||
assetLoaderErrorChain(loading, assetFileInit(
|
||||
&file, loading->entry->name, NULL, NULL
|
||||
));
|
||||
assetLoaderErrorChain(loading, assetFileOpen(&file));
|
||||
assetLoaderErrorChain(loading, assetMp3ParseHeader(&file, mp3File));
|
||||
assetLoaderErrorChain(loading, assetFileClose(&file));
|
||||
assetLoaderErrorChain(loading, assetFileDispose(&file));
|
||||
|
||||
loading->loading.mp3.state = ASSET_MP3_LOADER_STATE_DONE;
|
||||
loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetMp3LoaderSync(assetloading_t *loading) {
|
||||
assertNotNull(loading, "Loading cannot be NULL");
|
||||
assertTrue(loading->type == ASSET_LOADER_TYPE_MP3, "Invalid type.");
|
||||
assertIsMainThread("Must be called from the main thread.");
|
||||
|
||||
switch(loading->loading.mp3.state) {
|
||||
case ASSET_MP3_LOADER_STATE_INITIAL:
|
||||
loading->loading.mp3.state = ASSET_MP3_LOADER_STATE_READ_HEADER;
|
||||
loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
|
||||
errorOk();
|
||||
break;
|
||||
|
||||
case ASSET_MP3_LOADER_STATE_DONE:
|
||||
break;
|
||||
|
||||
default:
|
||||
errorOk();
|
||||
}
|
||||
|
||||
loading->entry->state = ASSET_ENTRY_STATE_LOADED;
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetMp3Dispose(assetentry_t *entry) {
|
||||
assertNotNull(entry, "Asset entry cannot be NULL");
|
||||
assertTrue(entry->type == ASSET_LOADER_TYPE_MP3, "Invalid type.");
|
||||
assertIsMainThread("Must be called from the main thread.");
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetMp3ParseHeader(assetfile_t *file, assetmp3file_t *mp3File) {
|
||||
assertNotNull(file, "Asset file cannot be NULL.");
|
||||
assertNotNull(mp3File, "Mp3 file cannot be NULL.");
|
||||
|
||||
memoryZero(mp3File, sizeof(assetmp3file_t));
|
||||
|
||||
// Skip a leading ID3v2 tag if present: "ID3" + version(2) + flags(1) + a
|
||||
// 4-byte syncsafe (7 usable bits/byte) size covering everything after
|
||||
// this 10-byte header.
|
||||
uint8_t id3Header[10];
|
||||
errorChain(assetFileRead(file, id3Header, sizeof(id3Header)));
|
||||
|
||||
size_t searchBase;
|
||||
if(memoryCompare(id3Header, "ID3", 3) == 0) {
|
||||
const uint32_t tagSize = (
|
||||
((uint32_t) (id3Header[6] & 0x7F) << 21) |
|
||||
((uint32_t) (id3Header[7] & 0x7F) << 14) |
|
||||
((uint32_t) (id3Header[8] & 0x7F) << 7) |
|
||||
((uint32_t) (id3Header[9] & 0x7F))
|
||||
);
|
||||
errorChain(assetFileRead(file, NULL, tagSize));
|
||||
searchBase = sizeof(id3Header) + tagSize;
|
||||
} else {
|
||||
// No ID3v2 tag - rewind the probe bytes just consumed so the frame
|
||||
// sync search below starts from the true beginning of the file.
|
||||
errorChain(assetFileRewind(file));
|
||||
searchBase = 0;
|
||||
}
|
||||
|
||||
const size_t searchWindowSize = mathMin(
|
||||
(size_t) ASSET_MP3_HEADER_SEARCH_MAX,
|
||||
(size_t) file->size > searchBase ? (size_t) file->size - searchBase : 0
|
||||
);
|
||||
if(searchWindowSize < 4) {
|
||||
errorThrow(
|
||||
"MP3 file is too short to contain a frame header: %s", file->filename
|
||||
);
|
||||
}
|
||||
|
||||
uint8_t *window = (uint8_t *) memoryAllocate(searchWindowSize);
|
||||
errorret_t readRet = assetFileRead(file, window, searchWindowSize);
|
||||
if(errorIsNotOk(readRet)) {
|
||||
memoryFree(window);
|
||||
errorChain(readRet);
|
||||
}
|
||||
|
||||
bool_t found = false;
|
||||
size_t frameIndex = 0;
|
||||
|
||||
for(size_t i = 0; i + 4 <= searchWindowSize; i++) {
|
||||
if(window[i] != 0xFF || (window[i + 1] & 0xE0) != 0xE0) continue;
|
||||
|
||||
const uint8_t versionBits = (window[i + 1] >> 3) & 0x3;
|
||||
const uint8_t layerBits = (window[i + 1] >> 1) & 0x3;
|
||||
// reserved version, or not Layer III
|
||||
if(versionBits == 1 || layerBits != 1) continue;
|
||||
|
||||
const uint8_t bitrateIndex = (window[i + 2] >> 4) & 0xF;
|
||||
const uint8_t sampleRateIndex = (window[i + 2] >> 2) & 0x3;
|
||||
if(
|
||||
bitrateIndex == 0 || bitrateIndex == 15 || sampleRateIndex == 3
|
||||
) continue;
|
||||
|
||||
const uint8_t channelMode = (window[i + 3] >> 6) & 0x3;
|
||||
const bool_t isMpeg1 = versionBits == 3;
|
||||
|
||||
mp3File->bitrateKbps = isMpeg1
|
||||
? ASSET_MP3_BITRATE_MPEG1_L3[bitrateIndex]
|
||||
: ASSET_MP3_BITRATE_MPEG2_L3[bitrateIndex];
|
||||
mp3File->sampleRate = isMpeg1
|
||||
? ASSET_MP3_SAMPLE_RATE_MPEG1[sampleRateIndex]
|
||||
: (versionBits == 2
|
||||
? ASSET_MP3_SAMPLE_RATE_MPEG2[sampleRateIndex]
|
||||
: ASSET_MP3_SAMPLE_RATE_MPEG25[sampleRateIndex]);
|
||||
mp3File->samplesPerFrame = isMpeg1 ? 1152 : 576;
|
||||
mp3File->channels = channelMode == 3 ? 1 : 2;
|
||||
|
||||
// A Xing/Info header, if present, sits right after the side info -
|
||||
// whose size depends on MPEG version and channel mode - immediately
|
||||
// following the 4-byte header (plus a 2-byte CRC, if the protection
|
||||
// bit says one follows).
|
||||
const bool_t hasCrc = (window[i + 1] & 0x1) == 0;
|
||||
const size_t sideInfoSize = isMpeg1
|
||||
? (mp3File->channels == 1 ? 17 : 32)
|
||||
: (mp3File->channels == 1 ? 9 : 17);
|
||||
const size_t xingOffset = i + 4 + (hasCrc ? 2 : 0) + sideInfoSize;
|
||||
|
||||
if(
|
||||
xingOffset + 8 <= searchWindowSize &&
|
||||
(
|
||||
memoryCompare(window + xingOffset, "Xing", 4) == 0 ||
|
||||
memoryCompare(window + xingOffset, "Info", 4) == 0
|
||||
)
|
||||
) {
|
||||
const uint8_t *flagsBytes = window + xingOffset + 4;
|
||||
const uint32_t flags = (
|
||||
((uint32_t) flagsBytes[0] << 24) | ((uint32_t) flagsBytes[1] << 16) |
|
||||
((uint32_t) flagsBytes[2] << 8) | (uint32_t) flagsBytes[3]
|
||||
);
|
||||
if((flags & 0x1) != 0 && xingOffset + 12 <= searchWindowSize) {
|
||||
const uint8_t *framesBytes = window + xingOffset + 8;
|
||||
const uint32_t xingFrameCount = (
|
||||
((uint32_t) framesBytes[0] << 24) |
|
||||
((uint32_t) framesBytes[1] << 16) |
|
||||
((uint32_t) framesBytes[2] << 8) |
|
||||
(uint32_t) framesBytes[3]
|
||||
);
|
||||
// The Xing/Info header's frame count includes the header's own
|
||||
// frame (this one, at `i`) - which libmad (and sceMp3) will
|
||||
// attempt to decode like any other, but which doesn't contribute a
|
||||
// real decodable frame of audio the way every other one does.
|
||||
// Confirmed against a real LAME-encoded file: its Xing header
|
||||
// declared 40 frames, but decoding actually produced exactly 39
|
||||
// frames' worth of real PCM - without this -1, playback would
|
||||
// permanently stall one frame short of the declared total (audible
|
||||
// as "never loops"), since real decode output can never catch up
|
||||
// to an overstated total.
|
||||
if(xingFrameCount > 0) {
|
||||
mp3File->totalFrames =
|
||||
(size_t) (xingFrameCount - 1) * mp3File->samplesPerFrame;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
frameIndex = i;
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
|
||||
memoryFree(window);
|
||||
|
||||
if(!found) {
|
||||
errorThrow(
|
||||
"MP3 file has no valid MPEG-1/2/2.5 Layer III frame within the first "
|
||||
"%u bytes: %s",
|
||||
(uint32_t) searchWindowSize, file->filename
|
||||
);
|
||||
}
|
||||
|
||||
mp3File->dataOffset = searchBase + frameIndex;
|
||||
mp3File->dataSize = (size_t) file->size - mp3File->dataOffset;
|
||||
|
||||
// No Xing/Info header found - estimate assuming constant bitrate (the
|
||||
// common case when one's genuinely absent; a real VBR file without one
|
||||
// is rare and will just get an approximate duration/loop point instead
|
||||
// of an exact one).
|
||||
if(mp3File->totalFrames == 0) {
|
||||
const float_t durationSeconds = (
|
||||
((float_t) mp3File->dataSize * 8.0f) /
|
||||
((float_t) mp3File->bitrateKbps * 1000.0f)
|
||||
);
|
||||
mp3File->totalFrames =
|
||||
(size_t) (durationSeconds * (float_t) mp3File->sampleRate);
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
#include "asset/assetfile.h"
|
||||
|
||||
typedef struct assetloading_s assetloading_t;
|
||||
typedef struct assetentry_s assetentry_t;
|
||||
|
||||
typedef struct { void *nothing; } assetmp3loaderinput_t;
|
||||
|
||||
typedef enum {
|
||||
ASSET_MP3_LOADER_STATE_INITIAL,
|
||||
ASSET_MP3_LOADER_STATE_READ_HEADER,
|
||||
ASSET_MP3_LOADER_STATE_DONE
|
||||
} assetmp3loaderstate_t;
|
||||
|
||||
typedef struct {
|
||||
assetmp3loaderstate_t state;
|
||||
} assetmp3loaderloading_t;
|
||||
|
||||
/**
|
||||
* Parsed metadata for an MP3 asset - deliberately just enough to configure
|
||||
* a decoder and know the clip's total length, not anything about its
|
||||
* actual compressed content (which is read/decoded on demand at playback
|
||||
* time - see audiostreammp3.c). Only MPEG-1/2/2.5 Layer III ("MP3" in the
|
||||
* everyday sense) is supported; Layers I/II are rejected.
|
||||
*/
|
||||
typedef struct {
|
||||
uint32_t sampleRate;
|
||||
uint8_t channels;
|
||||
|
||||
// 1152 for MPEG-1, 576 for MPEG-2/2.5 - how many PCM samples (per
|
||||
// channel) one compressed MPEG frame decodes to.
|
||||
uint16_t samplesPerFrame;
|
||||
|
||||
// The first frame's bitrate, in kbps. Used only as a fallback duration
|
||||
// estimate (assuming CBR) when no Xing/Info header is found - see
|
||||
// assetMp3ParseHeader()'s own comment.
|
||||
uint32_t bitrateKbps;
|
||||
|
||||
// Byte offset (from the start of the file) of the first real MPEG
|
||||
// frame, i.e. right after any leading ID3v2 tag.
|
||||
size_t dataOffset;
|
||||
|
||||
// Bytes of compressed MPEG data, from dataOffset to the end of the file.
|
||||
size_t dataSize;
|
||||
|
||||
// Decoded PCM frame count for the whole clip - exact if a Xing/Info
|
||||
// header was found (the common case for anything encoded with a modern
|
||||
// tool), otherwise estimated from bitrateKbps/dataSize assuming CBR (see
|
||||
// assetMp3ParseHeader()'s own comment) - unlike assetwavfile_t.dataSize,
|
||||
// MP3 has no header field that gives this directly.
|
||||
size_t totalFrames;
|
||||
} assetmp3file_t;
|
||||
|
||||
typedef assetmp3file_t assetmp3output_t;
|
||||
|
||||
/**
|
||||
* Async (background-thread) half of the MP3 loader - opens the asset file,
|
||||
* parses its header (see assetMp3ParseHeader()), and closes it again. Never
|
||||
* buffers the compressed MPEG data itself; that's read on demand at
|
||||
* playback time by audiostreammp3.c via its own independent file handle.
|
||||
*
|
||||
* @param loading The asset loading slot.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t assetMp3LoaderAsync(assetloading_t *loading);
|
||||
|
||||
/**
|
||||
* Sync (main-thread) half of the MP3 loader - a simple state machine that
|
||||
* schedules the async header parse and marks the entry loaded once it's
|
||||
* done, mirroring assetWavLoaderSync()'s shape exactly.
|
||||
*
|
||||
* @param loading The asset loading slot.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t assetMp3LoaderSync(assetloading_t *loading);
|
||||
|
||||
/**
|
||||
* Disposes an MP3 asset entry. A no-op - an assetmp3file_t owns no heap
|
||||
* allocations, and playback streams open their own independent file
|
||||
* handles (see audiostreammp3.c).
|
||||
*
|
||||
* @param entry The asset entry to dispose.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t assetMp3Dispose(assetentry_t *entry);
|
||||
|
||||
/**
|
||||
* Parses an MP3 file's metadata from an already-opened asset file
|
||||
* positioned at its very start: skips a leading ID3v2 tag if present,
|
||||
* scans forward for the first valid MPEG-1/2/2.5 Layer III frame header
|
||||
* (rejecting anything else - other layers, or no valid frame found within
|
||||
* a sane search window), and checks that frame for a Xing/Info header
|
||||
* (found in the vast majority of real-world MP3s, VBR or CBR) to get an
|
||||
* exact total-frame count; falls back to a CBR estimate from the first
|
||||
* frame's bitrate and the file's remaining size if absent.
|
||||
*
|
||||
* Never reads more than a bounded lookahead window into memory - the bulk
|
||||
* of the file (the actual compressed audio, following the parsed frame's
|
||||
* position) is left untouched, exactly like assetWavParseHeader().
|
||||
*
|
||||
* @param file Asset file to parse, positioned at offset 0.
|
||||
* @param mp3File Filled with the parsed metadata on success.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t assetMp3ParseHeader(assetfile_t *file, assetmp3file_t *mp3File);
|
||||
@@ -0,0 +1,10 @@
|
||||
# Copyright (c) 2026 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
assetwavloader.c
|
||||
)
|
||||
@@ -0,0 +1,181 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "assetwavloader.h"
|
||||
#include "util/memory.h"
|
||||
#include "util/endian.h"
|
||||
#include "assert/assert.h"
|
||||
#include "asset/loader/assetloading.h"
|
||||
#include "asset/loader/assetentry.h"
|
||||
|
||||
// "RIFF" + chunkSize + "WAVE", before any sub-chunks begin.
|
||||
#define ASSET_WAV_RIFF_HEADER_SIZE 12
|
||||
|
||||
// A sub-chunk header is a 4-byte id followed by a 4-byte little-endian size.
|
||||
#define ASSET_WAV_CHUNK_HEADER_SIZE 8
|
||||
|
||||
#define ASSET_WAV_FMT_CHUNK_SIZE_MIN 16
|
||||
// Sane upper bound for a stack buffer - real fmt chunks (PCM or otherwise)
|
||||
// never come close to this; anything bigger is treated as malformed.
|
||||
#define ASSET_WAV_FMT_CHUNK_SIZE_MAX 64
|
||||
|
||||
errorret_t assetWavLoaderAsync(assetloading_t *loading) {
|
||||
assertNotNull(loading, "Loading cannot be NULL");
|
||||
assertNotMainThread("Async loader should not be on main thread.");
|
||||
|
||||
if(loading->loading.wav.state != ASSET_WAV_LOADER_STATE_READ_HEADER) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
assetwavfile_t *wavFile = &loading->entry->data.wav;
|
||||
memoryZero(wavFile, sizeof(assetwavfile_t));
|
||||
|
||||
assetfile_t file;
|
||||
assetLoaderErrorChain(loading, assetFileInit(
|
||||
&file, loading->entry->name, NULL, NULL
|
||||
));
|
||||
assetLoaderErrorChain(loading, assetFileOpen(&file));
|
||||
assetLoaderErrorChain(loading, assetWavParseHeader(&file, wavFile));
|
||||
assetLoaderErrorChain(loading, assetFileClose(&file));
|
||||
assetLoaderErrorChain(loading, assetFileDispose(&file));
|
||||
|
||||
loading->loading.wav.state = ASSET_WAV_LOADER_STATE_DONE;
|
||||
loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetWavLoaderSync(assetloading_t *loading) {
|
||||
assertNotNull(loading, "Loading cannot be NULL");
|
||||
assertTrue(loading->type == ASSET_LOADER_TYPE_WAV, "Invalid type.");
|
||||
assertIsMainThread("Must be called from the main thread.");
|
||||
|
||||
switch(loading->loading.wav.state) {
|
||||
case ASSET_WAV_LOADER_STATE_INITIAL:
|
||||
loading->loading.wav.state = ASSET_WAV_LOADER_STATE_READ_HEADER;
|
||||
loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
|
||||
errorOk();
|
||||
break;
|
||||
|
||||
case ASSET_WAV_LOADER_STATE_DONE:
|
||||
break;
|
||||
|
||||
default:
|
||||
errorOk();
|
||||
}
|
||||
|
||||
loading->entry->state = ASSET_ENTRY_STATE_LOADED;
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetWavDispose(assetentry_t *entry) {
|
||||
assertNotNull(entry, "Asset entry cannot be NULL");
|
||||
assertTrue(entry->type == ASSET_LOADER_TYPE_WAV, "Invalid type.");
|
||||
assertIsMainThread("Must be called from the main thread.");
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t assetWavParseHeader(
|
||||
assetfile_t *file,
|
||||
assetwavfile_t *wavFile
|
||||
) {
|
||||
assertNotNull(file, "Asset file cannot be NULL.");
|
||||
assertNotNull(wavFile, "Wav file cannot be NULL.");
|
||||
|
||||
uint8_t riffHeader[ASSET_WAV_RIFF_HEADER_SIZE];
|
||||
errorChain(assetFileRead(file, riffHeader, sizeof(riffHeader)));
|
||||
|
||||
if(memoryCompare(riffHeader, "RIFF", 4) != 0) {
|
||||
errorThrow("WAV file has an invalid RIFF header: %s", file->filename);
|
||||
}
|
||||
if(memoryCompare(riffHeader + 8, "WAVE", 4) != 0) {
|
||||
errorThrow("WAV file has an invalid WAVE header: %s", file->filename);
|
||||
}
|
||||
|
||||
bool_t foundFormat = false;
|
||||
bool_t foundData = false;
|
||||
uint16_t audioFormat = 0;
|
||||
|
||||
// Walk the chunk list, reading only chunk headers (and the small "fmt "
|
||||
// body) - every other chunk, "data"'s sample bytes included, is skipped
|
||||
// via a NULL-buffer read rather than buffered into memory. Stops as soon
|
||||
// as "data" is found; nothing after it matters here.
|
||||
while(!foundData && (size_t) file->position < (size_t) file->size) {
|
||||
uint8_t chunkHeader[ASSET_WAV_CHUNK_HEADER_SIZE];
|
||||
errorChain(assetFileRead(file, chunkHeader, sizeof(chunkHeader)));
|
||||
|
||||
uint32_t chunkSizeLE;
|
||||
memoryCopy(&chunkSizeLE, chunkHeader + 4, sizeof(chunkSizeLE));
|
||||
const uint32_t chunkSize = endianLittleToHost32(chunkSizeLE);
|
||||
|
||||
// Chunks are padded to an even total size - the pad byte (if any)
|
||||
// isn't included in chunkSize but still needs to be skipped over.
|
||||
const uint32_t chunkSizePadded = chunkSize + (chunkSize % 2);
|
||||
|
||||
if(memoryCompare(chunkHeader, "fmt ", 4) == 0) {
|
||||
if(
|
||||
chunkSize < ASSET_WAV_FMT_CHUNK_SIZE_MIN ||
|
||||
chunkSize > ASSET_WAV_FMT_CHUNK_SIZE_MAX
|
||||
) {
|
||||
errorThrow("WAV 'fmt ' chunk has an unsupported size: %u", chunkSize);
|
||||
}
|
||||
|
||||
uint8_t fmtBuffer[ASSET_WAV_FMT_CHUNK_SIZE_MAX];
|
||||
errorChain(assetFileRead(file, fmtBuffer, chunkSize));
|
||||
if(chunkSize % 2 != 0) {
|
||||
errorChain(assetFileRead(file, NULL, 1));
|
||||
}
|
||||
|
||||
uint16_t u16;
|
||||
uint32_t u32;
|
||||
|
||||
memoryCopy(&u16, fmtBuffer + 0, sizeof(u16));
|
||||
audioFormat = endianLittleToHost16(u16);
|
||||
|
||||
memoryCopy(&u16, fmtBuffer + 2, sizeof(u16));
|
||||
wavFile->channels = (uint8_t) endianLittleToHost16(u16);
|
||||
|
||||
memoryCopy(&u32, fmtBuffer + 4, sizeof(u32));
|
||||
wavFile->sampleRate = endianLittleToHost32(u32);
|
||||
|
||||
memoryCopy(&u16, fmtBuffer + 14, sizeof(u16));
|
||||
wavFile->bitsPerSample = (uint8_t) endianLittleToHost16(u16);
|
||||
|
||||
foundFormat = true;
|
||||
} else if(memoryCompare(chunkHeader, "data", 4) == 0) {
|
||||
wavFile->dataOffset = (size_t) file->position;
|
||||
wavFile->dataSize = chunkSize;
|
||||
foundData = true;
|
||||
} else {
|
||||
errorChain(assetFileRead(file, NULL, chunkSizePadded));
|
||||
}
|
||||
}
|
||||
|
||||
if(!foundFormat) {
|
||||
errorThrow("WAV file is missing its 'fmt ' chunk: %s", file->filename);
|
||||
}
|
||||
if(!foundData) {
|
||||
errorThrow("WAV file is missing its 'data' chunk: %s", file->filename);
|
||||
}
|
||||
if(audioFormat != 1) {
|
||||
errorThrow(
|
||||
"Unsupported WAV audio format: %u (only PCM is supported): %s",
|
||||
audioFormat, file->filename
|
||||
);
|
||||
}
|
||||
if(wavFile->bitsPerSample != 16 && wavFile->bitsPerSample != 24) {
|
||||
errorThrow(
|
||||
"Unsupported WAV bits per sample: %u (only 16/24-bit is supported): %s",
|
||||
wavFile->bitsPerSample, file->filename
|
||||
);
|
||||
}
|
||||
if(wavFile->channels == 0) {
|
||||
errorThrow("WAV file declares 0 channels: %s", file->filename);
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "asset/assetfile.h"
|
||||
|
||||
typedef struct assetloading_s assetloading_t;
|
||||
typedef struct assetentry_s assetentry_t;
|
||||
|
||||
/** Input passed to the wav loader - currently unused. */
|
||||
typedef struct { void *nothing; } assetwavloaderinput_t;
|
||||
|
||||
typedef enum {
|
||||
ASSET_WAV_LOADER_STATE_INITIAL,
|
||||
ASSET_WAV_LOADER_STATE_READ_HEADER,
|
||||
ASSET_WAV_LOADER_STATE_DONE
|
||||
} assetwavloaderstate_t;
|
||||
|
||||
/** Per-slot scratch data used while the wav file is loading. */
|
||||
typedef struct {
|
||||
assetwavloaderstate_t state;
|
||||
} assetwavloaderloading_t;
|
||||
|
||||
/**
|
||||
* Parsed metadata for a WAV asset - only the RIFF/WAVE/fmt/data chunk
|
||||
* headers are ever read; the PCM sample data itself is never loaded here
|
||||
* (see @ref assetWavParseHeader). Playback reads sample data directly
|
||||
* from the archive on demand instead - see audiostreampcm.h.
|
||||
*/
|
||||
typedef struct {
|
||||
/** Sample rate of the PCM data, in Hz. */
|
||||
uint32_t sampleRate;
|
||||
|
||||
/** Number of interleaved channels in the PCM data. */
|
||||
uint8_t channels;
|
||||
|
||||
/**
|
||||
* Bits per sample of the *source* file data - 16 or 24 (see
|
||||
* assetWavParseHeader). Playback always reads 16-bit samples out via
|
||||
* audioStreamPcmRead() regardless of this - a 24-bit source is
|
||||
* truncated to 16-bit there, since none of this project's audio
|
||||
* backends (PSP/Dolphin hardware, SDL2 on Linux) accept anything wider.
|
||||
*/
|
||||
uint8_t bitsPerSample;
|
||||
|
||||
/** Byte offset from the start of the file to the first PCM sample. */
|
||||
size_t dataOffset;
|
||||
|
||||
/** Size of the PCM data, in bytes. */
|
||||
size_t dataSize;
|
||||
} assetwavfile_t;
|
||||
|
||||
/** Convenience alias - the loaded output type of a wav asset entry. */
|
||||
typedef assetwavfile_t assetwavoutput_t;
|
||||
|
||||
/**
|
||||
* Asynchronous loader callback. Opens the WAV file and reads just enough of
|
||||
* it to locate and parse the `fmt ` chunk and locate (not read) the `data`
|
||||
* chunk - see @ref assetWavParseHeader. All I/O happens here so the main
|
||||
* thread is not blocked. Sets entry state to `ASSET_ENTRY_STATE_PENDING_SYNC`
|
||||
* on success or `ASSET_ENTRY_STATE_ERROR` on failure.
|
||||
*
|
||||
* @param loading The loading slot for this asset entry.
|
||||
* @return OK on success, error otherwise.
|
||||
*/
|
||||
errorret_t assetWavLoaderAsync(assetloading_t *loading);
|
||||
|
||||
/**
|
||||
* Synchronous loader callback. Confirms the async phase completed and marks
|
||||
* the entry as `ASSET_ENTRY_STATE_LOADED`.
|
||||
*
|
||||
* @param loading The loading slot for this asset entry.
|
||||
* @return OK on success, error otherwise.
|
||||
*/
|
||||
errorret_t assetWavLoaderSync(assetloading_t *loading);
|
||||
|
||||
/**
|
||||
* Dispose callback. The wav asset owns no allocations of its own (its data
|
||||
* chunk is read directly from the archive by whichever streams are playing
|
||||
* it, each through their own handle - see audiostreampcm.h), so this is
|
||||
* currently a no-op beyond the standard asserts.
|
||||
*
|
||||
* @param entry The asset entry to dispose.
|
||||
* @return OK on success, error otherwise.
|
||||
*/
|
||||
errorret_t assetWavDispose(assetentry_t *entry);
|
||||
|
||||
/**
|
||||
* Parses a RIFF/WAVE file's chunk structure from an already-open asset
|
||||
* file, reading only chunk headers (and the small `fmt ` chunk body) -
|
||||
* every other chunk, including `data`'s actual sample bytes, is skipped
|
||||
* over via `assetFileRead(file, NULL, size)` rather than read into memory,
|
||||
* so this never buffers the (potentially large) PCM payload.
|
||||
*
|
||||
* Stops as soon as the `data` chunk header is found, recording its file
|
||||
* offset and declared size in `wavFile` without reading any of its bytes -
|
||||
* the file is left positioned at the start of the PCM data.
|
||||
*
|
||||
* Only PCM (audio format 1), 16- or 24-bit-per-sample WAV data is
|
||||
* supported - see audiostreampcm.h's audioStreamPcmRead() for how a
|
||||
* 24-bit source gets truncated to the 16-bit output every platform
|
||||
* backend expects. Requires the `fmt ` chunk to appear before `data`, per
|
||||
* the WAV spec's recommended ordering.
|
||||
*
|
||||
* @param file An open asset file, positioned at the start of the WAV data.
|
||||
* @param wavFile Struct whose fields will be filled in.
|
||||
* @return OK on success, error if the file is malformed or an unsupported
|
||||
* format.
|
||||
*/
|
||||
errorret_t assetWavParseHeader(
|
||||
assetfile_t *file,
|
||||
assetwavfile_t *wavFile
|
||||
);
|
||||
@@ -0,0 +1,14 @@
|
||||
# Copyright (c) 2026 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
audio.c
|
||||
)
|
||||
|
||||
# Subdirs
|
||||
add_subdirectory(mixer)
|
||||
add_subdirectory(stream)
|
||||
@@ -0,0 +1,73 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "audio.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "util/memory.h"
|
||||
#include "assert/assert.h"
|
||||
|
||||
audio_t AUDIO;
|
||||
|
||||
errorret_t audioInit() {
|
||||
memoryZero(&AUDIO, sizeof(audio_t));
|
||||
|
||||
errorChain(audioPlatformInit());
|
||||
errorChain(audioMixerInit());
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
audiostream_t * audioAquireStream(assetentry_t *asset) {
|
||||
assertNotNull(asset, "Asset cannot be NULL.");
|
||||
// Same check audioStreamInit() makes - see its own comment on why this
|
||||
// is an assert (a programmer error, not untrusted data). Checking here
|
||||
// too catches the mistake as early as possible, before any stream slot
|
||||
// is handed out for it.
|
||||
assertTrue(
|
||||
audioStreamTypeForAssetType(asset->type) != AUDIO_STREAM_TYPE_NULL,
|
||||
"Unsupported asset type for an audio stream."
|
||||
);
|
||||
|
||||
for(uint8_t i = 0; i < AUDIO_STREAMS_MAX; i++) {
|
||||
audiostream_t *stream = &AUDIO.streams[i];
|
||||
if(stream->type == AUDIO_STREAM_TYPE_NULL) {
|
||||
return stream;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
errorret_t audioUpdateEarly() {
|
||||
errorChain(audioPlatformUpdate());
|
||||
errorChain(audioMixerUpdateEarly());
|
||||
|
||||
for(uint8_t i = 0; i < AUDIO_STREAMS_MAX; i++) {
|
||||
audiostream_t *stream = &AUDIO.streams[i];
|
||||
errorChain(audioStreamUpdate(stream));
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioUpdateLate() {
|
||||
errorChain(audioMixerUpdateLate());
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioDispose() {
|
||||
for(uint8_t i = 0; i < AUDIO_STREAMS_MAX; i++) {
|
||||
audiostream_t *stream = &AUDIO.streams[i];
|
||||
errorChain(audioStreamDispose(stream));
|
||||
}
|
||||
|
||||
errorChain(audioMixerDispose());
|
||||
errorChain(audioPlatformDispose());
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "dusk.h"
|
||||
#include "audio/stream/audiostream.h"
|
||||
#include "audio/audioplatform.h"
|
||||
|
||||
#ifndef audioPlatformInit
|
||||
#error "audioPlatformInit is not defined"
|
||||
#endif
|
||||
|
||||
#ifndef audioPlatformUpdate
|
||||
#error "audioPlatformUpdate is not defined"
|
||||
#endif
|
||||
|
||||
#ifndef audioPlatformDispose
|
||||
#error "audioPlatformDispose is not defined"
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
audiostream_t streams[AUDIO_STREAMS_MAX];
|
||||
} audio_t;
|
||||
|
||||
extern audio_t AUDIO;
|
||||
|
||||
/**
|
||||
* Initializes the audio subsystem.
|
||||
*
|
||||
* @return Error indicating success or failure of the operation.
|
||||
*/
|
||||
errorret_t audioInit();
|
||||
|
||||
/**
|
||||
* Aquires an available audio stream for playing the given asset. Can return
|
||||
* NULL if there is no available stream slot.
|
||||
*
|
||||
* The returned stream is not yet configured to play `asset` - call
|
||||
* audioStreamInit(stream, asset) next.
|
||||
*
|
||||
* @param asset The asset the caller intends to play - validated eagerly so
|
||||
* an unsupported asset type is caught here rather than only
|
||||
* once audioStreamInit() is called.
|
||||
* @return Pointer to an available audio stream, or NULL if none are free.
|
||||
*/
|
||||
audiostream_t * audioAquireStream(assetentry_t *asset);
|
||||
|
||||
/**
|
||||
* Updates the audio subsystem, updating every active stream. Should be
|
||||
* called once per frame, before rendering - keeps stream buffering/decode
|
||||
* work off the render thread's critical path (see duskmad's MP3 decode
|
||||
* ring for why this matters).
|
||||
*
|
||||
* @return Error indicating success or failure of the operation.
|
||||
*/
|
||||
errorret_t audioUpdateEarly();
|
||||
|
||||
/**
|
||||
* Updates the audio subsystem's end-of-frame work - currently just starting
|
||||
* whatever the audio mixer queued this frame (see
|
||||
* audioMixerUpdateLate()'s own comment). Should be called once per frame,
|
||||
* after rendering.
|
||||
*
|
||||
* @return Error indicating success or failure of the operation.
|
||||
*/
|
||||
errorret_t audioUpdateLate();
|
||||
|
||||
/**
|
||||
* Disposes the audio subsystem, stopping and disposing every active stream.
|
||||
*
|
||||
* @return Error indicating success or failure of the operation.
|
||||
*/
|
||||
errorret_t audioDispose();
|
||||
@@ -0,0 +1,11 @@
|
||||
# Copyright (c) 2026 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
audiomixer.c
|
||||
audiomixerchannel.c
|
||||
)
|
||||
@@ -0,0 +1,199 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "audiomixer.h"
|
||||
#include "audio/stream/audiostream.h"
|
||||
#include "util/memory.h"
|
||||
#include "util/string.h"
|
||||
#include "assert/assert.h"
|
||||
|
||||
audiomixer_t AUDIO_MIXER;
|
||||
|
||||
errorret_t audioMixerInit() {
|
||||
memoryZero(&AUDIO_MIXER, sizeof(audiomixer_t));
|
||||
|
||||
audiomixerchannel_t channel = 0;
|
||||
while(channel < AUDIO_MIXER_CHANNEL_COUNT) {
|
||||
AUDIO_MIXER.channels[channel].fade = 1.0f;
|
||||
// -1 means "no fade in progress" - see its own comment; zero-init
|
||||
// would otherwise look like an active fade at time 0.
|
||||
AUDIO_MIXER.channels[channel].fadeTime = -1.0f;
|
||||
channel++;
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioMixerUpdateEarly() {
|
||||
audiomixerchannel_t channel = 0;
|
||||
while(channel < AUDIO_MIXER_CHANNEL_COUNT) {
|
||||
// One channel's error (e.g. a failed asset load) must not stop every
|
||||
// other channel from being updated this frame - caught and logged
|
||||
// rather than propagated, same as audioStream*IsFinished()'s own
|
||||
// per-stream error handling.
|
||||
errorret_t ret = audioMixerChannelUpdateEarly(
|
||||
channel, &AUDIO_MIXER.channels[channel]
|
||||
);
|
||||
if(errorIsNotOk(ret)) errorCatch(errorPrint(ret));
|
||||
channel++;
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioMixerUpdateLate() {
|
||||
audiomixerchannel_t channel = 0;
|
||||
while(channel < AUDIO_MIXER_CHANNEL_COUNT) {
|
||||
errorret_t ret =
|
||||
audioMixerChannelUpdateLate(&AUDIO_MIXER.channels[channel]);
|
||||
if(errorIsNotOk(ret)) errorCatch(errorPrint(ret));
|
||||
channel++;
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
void audioMixerPlay(
|
||||
const char_t *file,
|
||||
const audiomixerchannel_t channel,
|
||||
const float_t volume,
|
||||
const float_t pan
|
||||
) {
|
||||
audioMixerQueuePlay(file, channel, volume, pan, false, 0, -1.0f, 0.0f);
|
||||
}
|
||||
|
||||
void audioMixerPlayLooped(
|
||||
const char_t *file,
|
||||
const audiomixerchannel_t channel,
|
||||
const float_t volume,
|
||||
const float_t pan,
|
||||
const uint8_t loopCount,
|
||||
const float_t loopStart,
|
||||
const float_t loopTo
|
||||
) {
|
||||
audioMixerQueuePlay(
|
||||
file, channel, volume, pan, true, loopCount, loopStart, loopTo
|
||||
);
|
||||
}
|
||||
|
||||
void audioMixerQueuePlay(
|
||||
const char_t *file,
|
||||
const audiomixerchannel_t channel,
|
||||
const float_t volume,
|
||||
const float_t pan,
|
||||
const bool_t looping,
|
||||
const uint8_t loopCount,
|
||||
const float_t loopStart,
|
||||
const float_t loopTo
|
||||
) {
|
||||
assertStrLenMin(file, 1, "File is required, to stop use audioMixerStop");
|
||||
assertTrue(channel < AUDIO_MIXER_CHANNEL_COUNT, "Channel is out of range");
|
||||
assertTrue(volume > 0.0f && volume <= 1.0f, "Volume is out of range");
|
||||
assertTrue(
|
||||
pan >= AUDIO_STREAM_LEFT && pan <= AUDIO_STREAM_RIGHT,
|
||||
"Pan is out of range"
|
||||
);
|
||||
assertTrue(
|
||||
!looping || loopStart < 0.0f || loopTo < loopStart,
|
||||
"Loop points incorrect"
|
||||
);
|
||||
|
||||
audiomixercommand_t *command = &AUDIO_MIXER.channels[channel].pending;
|
||||
|
||||
command->command = AUDIO_MIXER_COMMAND_PLAY;
|
||||
stringCopy(command->file, file, AUDIO_PATH_MAX);
|
||||
command->volume = volume;
|
||||
command->pan = pan;
|
||||
command->looping = looping;
|
||||
command->loopCount = loopCount;
|
||||
command->loopStart = loopStart;
|
||||
command->loopTo = loopTo;
|
||||
}
|
||||
|
||||
void audioMixerStop(const audiomixerchannel_t channel) {
|
||||
assertTrue(channel < AUDIO_MIXER_CHANNEL_COUNT, "Channel is out of range");
|
||||
|
||||
AUDIO_MIXER.channels[channel].pending.command = AUDIO_MIXER_COMMAND_STOP;
|
||||
}
|
||||
|
||||
void audioMixerPause(const audiomixerchannel_t channel) {
|
||||
assertTrue(channel < AUDIO_MIXER_CHANNEL_COUNT, "Channel is out of range");
|
||||
|
||||
audiostream_t *stream = AUDIO_MIXER.channels[channel].stream;
|
||||
if(stream != NULL) audioStreamPause(stream);
|
||||
}
|
||||
|
||||
void audioMixerResume(const audiomixerchannel_t channel) {
|
||||
assertTrue(channel < AUDIO_MIXER_CHANNEL_COUNT, "Channel is out of range");
|
||||
|
||||
audiostream_t *stream = AUDIO_MIXER.channels[channel].stream;
|
||||
if(stream != NULL) audioStreamPlay(stream);
|
||||
}
|
||||
|
||||
void audioMixerSetPan(const audiomixerchannel_t channel, const float_t pan) {
|
||||
assertTrue(channel < AUDIO_MIXER_CHANNEL_COUNT, "Channel is out of range");
|
||||
assertTrue(
|
||||
pan >= AUDIO_STREAM_LEFT && pan <= AUDIO_STREAM_RIGHT,
|
||||
"Pan is out of range"
|
||||
);
|
||||
|
||||
audiostream_t *stream = AUDIO_MIXER.channels[channel].stream;
|
||||
if(stream != NULL) audioStreamSetDirectionality(stream, pan);
|
||||
}
|
||||
|
||||
void audioMixerSetLoop(
|
||||
const audiomixerchannel_t channel,
|
||||
const bool_t looping,
|
||||
const uint8_t loopCount,
|
||||
const float_t loopStart,
|
||||
const float_t loopTo
|
||||
) {
|
||||
assertTrue(channel < AUDIO_MIXER_CHANNEL_COUNT, "Channel is out of range");
|
||||
assertTrue(
|
||||
!looping || loopStart < 0.0f || loopTo < loopStart,
|
||||
"Loop points incorrect"
|
||||
);
|
||||
|
||||
audiostream_t *stream = AUDIO_MIXER.channels[channel].stream;
|
||||
if(stream == NULL) return;
|
||||
|
||||
audioStreamSetLooping(stream, looping);
|
||||
if(looping) {
|
||||
audioStreamSetLoopPoints(stream, loopStart, loopTo);
|
||||
audioStreamSetLoopLimit(stream, loopCount);
|
||||
}
|
||||
}
|
||||
|
||||
void audioMixerFadeTo(
|
||||
const audiomixerchannel_t channel,
|
||||
const float_t from,
|
||||
const float_t to,
|
||||
const float_t duration,
|
||||
const easingtype_t easing
|
||||
) {
|
||||
assertTrue(channel < AUDIO_MIXER_CHANNEL_COUNT, "Channel is out of range");
|
||||
|
||||
audioMixerChannelFadeTo(
|
||||
&AUDIO_MIXER.channels[channel], from, to, duration, easing
|
||||
);
|
||||
}
|
||||
|
||||
bool_t audioMixerIsFading(const audiomixerchannel_t channel) {
|
||||
assertTrue(channel < AUDIO_MIXER_CHANNEL_COUNT, "Channel is out of range");
|
||||
|
||||
return audioMixerChannelIsFading(&AUDIO_MIXER.channels[channel]);
|
||||
}
|
||||
|
||||
errorret_t audioMixerDispose() {
|
||||
audiomixerchannel_t channel = 0;
|
||||
while(channel < AUDIO_MIXER_CHANNEL_COUNT) {
|
||||
errorChain(audioMixerChannelStopStream(&AUDIO_MIXER.channels[channel]));
|
||||
channel++;
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,204 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/mixer/audiomixerchannel.h"
|
||||
|
||||
typedef struct {
|
||||
audiomixerchannelstate_t channels[AUDIO_MIXER_CHANNEL_COUNT];
|
||||
} audiomixer_t;
|
||||
|
||||
extern audiomixer_t AUDIO_MIXER;
|
||||
|
||||
/**
|
||||
* Initializes the audio mixer.
|
||||
*/
|
||||
errorret_t audioMixerInit();
|
||||
|
||||
/**
|
||||
* Updates the audio mixer, called before rendering (the start of the
|
||||
* frame) - see audioMixerChannelUpdateEarly()'s own comment, run for every
|
||||
* channel.
|
||||
*/
|
||||
errorret_t audioMixerUpdateEarly();
|
||||
|
||||
/**
|
||||
* Updates the audio mixer, called at the end of each frame - see
|
||||
* audioMixerChannelUpdateLate()'s own comment, run for every channel.
|
||||
*/
|
||||
errorret_t audioMixerUpdateLate();
|
||||
|
||||
/**
|
||||
* Same as audioMixerPlayLooped() but with no looping.
|
||||
*
|
||||
* @param file File to be played.
|
||||
* @param channel Channel you want to play this sound on.
|
||||
* @param volume Volume of the sound, from 0.0 (silent) to 1.0 (loudest).
|
||||
* @param pan Stereo panning of the sound, from AUDIO_STREAM_LEFT to
|
||||
* AUDIO_STREAM_RIGHT.
|
||||
*/
|
||||
void audioMixerPlay(
|
||||
const char_t *file,
|
||||
const audiomixerchannel_t channel,
|
||||
const float_t volume,
|
||||
const float_t pan
|
||||
);
|
||||
|
||||
/**
|
||||
* Queues a sound to be played on the next audio mixer update, which occurs at
|
||||
* the end of each frame.
|
||||
*
|
||||
* Mixer channels can only hold one voice (audio stream) at a time. If you try
|
||||
* to queue multiple sounds on the same channel only the last one will be played
|
||||
* and will stop any actively playing on that channel currently.
|
||||
*
|
||||
* Volume is also mixed based on the channel, so supplying volume 1.0 is then
|
||||
* multiplied by the channel's volume, e.g. 0.5*1.0 = 0.5.
|
||||
*
|
||||
* @param file File to be played.
|
||||
* @param channel Channel you want to play this sound on.
|
||||
* @param volume Volume of the sound, from 0.0 (silent) to 1.0 (loudest).
|
||||
* @param pan Stereo panning of the sound, from AUDIO_STREAM_LEFT to
|
||||
* AUDIO_STREAM_RIGHT.
|
||||
* @param loopCount How many times to loop the sound, 0 for infinite looping.
|
||||
* @param loopStart Where the loop segment ends, in seconds, or -1 to loop
|
||||
* the whole stream (the default).
|
||||
* @param loopTo Where the loop segment starts, in seconds.
|
||||
*/
|
||||
void audioMixerPlayLooped(
|
||||
const char_t *file,
|
||||
const audiomixerchannel_t channel,
|
||||
const float_t volume,
|
||||
const float_t pan,
|
||||
const uint8_t loopCount,
|
||||
const float_t loopStart,
|
||||
const float_t loopTo
|
||||
);
|
||||
|
||||
/**
|
||||
* Shared implementation behind audioMixerPlay()/audioMixerPlayLooped() -
|
||||
* queues an AUDIO_MIXER_COMMAND_PLAY for the given channel, to be loaded at
|
||||
* the end of this frame and started at the start of the next (see
|
||||
* audioMixerUpdateLate()/audioMixerUpdateEarly()).
|
||||
*
|
||||
* @param file File to be played.
|
||||
* @param channel Channel you want to play this sound on.
|
||||
* @param volume Volume of the sound, from 0.0 (silent) to 1.0 (loudest).
|
||||
* @param pan Stereo panning of the sound, from AUDIO_STREAM_LEFT to
|
||||
* AUDIO_STREAM_RIGHT.
|
||||
* @param looping Whether the stream should loop once it finishes.
|
||||
* @param loopCount How many times to loop the sound, 0 for infinite looping.
|
||||
* Ignored unless looping is true.
|
||||
* @param loopStart Where the loop segment ends, in seconds, or -1 to loop
|
||||
* the whole stream. Ignored unless looping is true.
|
||||
* @param loopTo Where the loop segment starts, in seconds. Ignored unless
|
||||
* looping is true.
|
||||
*/
|
||||
void audioMixerQueuePlay(
|
||||
const char_t *file,
|
||||
const audiomixerchannel_t channel,
|
||||
const float_t volume,
|
||||
const float_t pan,
|
||||
const bool_t looping,
|
||||
const uint8_t loopCount,
|
||||
const float_t loopStart,
|
||||
const float_t loopTo
|
||||
);
|
||||
|
||||
/**
|
||||
* Stops playing sound on the given channel.
|
||||
*
|
||||
* @param channel Channel to stop.
|
||||
*/
|
||||
void audioMixerStop(const audiomixerchannel_t channel);
|
||||
|
||||
/**
|
||||
* Pauses the given channel's currently playing stream, if any - a safe
|
||||
* no-op if the channel isn't playing anything. Playback position is
|
||||
* retained, so audioMixerResume() continues from the same point.
|
||||
*
|
||||
* @param channel Channel to pause.
|
||||
*/
|
||||
void audioMixerPause(const audiomixerchannel_t channel);
|
||||
|
||||
/**
|
||||
* Resumes the given channel's currently paused stream, if any - a safe
|
||||
* no-op if the channel isn't playing anything.
|
||||
*
|
||||
* @param channel Channel to resume.
|
||||
*/
|
||||
void audioMixerResume(const audiomixerchannel_t channel);
|
||||
|
||||
/**
|
||||
* Sets the stereo panning of the given channel's currently playing stream,
|
||||
* if any - a safe no-op if the channel isn't playing anything. Only
|
||||
* affects what's playing right now; a later audioMixerPlay()/
|
||||
* audioMixerPlayLooped() call on this channel uses its own `pan` argument
|
||||
* instead.
|
||||
*
|
||||
* @param channel Channel to update.
|
||||
* @param pan Stereo panning, from AUDIO_STREAM_LEFT to AUDIO_STREAM_RIGHT.
|
||||
*/
|
||||
void audioMixerSetPan(const audiomixerchannel_t channel, const float_t pan);
|
||||
|
||||
/**
|
||||
* Sets the looping behaviour of the given channel's currently playing
|
||||
* stream, if any - a safe no-op if the channel isn't playing anything.
|
||||
* Only affects what's playing right now; a later audioMixerPlay()/
|
||||
* audioMixerPlayLooped() call on this channel uses its own loop arguments
|
||||
* instead.
|
||||
*
|
||||
* @param channel Channel to update.
|
||||
* @param looping Whether the stream should loop.
|
||||
* @param loopCount How many times to loop, 0 for infinite. Ignored unless
|
||||
* looping is true.
|
||||
* @param loopStart Where the loop segment ends, in seconds, or -1 to loop
|
||||
* the whole stream. Ignored unless looping is true.
|
||||
* @param loopTo Where the loop segment starts, in seconds. Ignored unless
|
||||
* looping is true.
|
||||
*/
|
||||
void audioMixerSetLoop(
|
||||
const audiomixerchannel_t channel,
|
||||
const bool_t looping,
|
||||
const uint8_t loopCount,
|
||||
const float_t loopStart,
|
||||
const float_t loopTo
|
||||
);
|
||||
|
||||
/**
|
||||
* Starts fading the given channel from `from` to `to` over `duration`
|
||||
* seconds, eased by `easing` - see audioMixerChannelFadeTo()'s own
|
||||
* comment. Continues running (advanced every audioMixerUpdateEarly()) even
|
||||
* if the channel isn't currently playing anything.
|
||||
*
|
||||
* @param channel Channel to fade.
|
||||
* @param from Starting fade value, from 0.0 (silent) to 1.0 (loudest).
|
||||
* @param to Ending fade value, from 0.0 (silent) to 1.0 (loudest).
|
||||
* @param duration How long the fade takes, in seconds.
|
||||
* @param easing Easing curve to apply to the fade's progress.
|
||||
*/
|
||||
void audioMixerFadeTo(
|
||||
const audiomixerchannel_t channel,
|
||||
const float_t from,
|
||||
const float_t to,
|
||||
const float_t duration,
|
||||
const easingtype_t easing
|
||||
);
|
||||
|
||||
/**
|
||||
* Whether the given channel currently has a fade in progress (started via
|
||||
* audioMixerFadeTo() and not yet finished).
|
||||
*
|
||||
* @param channel Channel to check.
|
||||
* @return true if a fade is still in progress.
|
||||
*/
|
||||
bool_t audioMixerIsFading(const audiomixerchannel_t channel);
|
||||
|
||||
/**
|
||||
* Disposes the audio mixer.
|
||||
*/
|
||||
errorret_t audioMixerDispose();
|
||||
@@ -0,0 +1,223 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "audiomixerchannel.h"
|
||||
#include "asset/asset.h"
|
||||
#include "audio/audio.h"
|
||||
#include "audio/stream/audiostream.h"
|
||||
#include "audio/stream/audiostreamtype.h"
|
||||
#include "save/save.h"
|
||||
#include "time/time.h"
|
||||
#include "util/math.h"
|
||||
#include "assert/assert.h"
|
||||
|
||||
errorret_t audioMixerChannelStopStream(audiomixerchannelstate_t *state) {
|
||||
assertNotNull(state, "State cannot be NULL.");
|
||||
|
||||
if(state->stream == NULL) errorOk();
|
||||
|
||||
errorChain(audioStreamDispose(state->stream));
|
||||
state->stream = NULL;
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
void audioMixerChannelFadeTo(
|
||||
audiomixerchannelstate_t *state,
|
||||
const float_t from,
|
||||
const float_t to,
|
||||
const float_t duration,
|
||||
const easingtype_t easing
|
||||
) {
|
||||
assertNotNull(state, "State cannot be NULL.");
|
||||
|
||||
state->fade = from;
|
||||
state->fadeFrom = from;
|
||||
state->fadeTo = to;
|
||||
state->fadeDuration = duration;
|
||||
state->fadeEasing = easing;
|
||||
// A non-positive duration finishes instantly - marked inactive right
|
||||
// away (fadeTime < 0) rather than left at 0 to progress next frame,
|
||||
// since there's nothing left to progress.
|
||||
if(duration <= 0.0f) {
|
||||
state->fade = to;
|
||||
state->fadeTime = -1.0f;
|
||||
} else {
|
||||
state->fadeTime = 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
bool_t audioMixerChannelIsFading(const audiomixerchannelstate_t *state) {
|
||||
assertNotNull(state, "State cannot be NULL.");
|
||||
|
||||
return state->fadeTime >= 0.0f;
|
||||
}
|
||||
|
||||
void audioMixerChannelApplyVolume(
|
||||
const audiomixerchannel_t channel,
|
||||
audiomixerchannelstate_t *state
|
||||
) {
|
||||
assertNotNull(state, "State cannot be NULL.");
|
||||
|
||||
if(state->stream == NULL) return;
|
||||
|
||||
// Advances any in-progress fade before it's read below - see
|
||||
// audioMixerChannelFadeTo()'s own comment on fadeTime's meaning.
|
||||
if(state->fadeTime >= 0.0f) {
|
||||
state->fadeTime += TIME.delta;
|
||||
const float_t t = mathClamp(
|
||||
state->fadeTime / state->fadeDuration, 0.0f, 1.0f
|
||||
);
|
||||
state->fade = state->fadeFrom +
|
||||
(state->fadeTo - state->fadeFrom) * easingApply(state->fadeEasing, t);
|
||||
if(state->fadeTime >= state->fadeDuration) {
|
||||
state->fade = state->fadeTo;
|
||||
state->fadeTime = -1.0f;
|
||||
}
|
||||
}
|
||||
|
||||
// state->fade and both SAVE.settings volumes have no setter - written
|
||||
// directly by callers - so this is the only place any of them ever gets
|
||||
// validated, rather than at the point they're set.
|
||||
assertTrue(
|
||||
state->fade >= 0.0f && state->fade <= 1.0f,
|
||||
"Channel fade is out of range."
|
||||
);
|
||||
assertTrue(
|
||||
SAVE.settings.audioChannelVolume[channel] >= 0.0f &&
|
||||
SAVE.settings.audioChannelVolume[channel] <= 1.0f,
|
||||
"Channel volume is out of range."
|
||||
);
|
||||
assertTrue(
|
||||
SAVE.settings.audioMasterVolume >= 0.0f &&
|
||||
SAVE.settings.audioMasterVolume <= 1.0f,
|
||||
"Master volume is out of range."
|
||||
);
|
||||
|
||||
// Final computed volume.
|
||||
float_t volume = (
|
||||
state->baseVolume *
|
||||
state->fade *
|
||||
SAVE.settings.audioChannelVolume[channel] *
|
||||
SAVE.settings.audioMasterVolume
|
||||
);
|
||||
audioStreamSetVolume(state->stream, volume);
|
||||
}
|
||||
|
||||
errorret_t audioMixerChannelUpdateEarly(
|
||||
const audiomixerchannel_t channel,
|
||||
audiomixerchannelstate_t *state
|
||||
) {
|
||||
assertNotNull(state, "State cannot be NULL.");
|
||||
|
||||
audiomixercommand_t *command = &state->pending;
|
||||
|
||||
if(command->command == AUDIO_MIXER_COMMAND_STOP) {
|
||||
errorChain(audioMixerChannelStopStream(state));
|
||||
command->command = AUDIO_MIXER_COMMAND_NONE;
|
||||
audioMixerChannelApplyVolume(channel, state);
|
||||
errorOk();
|
||||
}
|
||||
|
||||
if(
|
||||
command->command != AUDIO_MIXER_COMMAND_PLAY ||
|
||||
command->loadingAsset == NULL
|
||||
) {
|
||||
// A PLAY command with no loadingAsset yet (command->loadingAsset ==
|
||||
// NULL) was queued too late for the audioMixerChannelUpdateLate() that
|
||||
// just ran immediately before this call to have locked it - the only
|
||||
// way that happens is a command queued outside the normal per-frame
|
||||
// cycle, e.g. during engine startup before any
|
||||
// audioMixerChannelUpdateLate() has run yet. Left alone (still
|
||||
// AUDIO_MIXER_COMMAND_PLAY) rather than treated as an error: the very
|
||||
// next audioMixerChannelUpdateLate() will lock it, and the frame after
|
||||
// that will reach here and apply it normally.
|
||||
audioMixerChannelApplyVolume(channel, state);
|
||||
errorOk();
|
||||
}
|
||||
|
||||
// Blocks here if audioMixerChannelUpdateLate()'s load (kicked off at the
|
||||
// end of the previous frame) hasn't finished yet - see this function's
|
||||
// own doc comment on why that's accepted for now.
|
||||
errorret_t loadRet = assetRequireLoaded(command->loadingAsset);
|
||||
if(errorIsNotOk(loadRet)) {
|
||||
assetUnlockEntry(command->loadingAsset);
|
||||
command->loadingAsset = NULL;
|
||||
command->command = AUDIO_MIXER_COMMAND_NONE;
|
||||
errorChain(loadRet);
|
||||
}
|
||||
|
||||
errorChain(audioMixerChannelStopStream(state));
|
||||
|
||||
audiostream_t *stream = audioAquireStream(command->loadingAsset);
|
||||
assertNotNull(stream, "No free audio stream slots available.");
|
||||
|
||||
errorret_t initRet = audioStreamInit(stream, command->loadingAsset);
|
||||
// The stream holds its own lock on the asset once initialized (or, on
|
||||
// failure, audioStreamInit() has already released it itself) - either
|
||||
// way this call's own lock is no longer needed.
|
||||
assetUnlockEntry(command->loadingAsset);
|
||||
command->loadingAsset = NULL;
|
||||
command->command = AUDIO_MIXER_COMMAND_NONE;
|
||||
errorChain(initRet);
|
||||
|
||||
// Forwards to this channel's own onLoop/onEnd (persistent across every
|
||||
// play on this channel) rather than this one stream instance's own -
|
||||
// see audiomixerchannelstate_t.onLoop's own comment.
|
||||
stream->user = state;
|
||||
stream->onLoop = audioMixerChannelOnStreamLoop;
|
||||
stream->onEnd = audioMixerChannelOnStreamEnd;
|
||||
|
||||
audioStreamSetDirectionality(stream, command->pan);
|
||||
if(command->looping) {
|
||||
audioStreamSetLooping(stream, true);
|
||||
audioStreamSetLoopPoints(stream, command->loopStart, command->loopTo);
|
||||
audioStreamSetLoopLimit(stream, command->loopCount);
|
||||
}
|
||||
audioStreamPlay(stream);
|
||||
|
||||
state->stream = stream;
|
||||
state->baseVolume = command->volume;
|
||||
|
||||
audioMixerChannelApplyVolume(channel, state);
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioMixerChannelUpdateLate(audiomixerchannelstate_t *state) {
|
||||
assertNotNull(state, "State cannot be NULL.");
|
||||
|
||||
audiomixercommand_t *command = &state->pending;
|
||||
|
||||
if(command->command != AUDIO_MIXER_COMMAND_PLAY) errorOk();
|
||||
|
||||
assetloadertype_t assetType = audioStreamAssetTypeForPath(command->file);
|
||||
assertTrue(
|
||||
assetType != ASSET_LOADER_TYPE_NULL, "Unsupported audio file extension."
|
||||
);
|
||||
|
||||
// Begins loading now - kicked off at the end of this frame so it has
|
||||
// until the start of the next (audioMixerChannelUpdateEarly()) to finish
|
||||
// before that has to block on it.
|
||||
command->loadingAsset = assetLock(command->file, assetType, NULL);
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
void audioMixerChannelOnStreamLoop(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
audiomixerchannelstate_t *state = (audiomixerchannelstate_t *) stream->user;
|
||||
if(state->onLoop != NULL) state->onLoop(state);
|
||||
}
|
||||
|
||||
void audioMixerChannelOnStreamEnd(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
audiomixerchannelstate_t *state = (audiomixerchannelstate_t *) stream->user;
|
||||
if(state->onEnd != NULL) state->onEnd(state);
|
||||
}
|
||||
@@ -0,0 +1,242 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "dusk.h"
|
||||
#include "error/error.h"
|
||||
#include "animation/easing.h"
|
||||
|
||||
// Forward-declared rather than including asset/asset.h - this header only
|
||||
// ever needs a pointer to it, and pulling in the full asset module here
|
||||
// creates a real include cycle for anything that reaches this header via
|
||||
// asset/loader/cutscene/assetcutsceneloader.h (asset.h -> ... ->
|
||||
// assetloader.h -> assetcutsceneloader.h -> cutscene.h -> cutsceneitem.h
|
||||
// -> the audio cutscene items -> this header -> asset/asset.h again,
|
||||
// mid-parse). audiomixerchannel.c itself still includes the full header.
|
||||
typedef struct assetentry_s assetentry_t;
|
||||
|
||||
typedef struct audiostream_s audiostream_t;
|
||||
|
||||
#define AUDIO_PATH_MAX 256
|
||||
|
||||
typedef enum {
|
||||
AUDIO_MIXER_CHANNEL_BGM_0,
|
||||
AUDIO_MIXER_CHANNEL_VOICE_0,
|
||||
AUDIO_MIXER_CHANNEL_VOICE_1,
|
||||
AUDIO_MIXER_CHANNEL_SFX_0,
|
||||
AUDIO_MIXER_CHANNEL_SFX_1,
|
||||
AUDIO_MIXER_CHANNEL_SFX_2,
|
||||
AUDIO_MIXER_CHANNEL_SFX_3,
|
||||
AUDIO_MIXER_CHANNEL_COUNT
|
||||
} audiomixerchannel_t;
|
||||
|
||||
typedef enum {
|
||||
AUDIO_MIXER_COMMAND_NONE,
|
||||
AUDIO_MIXER_COMMAND_PLAY,
|
||||
AUDIO_MIXER_COMMAND_STOP
|
||||
} audiomixercommandtype_t;
|
||||
|
||||
typedef struct {
|
||||
// What audioMixerChannelUpdateEarly() should do to this channel at the
|
||||
// start of the next frame - AUDIO_MIXER_COMMAND_NONE if nothing's
|
||||
// queued. Set by audioMixerPlay()/audioMixerPlayLooped()/
|
||||
// audioMixerStop(); queuing a new command on a channel replaces, rather
|
||||
// than stacks on top of, whatever was already queued for it this frame -
|
||||
// only the most recent survives.
|
||||
audiomixercommandtype_t command;
|
||||
|
||||
// AUDIO_MIXER_COMMAND_PLAY only, below.
|
||||
char_t file[AUDIO_PATH_MAX];
|
||||
float_t volume;
|
||||
float_t pan;
|
||||
bool_t looping;
|
||||
uint8_t loopCount;
|
||||
float_t loopStart;
|
||||
float_t loopTo;
|
||||
|
||||
// Set by audioMixerChannelUpdateLate() (the end of the frame this PLAY
|
||||
// command was queued on), once it locks the requested file and kicks off
|
||||
// its load. audioMixerChannelUpdateEarly() (the start of the next frame)
|
||||
// blocks on this being fully loaded before actually starting playback -
|
||||
// see its own comment. NULL except in that in-between window.
|
||||
assetentry_t *loadingAsset;
|
||||
} audiomixercommand_t;
|
||||
|
||||
typedef struct audiomixerchannelstate_s audiomixerchannelstate_t;
|
||||
|
||||
typedef struct audiomixerchannelstate_s {
|
||||
// Queued action for the next audioMixerChannelUpdateEarly() to apply.
|
||||
audiomixercommand_t pending;
|
||||
|
||||
// This channel's currently playing stream, or NULL if nothing is -
|
||||
// acquired from AUDIO.streams by audioMixerChannelUpdateEarly() when it
|
||||
// applies an AUDIO_MIXER_COMMAND_PLAY, disposed the same way on
|
||||
// AUDIO_MIXER_COMMAND_STOP or before a new AUDIO_MIXER_COMMAND_PLAY
|
||||
// replaces it.
|
||||
audiostream_t *stream;
|
||||
|
||||
// The per-sound volume `stream` was last started with (the `volume`
|
||||
// argument to whichever audioMixerPlay()/audioMixerPlayLooped() call
|
||||
// started it) - combined with this channel's fade, its own volume
|
||||
// (SAVE.settings.audioChannelVolume) and the mixer's master volume
|
||||
// (SAVE.settings.audioMasterVolume), every frame, to get the volume
|
||||
// actually passed to audioStreamSetVolume(). Meaningless while `stream`
|
||||
// is NULL.
|
||||
float_t baseVolume;
|
||||
|
||||
// This channel's own fade multiplier, from 0.0 (fully faded out) to 1.0
|
||||
// (no fade applied, the default) - transient runtime state, unlike the
|
||||
// channel/master volumes below (which are persisted user preferences).
|
||||
// No setter - write it directly; audioMixerChannelApplyVolume() asserts
|
||||
// it's in range the next time it reads it, rather than validating at the
|
||||
// point it's set.
|
||||
float_t fade;
|
||||
|
||||
// Fade transition state, set by audioMixerChannelFadeTo() and advanced
|
||||
// every frame by audioMixerChannelApplyVolume(), before it reads `fade`
|
||||
// to compute the mixed volume. fadeTime < 0 means no fade is in progress
|
||||
// (audioMixerChannelIsFading() is just `fadeTime >= 0`) - audioMixerInit()
|
||||
// explicitly sets this to -1.0f, since zero-initializing it would
|
||||
// otherwise look like an active fade at time 0.
|
||||
float_t fadeFrom;
|
||||
float_t fadeTo;
|
||||
float_t fadeDuration;
|
||||
float_t fadeTime;
|
||||
easingtype_t fadeEasing;
|
||||
|
||||
// Arbitrary caller data, handed back as-is to onLoop/onEnd below - never
|
||||
// read or written by the mixer itself. NULL by default.
|
||||
void *user;
|
||||
|
||||
// Fired (from the main thread - safe to do arbitrary work, same
|
||||
// guarantee as audiostream_t's own onLoop/onEnd) whenever this channel's
|
||||
// currently playing stream loops, or reaches its natural end (including
|
||||
// hitting its loop limit - see audioStreamSetLoopLimit()) and stops.
|
||||
// Wired onto every stream this channel starts via
|
||||
// audioMixerChannelOnStreamLoop()/OnStreamEnd() - not called directly by
|
||||
// anything else. No setter - write these fields directly; NULL (the
|
||||
// default) means not notified. Unlike `stream`/`pending`, these persist
|
||||
// across every play on this channel, not just one.
|
||||
void (*onLoop)(audiomixerchannelstate_t *state);
|
||||
void (*onEnd)(audiomixerchannelstate_t *state);
|
||||
} audiomixerchannelstate_t;
|
||||
|
||||
/**
|
||||
* Stops and disposes the given channel's currently playing stream, if any -
|
||||
* a safe no-op if the channel is already idle. Shared by
|
||||
* audioMixerChannelUpdateEarly() (AUDIO_MIXER_COMMAND_STOP, and replacing a
|
||||
* channel's stream before a new AUDIO_MIXER_COMMAND_PLAY starts) and
|
||||
* audioMixerDispose().
|
||||
*
|
||||
* @param state The channel state to stop.
|
||||
*/
|
||||
errorret_t audioMixerChannelStopStream(audiomixerchannelstate_t *state);
|
||||
|
||||
/**
|
||||
* Computes the given channel's actual playback volume - its currently
|
||||
* playing sound's own volume (baseVolume), this channel's fade, this
|
||||
* channel's own volume (SAVE.settings.audioChannelVolume[channel]) and the
|
||||
* mixer's master volume (SAVE.settings.audioMasterVolume) - and applies it
|
||||
* via audioStreamSetVolume(). Asserts fade and both save-settings volumes
|
||||
* are each within [0.0, 1.0] - the only validation any of them ever gets,
|
||||
* since none of them have a setter. A safe no-op if the channel isn't
|
||||
* playing anything. Called every audioMixerChannelUpdateEarly(), not just
|
||||
* when a PLAY command starts a new stream - see its own comment.
|
||||
*
|
||||
* @param channel Which channel `state` is, to index
|
||||
* SAVE.settings.audioChannelVolume with.
|
||||
* @param state The channel state to update.
|
||||
*/
|
||||
void audioMixerChannelApplyVolume(
|
||||
const audiomixerchannel_t channel,
|
||||
audiomixerchannelstate_t *state
|
||||
);
|
||||
|
||||
/**
|
||||
* Starts fading the given channel's `fade` multiplier from `from` to `to`
|
||||
* over `duration` seconds, eased by `easing` - snaps `fade` to `from`
|
||||
* immediately, then audioMixerChannelApplyVolume() advances it every frame
|
||||
* from here on. A `duration` of 0 or less snaps straight to `to` and marks
|
||||
* the fade as already finished (audioMixerChannelIsFading() returns
|
||||
* false on the very next call).
|
||||
*
|
||||
* @param state The channel state to fade.
|
||||
* @param from Starting fade value, from 0.0 (silent) to 1.0 (loudest).
|
||||
* @param to Ending fade value, from 0.0 (silent) to 1.0 (loudest).
|
||||
* @param duration How long the fade takes, in seconds.
|
||||
* @param easing Easing curve to apply to the fade's progress.
|
||||
*/
|
||||
void audioMixerChannelFadeTo(
|
||||
audiomixerchannelstate_t *state,
|
||||
const float_t from,
|
||||
const float_t to,
|
||||
const float_t duration,
|
||||
const easingtype_t easing
|
||||
);
|
||||
|
||||
/**
|
||||
* Whether the given channel currently has a fade in progress (started via
|
||||
* audioMixerChannelFadeTo() and not yet finished).
|
||||
*
|
||||
* @param state The channel state to check.
|
||||
* @return true if a fade is still in progress.
|
||||
*/
|
||||
bool_t audioMixerChannelIsFading(const audiomixerchannelstate_t *state);
|
||||
|
||||
/**
|
||||
* Updates a single mixer channel, called before rendering (the start of
|
||||
* the frame): applies whatever command (play, stop - including everything
|
||||
* a play carries, pan/looping) audioMixerChannelUpdateLate() queued for
|
||||
* loading at the end of the previous frame. If that load hasn't finished
|
||||
* yet, this blocks (via assetRequireLoaded()) until it has - a deliberate
|
||||
* stall for now rather than skipping a frame, since there's currently no
|
||||
* way to only partially apply a channel's command. Also recomputes and
|
||||
* reapplies this channel's mixed volume (see
|
||||
* audioMixerChannelApplyVolume()) every time, regardless of whether a
|
||||
* command was queued this frame, so a live change to this channel's fade,
|
||||
* its own volume, or the master volume takes effect on whatever's already
|
||||
* playing too.
|
||||
*
|
||||
* @param channel Which channel `state` is - see
|
||||
* audioMixerChannelApplyVolume()'s own comment.
|
||||
* @param state The channel state to update.
|
||||
*/
|
||||
errorret_t audioMixerChannelUpdateEarly(
|
||||
const audiomixerchannel_t channel,
|
||||
audiomixerchannelstate_t *state
|
||||
);
|
||||
|
||||
/**
|
||||
* Updates a single mixer channel, called at the end of each frame, once
|
||||
* every other system has had a chance to queue a command via
|
||||
* audioMixerPlay()/audioMixerPlayLooped()/audioMixerStop(). For a queued
|
||||
* AUDIO_MIXER_COMMAND_PLAY, locks its file and begins loading it (see
|
||||
* assetLock()) - giving it from now until the next
|
||||
* audioMixerChannelUpdateEarly() to finish before that has to block on it.
|
||||
* Actually starting/stopping playback happens there, not here.
|
||||
*
|
||||
* @param state The channel state to update.
|
||||
*/
|
||||
errorret_t audioMixerChannelUpdateLate(audiomixerchannelstate_t *state);
|
||||
|
||||
/**
|
||||
* Trampoline wired onto every stream a channel starts (as that stream's
|
||||
* onLoop) - forwards to the channel's own onLoop (see
|
||||
* audiomixerchannelstate_t.onLoop's own comment) via stream->user, which
|
||||
* audioMixerChannelUpdateEarly() points at the channel's own state.
|
||||
*
|
||||
* @param stream The stream that looped.
|
||||
*/
|
||||
void audioMixerChannelOnStreamLoop(audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Same as audioMixerChannelOnStreamLoop() but wired onto onEnd, forwarding
|
||||
* to the channel's own onEnd.
|
||||
*
|
||||
* @param stream The stream that ended.
|
||||
*/
|
||||
void audioMixerChannelOnStreamEnd(audiostream_t *stream);
|
||||
@@ -0,0 +1,13 @@
|
||||
# Copyright (c) 2026 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
# Sources
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
audiostream.c
|
||||
audiostreampcm.c
|
||||
audiostreammp3.c
|
||||
audiostreamtype.c
|
||||
)
|
||||
@@ -0,0 +1,312 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "audiostream.h"
|
||||
#include "assert/assert.h"
|
||||
#include "util/math.h"
|
||||
|
||||
errorret_t audioStreamInit(audiostream_t *stream, assetentry_t *asset) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertNotNull(asset, "Asset cannot be NULL.");
|
||||
assertTrue(
|
||||
asset->state == ASSET_ENTRY_STATE_LOADED,
|
||||
"Asset must be loaded before it can back an audio stream."
|
||||
);
|
||||
// A caller passing an asset type that can't back an audio stream is a
|
||||
// programmer error, not something that can happen from untrusted data, so
|
||||
// this is an assert rather than an errorThrow (see
|
||||
// feedback_assert_vs_error convention).
|
||||
assertTrue(
|
||||
audioStreamTypeForAssetType(asset->type) != AUDIO_STREAM_TYPE_NULL,
|
||||
"Unsupported asset type for an audio stream."
|
||||
);
|
||||
|
||||
stream->state = 0;
|
||||
stream->volume = 1.0f;
|
||||
stream->directionality = AUDIO_STREAM_CENTER;
|
||||
stream->loopStart = -1;
|
||||
stream->loopTo = 0;
|
||||
stream->duration = 0;
|
||||
stream->startFrame = 0;
|
||||
stream->seeking = false;
|
||||
stream->user = NULL;
|
||||
stream->onLoop = NULL;
|
||||
stream->onEnd = NULL;
|
||||
stream->loopCount = 0;
|
||||
stream->lastLoopCount = 0;
|
||||
stream->loopLimit = 0;
|
||||
stream->loopRestartCount = 0;
|
||||
|
||||
// Locked for as long as the stream is in use (see audiostream_t.asset's
|
||||
// own comment) - released in audioStreamDispose().
|
||||
stream->asset = asset;
|
||||
assetEntryLock(asset);
|
||||
|
||||
// Type-specific setup (audioStreamPcmInit() / audioStreamMp3Init())
|
||||
// determines stream->type, sets stream->sampleRate/channels, and asks
|
||||
// the platform implementation to set up its state.
|
||||
errorret_t ret = asset->type == ASSET_LOADER_TYPE_MP3
|
||||
? audioStreamMp3Init(stream)
|
||||
: audioStreamPcmInit(stream);
|
||||
if(errorIsNotOk(ret)) {
|
||||
assetEntryUnlock(asset);
|
||||
stream->asset = NULL;
|
||||
errorChain(ret);
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
size_t audioStreamGetTotalFrames(const audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
return stream->type == AUDIO_STREAM_TYPE_MP3
|
||||
? audioStreamMp3GetTotalFrames(stream)
|
||||
: audioStreamPcmGetTotalFrames(stream);
|
||||
}
|
||||
|
||||
errorret_t audioStreamSeek(audiostream_t *stream, const size_t frame) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
errorChain(
|
||||
stream->type == AUDIO_STREAM_TYPE_MP3
|
||||
? audioStreamMp3Seek(stream, frame)
|
||||
: audioStreamPcmSeek(stream, frame)
|
||||
);
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioStreamRead(
|
||||
audiostream_t *stream,
|
||||
int16_t *buffer,
|
||||
const size_t frameCount,
|
||||
size_t *outFramesRead
|
||||
) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
errorChain(
|
||||
stream->type == AUDIO_STREAM_TYPE_MP3
|
||||
? audioStreamMp3Read(stream, buffer, frameCount, outFramesRead)
|
||||
: audioStreamPcmRead(stream, buffer, frameCount, outFramesRead)
|
||||
);
|
||||
errorOk();
|
||||
}
|
||||
|
||||
void audioStreamPlay(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
stream->state |= AUDIO_STREAM_STATE_PLAYING;
|
||||
}
|
||||
|
||||
void audioStreamPause(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
stream->state &= ~AUDIO_STREAM_STATE_PLAYING;
|
||||
}
|
||||
|
||||
void audioStreamSetPosition(audiostream_t *stream, const float_t position) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
// Wrap into [0, duration).
|
||||
float_t t = position;
|
||||
while(t < 0) t += stream->duration;
|
||||
while(t >= stream->duration) t -= stream->duration;
|
||||
|
||||
stream->startFrame = (size_t) (t * stream->sampleRate);
|
||||
stream->seeking = true;
|
||||
|
||||
// Force the next audioStreamUpdate() to re-buffer from startFrame instead
|
||||
// of continuing whatever was already buffered - see the platform Buffer()
|
||||
// implementations for how each one applies startFrame; PSP is the one
|
||||
// exception (see audioStreamSetPosition's own doc comment).
|
||||
stream->state &= ~AUDIO_STREAM_STATE_BUFFERED;
|
||||
}
|
||||
|
||||
void audioStreamSetLoopPoints(
|
||||
audiostream_t *stream,
|
||||
const float_t loopStart,
|
||||
const float_t loopTo
|
||||
) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(
|
||||
loopStart < 0 || loopTo < loopStart,
|
||||
"loopTo must be before loopStart."
|
||||
);
|
||||
|
||||
stream->loopStart = loopStart;
|
||||
stream->loopTo = loopTo;
|
||||
}
|
||||
|
||||
void audioStreamGetPanFactors(
|
||||
const audiostream_t *stream,
|
||||
float_t *outLeft,
|
||||
float_t *outRight
|
||||
) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertNotNull(outLeft, "outLeft cannot be NULL.");
|
||||
assertNotNull(outRight, "outRight cannot be NULL.");
|
||||
|
||||
// directionality is already a pan factor in AUDIO_STREAM_LEFT..RIGHT
|
||||
// (-1.0..1.0) - assertTrue'd here rather than clamped, since a caller
|
||||
// passing something outside that range is a programmer error (see
|
||||
// audioStreamSetDirectionality()'s own assert).
|
||||
const float_t pan = stream->directionality;
|
||||
|
||||
*outLeft = pan > 0 ? (1.0f - pan) : 1.0f;
|
||||
*outRight = pan < 0 ? (1.0f + pan) : 1.0f;
|
||||
}
|
||||
|
||||
size_t audioStreamComputeEndFrame(
|
||||
const audiostream_t *stream,
|
||||
const size_t startFrame,
|
||||
const size_t totalFrames
|
||||
) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
size_t endFrame = totalFrames;
|
||||
if((stream->state & AUDIO_STREAM_STATE_LOOPING) && stream->loopStart >= 0) {
|
||||
endFrame = mathMin(
|
||||
(size_t) (stream->loopStart * stream->sampleRate), totalFrames
|
||||
);
|
||||
}
|
||||
if(startFrame >= endFrame) endFrame = totalFrames;
|
||||
|
||||
return endFrame;
|
||||
}
|
||||
|
||||
void audioStreamSetVolume(audiostream_t *stream, const float_t volume) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(volume >= 0.0f && volume <= 1.0f, "Volume is out of range.");
|
||||
stream->volume = volume;
|
||||
// TODO: Do I need to update the device output? PSP may require this
|
||||
}
|
||||
|
||||
void audioStreamSetDirectionality(
|
||||
audiostream_t *stream,
|
||||
const float_t directionality
|
||||
) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(
|
||||
directionality >= AUDIO_STREAM_LEFT && directionality <= AUDIO_STREAM_RIGHT,
|
||||
"Directionality is out of range."
|
||||
);
|
||||
stream->directionality = directionality;
|
||||
// TODO: Need to update internal decoder?
|
||||
}
|
||||
|
||||
void audioStreamSetLooping(audiostream_t *stream, const bool_t looping) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
if(looping) {
|
||||
stream->state |= AUDIO_STREAM_STATE_LOOPING;
|
||||
} else {
|
||||
stream->state &= ~AUDIO_STREAM_STATE_LOOPING;
|
||||
}
|
||||
}
|
||||
|
||||
void audioStreamSetLoopLimit(audiostream_t *stream, const uint32_t loopLimit) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
stream->loopLimit = loopLimit;
|
||||
stream->loopRestartCount = 0;
|
||||
}
|
||||
|
||||
errorret_t audioStreamUpdate(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
if(stream->type == AUDIO_STREAM_TYPE_NULL) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
// Some platforms (PSP) loop entirely on their own background thread for
|
||||
// gaplessness and can only safely notify onLoop by incrementing this
|
||||
// counter from there, rather than calling onLoop directly off the main
|
||||
// thread - see loopCount's own comment. Firing it here, unconditionally,
|
||||
// catches up to the latest count in one call even if multiple loops
|
||||
// happened between two Update() calls.
|
||||
if(stream->loopCount != stream->lastLoopCount) {
|
||||
stream->lastLoopCount = stream->loopCount;
|
||||
|
||||
if(stream->onLoop != NULL) {
|
||||
stream->onLoop(stream);
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Once streamed (rather than fully in-memory) sources exist, this is
|
||||
// where new data would be decoded/read in and re-buffered as playback
|
||||
// consumes it.
|
||||
// Checked in this order (finished-check before needs-buffering) so that a
|
||||
// loop restart falls straight through into re-buffering within this same
|
||||
// call, instead of leaving BUFFERED cleared for the caller to notice and
|
||||
// act on next frame - that extra frame of latency was audible as a gap
|
||||
// at every loop boundary.
|
||||
if(
|
||||
(stream->state & AUDIO_STREAM_STATE_PLAYING) &&
|
||||
(stream->state & AUDIO_STREAM_STATE_BUFFERED) &&
|
||||
audioStreamPlatformIsFinished(stream)
|
||||
) {
|
||||
// A limit of 0 means unlimited; otherwise this pass's restart only goes
|
||||
// ahead while fewer than loopLimit restarts have already happened -
|
||||
// once it's reached, fall through to the same stop/onEnd path as a
|
||||
// non-looping stream instead of restarting again.
|
||||
const bool_t loopLimitReached = stream->loopLimit > 0 &&
|
||||
stream->loopRestartCount >= stream->loopLimit;
|
||||
|
||||
if((stream->state & AUDIO_STREAM_STATE_LOOPING) && !loopLimitReached) {
|
||||
stream->state &= ~AUDIO_STREAM_STATE_BUFFERED;
|
||||
stream->loopRestartCount++;
|
||||
|
||||
// Resume from loopTo rather than the very start of the buffer - only
|
||||
// matters for platforms that reach this generic restart path at all
|
||||
// (Linux and Dolphin, both of which re-buffer per pass and report
|
||||
// "finished" at every loop boundary); PSP loops entirely on its own
|
||||
// read-ahead ring instead (see loopRestartCount's own comment).
|
||||
stream->startFrame = (size_t) (stream->loopTo * stream->sampleRate);
|
||||
|
||||
if(stream->onLoop != NULL) {
|
||||
stream->onLoop(stream);
|
||||
}
|
||||
} else {
|
||||
stream->state &=
|
||||
~(AUDIO_STREAM_STATE_PLAYING | AUDIO_STREAM_STATE_BUFFERED);
|
||||
|
||||
if(stream->onEnd != NULL) {
|
||||
stream->onEnd(stream);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(
|
||||
(stream->state & AUDIO_STREAM_STATE_PLAYING) &&
|
||||
!(stream->state & AUDIO_STREAM_STATE_BUFFERED)
|
||||
) {
|
||||
errorChain(audioStreamPlatformBuffer(stream));
|
||||
stream->state |= AUDIO_STREAM_STATE_BUFFERED;
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioStreamDispose(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
|
||||
if(stream->type != AUDIO_STREAM_TYPE_NULL) {
|
||||
errorChain(audioStreamPlatformDispose(stream));
|
||||
}
|
||||
|
||||
if(stream->type == AUDIO_STREAM_TYPE_PCM) {
|
||||
errorChain(audioStreamPcmDispose(stream));
|
||||
} else if(stream->type == AUDIO_STREAM_TYPE_MP3) {
|
||||
errorChain(audioStreamMp3Dispose(stream));
|
||||
}
|
||||
|
||||
if(stream->asset != NULL) {
|
||||
assetEntryUnlock(stream->asset);
|
||||
stream->asset = NULL;
|
||||
}
|
||||
|
||||
stream->type = AUDIO_STREAM_TYPE_NULL;
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,360 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/stream/audiostreamtype.h"
|
||||
#include "audio/stream/audiostreampcm.h"
|
||||
#include "audio/stream/audiostreammp3.h"
|
||||
#include "audio/audiostreamplatform.h"
|
||||
#include "asset/loader/assetentry.h"
|
||||
|
||||
#ifndef audioStreamPlatformInit
|
||||
#error "audioStreamPlatformInit is not defined"
|
||||
#endif
|
||||
|
||||
#ifndef audioStreamPlatformDispose
|
||||
#error "audioStreamPlatformDispose is not defined"
|
||||
#endif
|
||||
|
||||
#ifndef audioStreamPlatformBuffer
|
||||
#error "audioStreamPlatformBuffer is not defined"
|
||||
#endif
|
||||
|
||||
#ifndef audioStreamPlatformIsFinished
|
||||
#error "audioStreamPlatformIsFinished is not defined"
|
||||
#endif
|
||||
|
||||
#define AUDIO_STREAMS_MAX 8
|
||||
#define AUDIO_STREAM_STATE_PLAYING (1 << 0)
|
||||
#define AUDIO_STREAM_STATE_LOOPING (1 << 1)
|
||||
#define AUDIO_STREAM_STATE_BUFFERED (1 << 2)
|
||||
#define AUDIO_STREAM_CENTER 0.0f
|
||||
#define AUDIO_STREAM_LEFT -1.0f
|
||||
#define AUDIO_STREAM_RIGHT 1.0f
|
||||
|
||||
typedef struct audiostream_s audiostream_t;
|
||||
|
||||
typedef struct audiostream_s {
|
||||
// Used for aquiring new data.
|
||||
audistreamtype_t type;
|
||||
|
||||
// What state the stream is in. volatile: PSP's output thread reads
|
||||
// AUDIO_STREAM_STATE_PLAYING directly to honor a pause promptly instead
|
||||
// of only reacting once the main thread's own per-frame gate notices -
|
||||
// see audioStreamPSPThreadFeed()'s own comment.
|
||||
volatile uint8_t state;
|
||||
|
||||
// The asset backing this stream's data (e.g. a WAV file) - determines
|
||||
// `type` (see audioStreamInit()) and is read from on demand by the
|
||||
// type-specific module (e.g. audiostreampcm.h) rather than ever being
|
||||
// fully decoded into memory up front. The stream holds its own lock on
|
||||
// this entry (assetEntryLock()/assetEntryUnlock()) for as long as it's
|
||||
// in use, independent of whatever lock(s) the caller that requested
|
||||
// playback may also be holding.
|
||||
assetentry_t *asset;
|
||||
|
||||
// Loudness, from 0.0 (silent) to 1.0 (loudest).
|
||||
float_t volume;
|
||||
|
||||
// In stereo space, where do we send the audio - from AUDIO_STREAM_LEFT
|
||||
// (-1.0) to AUDIO_STREAM_RIGHT (1.0), AUDIO_STREAM_CENTER (0.0) by
|
||||
// default.
|
||||
// TODO: Can we use a 3D vector + Pro Logic II?
|
||||
float_t directionality;
|
||||
|
||||
// In seconds, where the loop segment ends and playback jumps back to
|
||||
// loopTo - -1 (the default) means "at the end of the stream", i.e. loop
|
||||
// the whole buffer. Set via audioStreamSetLoopPoints().
|
||||
float_t loopStart;
|
||||
|
||||
// In seconds, where a loop jumps back to once it reaches loopStart.
|
||||
// Defaults to 0 (start of stream). Set via audioStreamSetLoopPoints().
|
||||
float_t loopTo;
|
||||
|
||||
// Cached duration of the stream in seconds.
|
||||
float_t duration;
|
||||
|
||||
// Frame offset the next platform Buffer() call should start playback
|
||||
// from - set by audioStreamSetPosition() (an explicit seek) and by
|
||||
// audioStreamUpdate() itself (to loopTo's frame offset, for platforms
|
||||
// that re-enter Buffer() on every loop restart rather than looping
|
||||
// natively). Each platform's Buffer()-invoking entry point must read and
|
||||
// reset this to 0 synchronously, in the same call that decided to
|
||||
// (re)buffer - not later/asynchronously (e.g. from a feeder thread),
|
||||
// since audioStreamUpdate() may already have moved on to something else
|
||||
// that touches this field by the time an async reader gets to it.
|
||||
size_t startFrame;
|
||||
|
||||
// True when startFrame came from an explicit audioStreamSetPosition()
|
||||
// seek rather than a natural loop restart. Platforms whose Buffer() call
|
||||
// can leave previously-queued audio still playing underneath the new
|
||||
// pass (currently just Linux's SDL queue, kept deliberately overlapping
|
||||
// across a loop restart to avoid a gap) need this to tell "jump now,
|
||||
// discarding whatever's still playing" (seek) apart from "let the old
|
||||
// tail keep playing while the new pass queues underneath it" (loop
|
||||
// restart) - both look identical as just "a pending startFrame"
|
||||
// otherwise. Consumed (reset to false) the same way as startFrame.
|
||||
bool_t seeking;
|
||||
|
||||
// Callbacks
|
||||
void *user;
|
||||
void (*onLoop)(audiostream_t *stream);
|
||||
void (*onEnd)(audiostream_t *stream);
|
||||
|
||||
// Incremented by platform code (from whatever thread/context it runs in)
|
||||
// each time a loop happens, instead of calling onLoop directly - onLoop
|
||||
// may do arbitrary, possibly-slow work (console printing, game logic),
|
||||
// which is only safe to run from the main thread inside audioStreamUpdate().
|
||||
// Calling it straight from a real-time audio thread risks starving the
|
||||
// hardware buffer if it takes too long - confirmed as the real cause of
|
||||
// a loud crackle on PSP once its feeder thread called onLoop inline.
|
||||
volatile uint32_t loopCount;
|
||||
|
||||
// audioStreamUpdate()'s own record of the last loopCount it fired
|
||||
// onLoop for - only ever touched from the main thread.
|
||||
uint32_t lastLoopCount;
|
||||
|
||||
// Maximum number of times this stream is allowed to loop before stopping
|
||||
// (firing onEnd) instead of restarting again - 0 (the default) means loop
|
||||
// forever. Has no effect unless looping is also enabled via
|
||||
// audioStreamSetLooping(). Set via audioStreamSetLoopLimit().
|
||||
uint32_t loopLimit;
|
||||
|
||||
// How many loop restarts this stream has already committed to - compared
|
||||
// against loopLimit each time a restart is considered, then incremented
|
||||
// if it goes ahead; reset to 0 by audioStreamSetLoopLimit(). Distinct
|
||||
// from loopCount (which tracks when a loop becomes audible, purely for
|
||||
// onLoop notification, and is PSP-only) - this counts decided restarts,
|
||||
// main-thread-only on every platform (PSP decides whether to loop from
|
||||
// its own read-ahead ring, itself driven from the main thread via
|
||||
// audioStreamPSPIsFinished() - see its own comment).
|
||||
uint32_t loopRestartCount;
|
||||
|
||||
// PCM format of the stream's decoded output - read identically by every
|
||||
// platform backend regardless of stream type (PCM decodes straight
|
||||
// through; MP3 decodes to this same format), so it lives here rather
|
||||
// than duplicated in both audiostreampcm_t and audiostreammp3_t. Set by
|
||||
// whichever type-specific Init function runs (audioStreamPcmInit() /
|
||||
// audioStreamMp3Init()).
|
||||
uint32_t sampleRate;
|
||||
uint8_t channels;
|
||||
|
||||
// Stream type specific data.
|
||||
union {
|
||||
audiostreampcm_t pcm;
|
||||
audiostreammp3_t mp3;
|
||||
};
|
||||
|
||||
// Platform-specific playback state (e.g. SDL2 device, PSP channel, ASND
|
||||
// voice). Defined by each platform's audiostreamplatform.h.
|
||||
audiostreamplatform_t platform;
|
||||
} audiostream_t;
|
||||
|
||||
/**
|
||||
* Initializes an audio stream to play the given asset, determining the
|
||||
* stream's type from the asset's loader type (e.g. a WAV asset becomes an
|
||||
* AUDIO_STREAM_TYPE_PCM stream) and dispatching to that type's own setup
|
||||
* (e.g. audioStreamPcmInit()). Does not begin playback; call
|
||||
* audioStreamPlay() once this returns.
|
||||
*
|
||||
* The stream takes its own lock on `asset` (see audiostream_t.asset's own
|
||||
* comment), released by audioStreamDispose() - the asset must already be
|
||||
* loaded (ASSET_ENTRY_STATE_LOADED) when this is called.
|
||||
*
|
||||
* @param stream The audio stream to initialize.
|
||||
* @param asset The loaded asset to play - its type must be one this
|
||||
* function supports (ASSET_LOADER_TYPE_WAV or
|
||||
* ASSET_LOADER_TYPE_MP3).
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamInit(audiostream_t *stream, assetentry_t *asset);
|
||||
|
||||
/**
|
||||
* Returns the total number of decoded PCM frames (one sample per channel)
|
||||
* available in the stream's underlying data, regardless of its type -
|
||||
* dispatches to audioStreamPcmGetTotalFrames() or
|
||||
* audioStreamMp3GetTotalFrames(). Platform backends should use this rather
|
||||
* than a type-specific function directly, so they don't need to know or
|
||||
* care which type they're driving.
|
||||
*
|
||||
* @param stream The audio stream to query.
|
||||
* @return The total number of frames available.
|
||||
*/
|
||||
size_t audioStreamGetTotalFrames(const audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Seeks the stream's decode position to the given frame offset, regardless
|
||||
* of its type - dispatches to audioStreamPcmSeek() or audioStreamMp3Seek().
|
||||
*
|
||||
* @param stream The audio stream to seek.
|
||||
* @param frame Frame offset to seek to, relative to the start of the
|
||||
* stream's decoded data.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamSeek(audiostream_t *stream, const size_t frame);
|
||||
|
||||
/**
|
||||
* Reads up to frameCount frames of decoded PCM sample data from the
|
||||
* stream's current position, regardless of its type - dispatches to
|
||||
* audioStreamPcmRead() or audioStreamMp3Read(). See either for the exact
|
||||
* short-read-at-end-of-stream contract, which is identical for both.
|
||||
*
|
||||
* @param stream The audio stream to read from.
|
||||
* @param buffer Destination buffer, sized for at least frameCount frames.
|
||||
* @param frameCount Maximum number of frames to read.
|
||||
* @param outFramesRead Set to the number of frames actually read.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamRead(
|
||||
audiostream_t *stream,
|
||||
int16_t *buffer,
|
||||
const size_t frameCount,
|
||||
size_t *outFramesRead
|
||||
);
|
||||
|
||||
/**
|
||||
* Begins or resumes playback of the given audio stream.
|
||||
*
|
||||
* @param stream The audio stream to play.
|
||||
*/
|
||||
void audioStreamPlay(audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Pauses playback of the given audio stream. Playback position is retained,
|
||||
* so audioStreamPlay() resumes from the same point.
|
||||
*
|
||||
* @param stream The audio stream to pause.
|
||||
*/
|
||||
void audioStreamPause(audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Seeks the given audio stream to the given position, in seconds, wrapping
|
||||
* into range if the position is outside [0, duration). Takes effect on the
|
||||
* next audioStreamUpdate() call for platforms that re-buffer per frame
|
||||
* (e.g. Linux); on PSP, which manages an entire playback pass on its own
|
||||
* feeder thread once started, a seek only takes effect the next time the
|
||||
* stream begins playing from a stopped state, not instantaneously mid-pass.
|
||||
*
|
||||
* @param stream The audio stream to seek.
|
||||
* @param position The new playback position, in seconds.
|
||||
*/
|
||||
void audioStreamSetPosition(audiostream_t *stream, const float_t position);
|
||||
|
||||
/**
|
||||
* Sets the loop region for the given audio stream: once playback reaches
|
||||
* loopStart, it jumps back to loopTo instead of continuing (or stopping,
|
||||
* if not looping). Has no effect unless looping is also enabled via
|
||||
* audioStreamSetLooping().
|
||||
*
|
||||
* @param stream The audio stream to update.
|
||||
* @param loopStart Where the loop segment ends, in seconds, or -1 to loop
|
||||
* the whole stream (the default).
|
||||
* @param loopTo Where the loop segment starts, in seconds.
|
||||
*/
|
||||
void audioStreamSetLoopPoints(
|
||||
audiostream_t *stream,
|
||||
const float_t loopStart,
|
||||
const float_t loopTo
|
||||
);
|
||||
|
||||
/**
|
||||
* Computes normalized left/right pan factors (0..1) for the given audio
|
||||
* stream's directionality. Callers multiply these by their own
|
||||
* platform-specific base volume representation.
|
||||
*
|
||||
* @param stream The audio stream to read directionality from.
|
||||
* @param outLeft Set to the left channel's pan factor.
|
||||
* @param outRight Set to the right channel's pan factor.
|
||||
*/
|
||||
void audioStreamGetPanFactors(
|
||||
const audiostream_t *stream,
|
||||
float_t *outLeft,
|
||||
float_t *outRight
|
||||
);
|
||||
|
||||
/**
|
||||
* Computes the stop frame for a playback pass starting at startFrame: the
|
||||
* current loop segment's end (stream->loopStart, converted to frames and
|
||||
* clamped to totalFrames) if looping is enabled and a loop start is set,
|
||||
* or totalFrames itself otherwise - including when startFrame has already
|
||||
* reached or passed the computed loop end (e.g. a seek landing in an
|
||||
* outro past the loop point), in which case this pass plays out to the
|
||||
* true end of the stream once instead of only the loop segment.
|
||||
*
|
||||
* @param stream The audio stream to compute this for.
|
||||
* @param startFrame This pass's starting frame offset.
|
||||
* @param totalFrames The stream's total decoded frame count
|
||||
* (audioStreamGetTotalFrames()).
|
||||
* @return This pass's stop frame offset.
|
||||
*/
|
||||
size_t audioStreamComputeEndFrame(
|
||||
const audiostream_t *stream,
|
||||
const size_t startFrame,
|
||||
const size_t totalFrames
|
||||
);
|
||||
|
||||
/**
|
||||
* Sets the playback volume of the given audio stream.
|
||||
*
|
||||
* @param stream The audio stream to update.
|
||||
* @param volume The new volume, from 0.0 (silent) to 1.0 (loudest).
|
||||
*/
|
||||
void audioStreamSetVolume(audiostream_t *stream, const float_t volume);
|
||||
|
||||
/**
|
||||
* Sets the stereo directionality (panning) of the given audio stream.
|
||||
*
|
||||
* @param stream The audio stream to update.
|
||||
* @param directionality The new panning value, from AUDIO_STREAM_LEFT to
|
||||
* AUDIO_STREAM_RIGHT.
|
||||
*/
|
||||
void audioStreamSetDirectionality(
|
||||
audiostream_t *stream,
|
||||
const float_t directionality
|
||||
);
|
||||
|
||||
/**
|
||||
* Sets whether the given audio stream loops back to loopTo (or the start
|
||||
* of the buffer, by default - see audioStreamSetLoopPoints()) when it
|
||||
* reaches loopStart (or the end of the buffer), rather than stopping and
|
||||
* firing onEnd.
|
||||
*
|
||||
* @param stream The audio stream to update.
|
||||
* @param looping Whether the stream should loop.
|
||||
*/
|
||||
void audioStreamSetLooping(audiostream_t *stream, const bool_t looping);
|
||||
|
||||
/**
|
||||
* Sets the maximum number of times the given audio stream is allowed to
|
||||
* loop before stopping (firing onEnd) instead of restarting again. Has no
|
||||
* effect unless looping is also enabled via audioStreamSetLooping(). Resets
|
||||
* the stream's current loop-restart progress back to 0, so the stream gets
|
||||
* the full count from this call onward.
|
||||
*
|
||||
* @param stream The audio stream to update.
|
||||
* @param loopLimit Maximum number of loop restarts, or 0 (the default) to
|
||||
* loop forever.
|
||||
*/
|
||||
void audioStreamSetLoopLimit(audiostream_t *stream, const uint32_t loopLimit);
|
||||
|
||||
/**
|
||||
* Updates the given audio stream, decoding new data and advancing playback
|
||||
* as needed. Should be called every frame for every active stream.
|
||||
*
|
||||
* @param stream The audio stream to update.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamUpdate(audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Disposes the audio stream, stopping playback and releasing any resources
|
||||
* associated with it.
|
||||
*
|
||||
* @param stream The audio stream to dispose.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamDispose(audiostream_t *stream);
|
||||
@@ -0,0 +1,167 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "audiostreammp3.h"
|
||||
#include "audiostream.h"
|
||||
#include "assert/assert.h"
|
||||
#include "util/math.h"
|
||||
#include "util/memory.h"
|
||||
|
||||
errorret_t audioStreamMp3Init(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertNotNull(stream->asset, "Stream must have an asset assigned.");
|
||||
assertTrue(
|
||||
stream->asset->type == ASSET_LOADER_TYPE_MP3,
|
||||
"Asset is not an MP3 file."
|
||||
);
|
||||
|
||||
const assetmp3file_t *mp3 = &stream->asset->data.mp3;
|
||||
|
||||
stream->type = AUDIO_STREAM_TYPE_MP3;
|
||||
stream->sampleRate = mp3->sampleRate;
|
||||
stream->channels = mp3->channels;
|
||||
stream->duration = (float_t) mp3->totalFrames / (float_t) mp3->sampleRate;
|
||||
|
||||
stream->mp3.pendingFrames = 0;
|
||||
stream->mp3.pendingPosition = 0;
|
||||
stream->mp3.position = 0;
|
||||
stream->mp3.totalFrames = mp3->totalFrames;
|
||||
|
||||
// Each stream opens its own independent handle to the same underlying
|
||||
// asset file - see audiostreampcm.c's audioStreamPcmInit() for why.
|
||||
errorChain(assetFileInit(
|
||||
&stream->mp3.file, stream->asset->name, NULL, NULL
|
||||
));
|
||||
errorChain(assetFileOpen(&stream->mp3.file));
|
||||
errorChain(assetFileRead(&stream->mp3.file, NULL, mp3->dataOffset));
|
||||
|
||||
errorChain(audioStreamMp3DecoderInit(stream));
|
||||
|
||||
errorChain(audioStreamPlatformInit(stream));
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioStreamMp3Dispose(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(stream->type == AUDIO_STREAM_TYPE_MP3, "Stream is not MP3.");
|
||||
|
||||
errorChain(audioStreamMp3DecoderDispose(stream));
|
||||
errorChain(assetFileClose(&stream->mp3.file));
|
||||
errorChain(assetFileDispose(&stream->mp3.file));
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
size_t audioStreamMp3GetTotalFrames(const audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(stream->type == AUDIO_STREAM_TYPE_MP3, "Stream is not MP3.");
|
||||
|
||||
return stream->mp3.totalFrames;
|
||||
}
|
||||
|
||||
errorret_t audioStreamMp3Seek(audiostream_t *stream, const size_t frame) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(stream->type == AUDIO_STREAM_TYPE_MP3, "Stream is not MP3.");
|
||||
|
||||
if(frame == stream->mp3.position) {
|
||||
errorOk();
|
||||
}
|
||||
|
||||
// Every seek - forward or backward - restarts decoding from the very
|
||||
// start of the compressed stream and discards frames until reaching the
|
||||
// target; see this file's own header comment for why MP3 has no cheaper
|
||||
// option, unlike audioStreamPcmSeek()'s direct byte-offset seek.
|
||||
errorChain(audioStreamMp3DecoderRewind(stream));
|
||||
stream->mp3.position = 0;
|
||||
stream->mp3.pendingFrames = 0;
|
||||
stream->mp3.pendingPosition = 0;
|
||||
|
||||
const size_t channels = stream->channels;
|
||||
int16_t discard[AUDIO_MP3_MAX_SAMPLES_PER_FRAME];
|
||||
|
||||
while(stream->mp3.position < frame) {
|
||||
size_t decodedFrames = 0;
|
||||
errorChain(
|
||||
audioStreamMp3DecoderDecodeFrame(stream, discard, &decodedFrames)
|
||||
);
|
||||
if(decodedFrames == 0) {
|
||||
// Ran out of stream before reaching the target - clamp rather than
|
||||
// erroring, same tolerance audioStreamPcmRead() has for a
|
||||
// shorter-than-declared asset.
|
||||
break;
|
||||
}
|
||||
|
||||
const size_t framesNeeded = frame - stream->mp3.position;
|
||||
if(decodedFrames <= framesNeeded) {
|
||||
stream->mp3.position += decodedFrames;
|
||||
continue;
|
||||
}
|
||||
|
||||
// This frame overshoots the target - keep the excess as pending so
|
||||
// the next Read() starts exactly at `frame` instead of skipping past
|
||||
// it.
|
||||
const size_t keepFrames = decodedFrames - framesNeeded;
|
||||
memoryMove(
|
||||
discard, discard + (framesNeeded * channels),
|
||||
keepFrames * channels * sizeof(int16_t)
|
||||
);
|
||||
memoryCopy(
|
||||
stream->mp3.pending, discard, keepFrames * channels * sizeof(int16_t)
|
||||
);
|
||||
stream->mp3.pendingFrames = keepFrames;
|
||||
stream->mp3.pendingPosition = 0;
|
||||
stream->mp3.position = frame;
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioStreamMp3Read(
|
||||
audiostream_t *stream,
|
||||
int16_t *buffer,
|
||||
const size_t frameCount,
|
||||
size_t *outFramesRead
|
||||
) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertNotNull(buffer, "Buffer cannot be NULL.");
|
||||
assertNotNull(outFramesRead, "outFramesRead cannot be NULL.");
|
||||
assertTrue(stream->type == AUDIO_STREAM_TYPE_MP3, "Stream is not MP3.");
|
||||
|
||||
const size_t channels = stream->channels;
|
||||
size_t framesWritten = 0;
|
||||
|
||||
while(framesWritten < frameCount) {
|
||||
if(stream->mp3.pendingPosition >= stream->mp3.pendingFrames) {
|
||||
size_t decodedFrames = 0;
|
||||
errorChain(audioStreamMp3DecoderDecodeFrame(
|
||||
stream, stream->mp3.pending, &decodedFrames
|
||||
));
|
||||
stream->mp3.pendingFrames = decodedFrames;
|
||||
stream->mp3.pendingPosition = 0;
|
||||
if(decodedFrames == 0) break; // Genuine end of stream.
|
||||
}
|
||||
|
||||
const size_t framesAvailable =
|
||||
stream->mp3.pendingFrames - stream->mp3.pendingPosition;
|
||||
const size_t framesToCopy =
|
||||
mathMin(frameCount - framesWritten, framesAvailable);
|
||||
|
||||
memoryCopy(
|
||||
buffer + (framesWritten * channels),
|
||||
stream->mp3.pending + (stream->mp3.pendingPosition * channels),
|
||||
framesToCopy * channels * sizeof(int16_t)
|
||||
);
|
||||
|
||||
stream->mp3.pendingPosition += framesToCopy;
|
||||
framesWritten += framesToCopy;
|
||||
}
|
||||
|
||||
stream->mp3.position += framesWritten;
|
||||
*outFramesRead = framesWritten;
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
#include "asset/assetfile.h"
|
||||
#include "audio/audiostreammp3decoder.h"
|
||||
|
||||
typedef struct audiostream_s audiostream_t;
|
||||
|
||||
// How many interleaved PCM samples (not frames - samples, i.e. frames *
|
||||
// channels) a single audioStreamMp3DecoderDecodeFrame() call is ever
|
||||
// allowed to produce. Sizes the pending-sample buffer below, which every
|
||||
// decoder backend writes directly into - this must be sized to the
|
||||
// largest of them, not just "one MPEG frame":
|
||||
// - libmad (software, Linux/Dolphin): always exactly one frame, 1152
|
||||
// samples/channel for MPEG-1 Layer III, doubled here for stereo.
|
||||
// - sceMp3 (hardware, PSP): its own pcmBuf is provisioned at double that
|
||||
// (see AUDIO_MP3_PSP_PCM_BUF_SIZE) - i.e. sceMp3Decode() can
|
||||
// legitimately hand back more than one frame's worth in a single call.
|
||||
// Sizing this for only one frame silently overflowed stream->mp3.pending
|
||||
// on real hardware whenever that happened - confirmed as the cause of
|
||||
// very intermittent audio corruption/clicking, since it only bit when
|
||||
// sceMp3 actually returned the larger amount.
|
||||
// So this covers the larger (PSP) case; libmad's decode is safely well
|
||||
// within it.
|
||||
#define AUDIO_MP3_MAX_SAMPLES_PER_FRAME (1152 * 2 * 2)
|
||||
|
||||
typedef struct {
|
||||
// This stream's own private handle into its asset's underlying file -
|
||||
// see audiostreampcm_t.file's own comment for why this isn't shared
|
||||
// across streams playing the same asset. Holds compressed MP3 bytes;
|
||||
// the decoder backend (audiostreammp3decoder.h) reads from it directly.
|
||||
assetfile_t file;
|
||||
|
||||
// Opaque per-platform decoder state - a reserved sceMp3 handle plus its
|
||||
// buffers on PSP, or libmad's mad_stream/mad_frame/mad_synth state plus a
|
||||
// sliding compressed-byte window on the libmad-based software backend
|
||||
// (Linux/Dolphin). Defined by whichever audiostreammp3decoder.h is
|
||||
// actually visible when this file is compiled - see that header's own
|
||||
// comment.
|
||||
audiostreammp3decoder_t decoder;
|
||||
|
||||
// One decoded MPEG frame's worth of PCM, held here across Read() calls
|
||||
// since a frame (576 or 1152 samples/channel) rarely lines up exactly
|
||||
// with whatever frameCount a caller asks for. pendingPosition marks how
|
||||
// many of the first pendingFrames frames have already been consumed.
|
||||
int16_t pending[AUDIO_MP3_MAX_SAMPLES_PER_FRAME];
|
||||
size_t pendingFrames;
|
||||
size_t pendingPosition;
|
||||
|
||||
// Current logical PCM frame position, relative to the start of the
|
||||
// decoded stream - decoding is push-forward-only (see
|
||||
// audioStreamMp3Seek()'s own comment on why a backward seek re-decodes
|
||||
// from the start rather than truly random-accessing).
|
||||
size_t position;
|
||||
|
||||
// Total decoded PCM frame count for the whole clip - copied from the
|
||||
// asset's parsed metadata at Init (see assetmp3file_t.totalFrames),
|
||||
// exact if a Xing/Info header was present, otherwise an estimate.
|
||||
size_t totalFrames;
|
||||
} audiostreammp3_t;
|
||||
|
||||
/**
|
||||
* Configures the given MP3 audio stream from its already-assigned asset
|
||||
* (see audiostream_t.asset - set by audioStreamInit(), which is what
|
||||
* should be calling this, not application code directly): opens this
|
||||
* stream's own private file handle onto the asset's compressed MPEG data,
|
||||
* and initializes the platform decoder backend
|
||||
* (audioStreamMp3DecoderInit()).
|
||||
*
|
||||
* Must be called after stream->asset is set and before audioStreamPlay().
|
||||
*
|
||||
* @param stream The audio stream to configure.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamMp3Init(audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Disposes the given MP3 audio stream's decoder backend and private file
|
||||
* handle.
|
||||
*
|
||||
* @param stream The audio stream to dispose.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamMp3Dispose(audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Returns the total number of frames (one sample per channel) available in
|
||||
* the stream's underlying MP3 data - see assetmp3file_t.totalFrames's own
|
||||
* comment on why this is sometimes an estimate rather than an exact count,
|
||||
* unlike audioStreamPcmGetTotalFrames().
|
||||
*
|
||||
* @param stream The audio stream to query. Must be AUDIO_STREAM_TYPE_MP3.
|
||||
* @return The total number of frames available.
|
||||
*/
|
||||
size_t audioStreamMp3GetTotalFrames(const audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Seeks the stream's decode position to the given frame offset. Unlike
|
||||
* audioStreamPcmSeek(), this is never cheap: MPEG frames aren't
|
||||
* independently decodable (each one's bit reservoir can depend on data
|
||||
* carried over from prior frames), so there's no equivalent of PCM's
|
||||
* direct byte-offset seek - every call, forward or backward, rewinds the
|
||||
* decoder to the very start of the compressed stream and decodes (and
|
||||
* discards) frames until reaching the target. Acceptable for this engine's
|
||||
* actual use (looping background music, where loopTo is typically near
|
||||
* the start anyway), but a real, non-constant cost for a seek deep into a
|
||||
* long track.
|
||||
*
|
||||
* @param stream The audio stream to seek. Must be AUDIO_STREAM_TYPE_MP3.
|
||||
* @param frame Frame offset to seek to, relative to the start of the
|
||||
* decoded stream.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamMp3Seek(audiostream_t *stream, const size_t frame);
|
||||
|
||||
/**
|
||||
* Reads up to frameCount frames of PCM sample data from the stream's
|
||||
* current position, advancing it by however many frames were actually
|
||||
* read. Reads fewer than frameCount (down to zero) once the underlying
|
||||
* MP3 data is exhausted, rather than erroring - same contract as
|
||||
* audioStreamPcmRead().
|
||||
*
|
||||
* @param stream The audio stream to read from. Must be AUDIO_STREAM_TYPE_MP3.
|
||||
* @param buffer Destination buffer, sized for at least frameCount frames.
|
||||
* @param frameCount Maximum number of frames to read.
|
||||
* @param outFramesRead Set to the number of frames actually read.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamMp3Read(
|
||||
audiostream_t *stream,
|
||||
int16_t *buffer,
|
||||
const size_t frameCount,
|
||||
size_t *outFramesRead
|
||||
);
|
||||
@@ -0,0 +1,179 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "audiostreampcm.h"
|
||||
#include "audiostream.h"
|
||||
#include "assert/assert.h"
|
||||
#include "util/math.h"
|
||||
#include "util/memory.h"
|
||||
#include "util/endian.h"
|
||||
|
||||
errorret_t audioStreamPcmInit(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertNotNull(stream->asset, "Stream must have an asset assigned.");
|
||||
assertTrue(
|
||||
stream->asset->type == ASSET_LOADER_TYPE_WAV,
|
||||
"Asset is not a WAV file."
|
||||
);
|
||||
|
||||
assetwavfile_t *wav = &stream->asset->data.wav;
|
||||
|
||||
stream->type = AUDIO_STREAM_TYPE_PCM;
|
||||
stream->sampleRate = wav->sampleRate;
|
||||
stream->channels = wav->channels;
|
||||
stream->duration = (
|
||||
(float_t) audioStreamPcmGetTotalFrames(stream) /
|
||||
(float_t) wav->sampleRate
|
||||
);
|
||||
|
||||
// Each stream opens its own independent handle to the same underlying
|
||||
// asset file, rather than sharing a single handle on the asset entry -
|
||||
// multiple streams playing the same asset concurrently (e.g. two
|
||||
// simultaneous plays of the same sound effect) would otherwise fight
|
||||
// over one shared read position. This isn't the final answer for that
|
||||
// (a shared decode/cache layer would scale better than N independent
|
||||
// decompression streams of the same data), but it's a correct one for
|
||||
// now - a problem to revisit once it actually matters.
|
||||
errorChain(assetFileInit(
|
||||
&stream->pcm.file, stream->asset->name, NULL, NULL
|
||||
));
|
||||
errorChain(assetFileOpen(&stream->pcm.file));
|
||||
errorChain(assetFileRead(&stream->pcm.file, NULL, wav->dataOffset));
|
||||
|
||||
errorChain(audioStreamPlatformInit(stream));
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioStreamPcmDispose(audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(stream->type == AUDIO_STREAM_TYPE_PCM, "Stream is not PCM.");
|
||||
|
||||
errorChain(assetFileClose(&stream->pcm.file));
|
||||
errorChain(assetFileDispose(&stream->pcm.file));
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
size_t audioStreamPcmGetTotalFrames(const audiostream_t *stream) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(stream->type == AUDIO_STREAM_TYPE_PCM, "Stream is not PCM.");
|
||||
|
||||
const assetwavfile_t *wav = &stream->asset->data.wav;
|
||||
const size_t sourceFrameSize = (
|
||||
stream->channels * (wav->bitsPerSample / 8)
|
||||
);
|
||||
return wav->dataSize / sourceFrameSize;
|
||||
}
|
||||
|
||||
errorret_t audioStreamPcmSeek(audiostream_t *stream, const size_t frame) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertTrue(stream->type == AUDIO_STREAM_TYPE_PCM, "Stream is not PCM.");
|
||||
|
||||
assetwavfile_t *wav = &stream->asset->data.wav;
|
||||
const size_t sourceFrameSize = (
|
||||
stream->channels * (wav->bitsPerSample / 8)
|
||||
);
|
||||
const size_t targetByte = wav->dataOffset + (frame * sourceFrameSize);
|
||||
|
||||
assertTrue(
|
||||
frame * sourceFrameSize <= wav->dataSize,
|
||||
"Seek frame is beyond the end of the PCM data."
|
||||
);
|
||||
|
||||
const size_t currentByte = (size_t) stream->pcm.file.position;
|
||||
if(targetByte < currentByte) {
|
||||
// Only a full rewind can move a read cursor earlier once it's already
|
||||
// advanced past a point - a compressed archive entry can't be decoded
|
||||
// backward. See this function's own doc comment for the performance
|
||||
// implications of a deep loopTo.
|
||||
errorChain(assetFileRewind(&stream->pcm.file));
|
||||
errorChain(assetFileRead(&stream->pcm.file, NULL, targetByte));
|
||||
} else if(targetByte > currentByte) {
|
||||
errorChain(assetFileRead(
|
||||
&stream->pcm.file, NULL, targetByte - currentByte
|
||||
));
|
||||
}
|
||||
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t audioStreamPcmRead(
|
||||
audiostream_t *stream,
|
||||
int16_t *buffer,
|
||||
const size_t frameCount,
|
||||
size_t *outFramesRead
|
||||
) {
|
||||
assertNotNull(stream, "Stream cannot be NULL.");
|
||||
assertNotNull(buffer, "Buffer cannot be NULL.");
|
||||
assertNotNull(outFramesRead, "outFramesRead cannot be NULL.");
|
||||
assertTrue(stream->type == AUDIO_STREAM_TYPE_PCM, "Stream is not PCM.");
|
||||
|
||||
assetwavfile_t *wav = &stream->asset->data.wav;
|
||||
const size_t channels = stream->channels;
|
||||
const size_t sourceSampleBytes = wav->bitsPerSample / 8;
|
||||
const size_t sourceFrameSize = channels * sourceSampleBytes;
|
||||
const size_t dataEndByte = wav->dataOffset + wav->dataSize;
|
||||
const size_t currentByte = (size_t) stream->pcm.file.position;
|
||||
|
||||
const size_t bytesAvailable = (
|
||||
currentByte < dataEndByte ? dataEndByte - currentByte : 0
|
||||
);
|
||||
const size_t framesAvailable = bytesAvailable / sourceFrameSize;
|
||||
const size_t framesToRead = mathMin(frameCount, framesAvailable);
|
||||
|
||||
if(framesToRead == 0) {
|
||||
*outFramesRead = 0;
|
||||
errorOk();
|
||||
}
|
||||
|
||||
if(sourceSampleBytes == sizeof(int16_t)) {
|
||||
// Output format already matches the source in width, but WAV samples
|
||||
// are always little-endian per the format spec regardless of host -
|
||||
// read straight through, then fix up byte order in place. A no-op on
|
||||
// every little-endian platform (endianLittleToHost16() compiles down
|
||||
// to returning its argument unchanged there) - only actually swaps
|
||||
// anything on a big-endian host (Dolphin/GameCube/Wii).
|
||||
errorChain(assetFileRead(
|
||||
&stream->pcm.file, buffer, framesToRead * sourceFrameSize
|
||||
));
|
||||
const size_t sampleCount = framesToRead * channels;
|
||||
for(size_t i = 0; i < sampleCount; i++) {
|
||||
buffer[i] = (int16_t) endianLittleToHost16((uint16_t) buffer[i]);
|
||||
}
|
||||
} else {
|
||||
// 24-bit source (the only other width assetWavParseHeader() accepts) -
|
||||
// read the raw 3-byte samples into a scratch buffer, then truncate
|
||||
// each down to 16-bit, since none of PSP/Dolphin's audio hardware (or
|
||||
// SDL2 on Linux) accepts anything wider - see assetwavfile_t's own
|
||||
// comment on bitsPerSample.
|
||||
assertTrue(sourceSampleBytes == 3, "Unsupported PCM sample width.");
|
||||
|
||||
const size_t rawBytes = framesToRead * sourceFrameSize;
|
||||
uint8_t *raw = memoryAllocate(rawBytes);
|
||||
errorret_t ret = assetFileRead(&stream->pcm.file, raw, rawBytes);
|
||||
if(errorIsNotOk(ret)) {
|
||||
memoryFree(raw);
|
||||
errorChain(ret);
|
||||
}
|
||||
|
||||
// 24-bit PCM samples are little-endian two's complement - the top two
|
||||
// bytes of each (indices 1 and 2) already form that same value
|
||||
// truncated to 16-bit (equivalent to an arithmetic right-shift by 8
|
||||
// bits, which preserves the sign correctly since byte 2 carries it).
|
||||
const size_t sampleCount = framesToRead * channels;
|
||||
for(size_t i = 0; i < sampleCount; i++) {
|
||||
const uint8_t *sample = raw + (i * 3);
|
||||
buffer[i] = (int16_t) (sample[1] | (sample[2] << 8));
|
||||
}
|
||||
|
||||
memoryFree(raw);
|
||||
}
|
||||
|
||||
*outFramesRead = framesToRead;
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "error/error.h"
|
||||
#include "asset/assetfile.h"
|
||||
|
||||
typedef struct audiostream_s audiostream_t;
|
||||
|
||||
typedef struct {
|
||||
// This stream's own private handle into its asset's underlying file -
|
||||
// deliberately not shared with any other stream reading the same asset
|
||||
// (see audioStreamPcmInit's own comment for why). Its read cursor is
|
||||
// what audioStreamPcmRead()/audioStreamPcmSeek() operate on.
|
||||
assetfile_t file;
|
||||
} audiostreampcm_t;
|
||||
|
||||
/**
|
||||
* Configures the given PCM audio stream from its already-assigned asset
|
||||
* (see audiostream_t.asset - set by audioStreamInit(), which is what
|
||||
* should be calling this, not application code directly) rather than
|
||||
* taking raw decoded data: sampleRate/channels/duration are read from the
|
||||
* asset's parsed WAV header, and a private file handle is opened for
|
||||
* reading sample data on demand as playback consumes it (see
|
||||
* audioStreamPcmRead()) - the PCM data itself is never read into memory
|
||||
* all at once, so this works the same regardless of how long the
|
||||
* underlying clip is.
|
||||
*
|
||||
* Must be called after stream->asset is set and before audioStreamPlay().
|
||||
*
|
||||
* @param stream The audio stream to configure.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamPcmInit(audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Disposes the given PCM audio stream's own private file handle.
|
||||
*
|
||||
* @param stream The audio stream to dispose.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamPcmDispose(audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Returns the total number of frames (one sample per channel) available
|
||||
* in the stream's underlying PCM data - NOT simply the asset's declared
|
||||
* byte size divided by a 16-bit frame size, since the source data isn't
|
||||
* always 16-bit even though audioStreamPcmRead() always produces 16-bit
|
||||
* output (see assetwavfile_t.bitsPerSample). Platform backends should use
|
||||
* this rather than computing frame counts from dataSize themselves.
|
||||
*
|
||||
* @param stream The audio stream to query. Must be AUDIO_STREAM_TYPE_PCM.
|
||||
* @return The total number of frames available.
|
||||
*/
|
||||
size_t audioStreamPcmGetTotalFrames(const audiostream_t *stream);
|
||||
|
||||
/**
|
||||
* Seeks the stream's private read cursor to the given frame offset
|
||||
* (relative to the start of the PCM data - the same units as
|
||||
* audiostream_t's startFrame/loopStart/loopTo, once converted from
|
||||
* seconds). Seeking backward re-reads from the start of the underlying
|
||||
* asset file (see assetFileRewind()) since a compressed archive entry can
|
||||
* only be decoded forward - this makes a loop with a deep loopTo more
|
||||
* expensive to restart than one near the start, which is a real
|
||||
* performance caveat, not just a theoretical one, for anything backed by
|
||||
* a compressed (not stored) asset archive entry.
|
||||
*
|
||||
* @param stream The audio stream to seek. Must be AUDIO_STREAM_TYPE_PCM.
|
||||
* @param frame Frame offset to seek to, relative to the start of the PCM
|
||||
* data.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamPcmSeek(audiostream_t *stream, const size_t frame);
|
||||
|
||||
/**
|
||||
* Reads up to frameCount frames of PCM sample data from the stream's
|
||||
* current read position, advancing it by however many frames were
|
||||
* actually read. Reads fewer than frameCount (down to zero) once the
|
||||
* underlying asset's PCM data is exhausted, rather than erroring - it's
|
||||
* up to the caller (platform code, which already knows about loop points)
|
||||
* to request no more than what it wants read from within the current
|
||||
* loop segment or the true end of the clip.
|
||||
*
|
||||
* @param stream The audio stream to read from. Must be AUDIO_STREAM_TYPE_PCM.
|
||||
* @param buffer Destination buffer, sized for at least frameCount frames.
|
||||
* @param frameCount Maximum number of frames to read.
|
||||
* @param outFramesRead Set to the number of frames actually read.
|
||||
* @return Error indicating success or failure.
|
||||
*/
|
||||
errorret_t audioStreamPcmRead(
|
||||
audiostream_t *stream,
|
||||
int16_t *buffer,
|
||||
const size_t frameCount,
|
||||
size_t *outFramesRead
|
||||
);
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "audiostreamtype.h"
|
||||
#include "util/string.h"
|
||||
|
||||
const audiostreamassettypeinfo_t
|
||||
AUDIO_STREAM_TYPE_FOR_ASSET_TYPE[ASSET_LOADER_TYPE_COUNT] = {
|
||||
[ASSET_LOADER_TYPE_WAV] = {
|
||||
.type = AUDIO_STREAM_TYPE_PCM, .extension = ".wav"
|
||||
},
|
||||
[ASSET_LOADER_TYPE_MP3] = {
|
||||
.type = AUDIO_STREAM_TYPE_MP3, .extension = ".mp3"
|
||||
}
|
||||
};
|
||||
|
||||
assetloadertype_t audioStreamAssetTypeForPath(const char_t *path) {
|
||||
for(assetloadertype_t i = 0; i < ASSET_LOADER_TYPE_COUNT; i++) {
|
||||
const char_t *extension = AUDIO_STREAM_TYPE_FOR_ASSET_TYPE[i].extension;
|
||||
if(extension != NULL && stringEndsWithCaseInsensitive(path, extension)) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return ASSET_LOADER_TYPE_NULL;
|
||||
}
|
||||
|
||||
audistreamtype_t audioStreamTypeForAssetType(
|
||||
const assetloadertype_t assetType
|
||||
) {
|
||||
return AUDIO_STREAM_TYPE_FOR_ASSET_TYPE[assetType].type;
|
||||
}
|
||||
|
||||
assetloadertype_t audioStreamAssetTypeForStreamType(
|
||||
const audistreamtype_t streamType
|
||||
) {
|
||||
if(streamType == AUDIO_STREAM_TYPE_NULL) return ASSET_LOADER_TYPE_NULL;
|
||||
|
||||
for(assetloadertype_t i = 0; i < ASSET_LOADER_TYPE_COUNT; i++) {
|
||||
if(AUDIO_STREAM_TYPE_FOR_ASSET_TYPE[i].type == streamType) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return ASSET_LOADER_TYPE_NULL;
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "dusk.h"
|
||||
#include "asset/loader/assetloader.h"
|
||||
|
||||
typedef enum {
|
||||
AUDIO_STREAM_TYPE_NULL,
|
||||
AUDIO_STREAM_TYPE_PCM,
|
||||
AUDIO_STREAM_TYPE_MP3,
|
||||
AUDIO_STREAM_TYPE_COUNT
|
||||
} audistreamtype_t;
|
||||
|
||||
typedef struct {
|
||||
// The audistreamtype_t an audio stream backed by this asset type should
|
||||
// become - AUDIO_STREAM_TYPE_NULL (the zero-initialized default) for any
|
||||
// asset type that can't back an audio stream.
|
||||
audistreamtype_t type;
|
||||
|
||||
// This asset type's file extension, including the leading '.' (e.g.
|
||||
// ".wav"). NULL for any asset type that can't back an audio stream.
|
||||
const char_t *extension;
|
||||
} audiostreamassettypeinfo_t;
|
||||
|
||||
// Maps an assetloadertype_t to the info describing the audio stream it
|
||||
// backs. Indexed directly by assetentry_t.type; see audioStreamInit()'s own
|
||||
// use of this for the canonical "is this asset type supported" check. Use
|
||||
// the functions below rather than indexing this directly, except where
|
||||
// you already have an assetloadertype_t in hand.
|
||||
extern const audiostreamassettypeinfo_t
|
||||
AUDIO_STREAM_TYPE_FOR_ASSET_TYPE[ASSET_LOADER_TYPE_COUNT];
|
||||
|
||||
/**
|
||||
* Determines which asset loader type a file path's extension corresponds
|
||||
* to, by matching it against AUDIO_STREAM_TYPE_FOR_ASSET_TYPE's own
|
||||
* extensions (case-insensitively).
|
||||
*
|
||||
* @param path The file path to inspect, e.g. "audio/boa.mp3".
|
||||
* @return The matching assetloadertype_t, or ASSET_LOADER_TYPE_NULL if the
|
||||
* path's extension doesn't match any audio asset type.
|
||||
*/
|
||||
assetloadertype_t audioStreamAssetTypeForPath(const char_t *path);
|
||||
|
||||
/**
|
||||
* Looks up the audistreamtype_t an audio stream backed by the given asset
|
||||
* type should become.
|
||||
*
|
||||
* @param assetType The asset loader type to look up.
|
||||
* @return The matching audistreamtype_t, or AUDIO_STREAM_TYPE_NULL if
|
||||
* assetType can't back an audio stream.
|
||||
*/
|
||||
audistreamtype_t audioStreamTypeForAssetType(const assetloadertype_t assetType);
|
||||
|
||||
/**
|
||||
* Looks up which asset loader type backs audio streams of the given type -
|
||||
* the reverse of audioStreamTypeForAssetType(). Scans
|
||||
* AUDIO_STREAM_TYPE_FOR_ASSET_TYPE for the first entry whose type matches,
|
||||
* since it isn't itself indexed by audistreamtype_t.
|
||||
*
|
||||
* @param streamType The audio stream type to look up.
|
||||
* @return The matching assetloadertype_t, or ASSET_LOADER_TYPE_NULL if
|
||||
* streamType is AUDIO_STREAM_TYPE_NULL or otherwise unmapped.
|
||||
*/
|
||||
assetloadertype_t audioStreamAssetTypeForStreamType(
|
||||
const audistreamtype_t streamType
|
||||
);
|
||||
@@ -17,8 +17,8 @@ console_t CONSOLE;
|
||||
|
||||
void consoleInit(void) {
|
||||
memoryZero(&CONSOLE, sizeof(console_t));
|
||||
// CONSOLE.visible = false;
|
||||
CONSOLE.visible = true;
|
||||
CONSOLE.visible = false;
|
||||
// CONSOLE.visible = true;
|
||||
threadMutexInit(&CONSOLE.printMutex);
|
||||
}
|
||||
|
||||
|
||||
@@ -55,8 +55,8 @@ void capsuleBuffer(
|
||||
vertices[vi].uv[1] = (v); \
|
||||
vi++;
|
||||
|
||||
/* ---- Top hemisphere ---- */
|
||||
/* phi ranges from PI/2 (top pole) down to 0 (equator). */
|
||||
// ---- Top hemisphere ----
|
||||
// phi ranges from PI/2 (top pole) down to 0 (equator).
|
||||
const float_t capStep = (float_t)GLM_PI_2 / (float_t)capRings;
|
||||
for(int32_t i = 0; i < capRings; i++) {
|
||||
const float_t phi1 = (float_t)GLM_PI_2 - (float_t)i * capStep;
|
||||
@@ -67,8 +67,8 @@ void capsuleBuffer(
|
||||
const float_t lxz1 = radius * cosf(phi1);
|
||||
const float_t lxz2 = radius * cosf(phi2);
|
||||
|
||||
/* UV: top cap occupies v in [0.5 + halfHeightFrac .. 1.0]: we use a
|
||||
* simple per-band normalisation against the full height. */
|
||||
// UV: top cap occupies v in [0.5 + halfHeightFrac .. 1.0]: we use a
|
||||
// simple per-band normalisation against the full height.
|
||||
const float_t v1 = 1.0f - (float_t)i / (float_t)(2 * capRings + 1);
|
||||
const float_t v2 = 1.0f - (float_t)(i + 1) / (float_t)(2 * capRings + 1);
|
||||
|
||||
@@ -97,7 +97,7 @@ void capsuleBuffer(
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- Cylindrical body ---- */
|
||||
// ---- Cylindrical body ----
|
||||
{
|
||||
const float_t yTop = cy + halfHeight;
|
||||
const float_t yBot = cy - halfHeight;
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
// Copyright (c) 2026 Dominic Masters
|
||||
//
|
||||
// This software is released under the MIT License.
|
||||
// https://opensource.org/licenses/MIT
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "display/display.h"
|
||||
|
||||
@@ -59,7 +59,7 @@ void planeBuffer(
|
||||
|
||||
switch(axis) {
|
||||
case PLANE_AXIS_XY: {
|
||||
/* Flat in XY at z = min[2]; spans X and Y. */
|
||||
// Flat in XY at z = min[2]; spans X and Y.
|
||||
const float_t z = min[2];
|
||||
PLANE_VERT(0, min[0], min[1], z, u0, v0)
|
||||
PLANE_VERT(1, max[0], min[1], z, u1, v0)
|
||||
@@ -71,7 +71,7 @@ void planeBuffer(
|
||||
}
|
||||
|
||||
case PLANE_AXIS_XZ: {
|
||||
/* Flat in XZ at y = min[1]; spans X and Z. */
|
||||
// Flat in XZ at y = min[1]; spans X and Z.
|
||||
const float_t y = min[1];
|
||||
PLANE_VERT(0, min[0], y, min[2], u0, v0)
|
||||
PLANE_VERT(1, max[0], y, min[2], u1, v0)
|
||||
@@ -83,7 +83,7 @@ void planeBuffer(
|
||||
}
|
||||
|
||||
case PLANE_AXIS_YZ: {
|
||||
/* Flat in YZ at x = min[0]; spans Y and Z. */
|
||||
// Flat in YZ at x = min[0]; spans Y and Z.
|
||||
const float_t x = min[0];
|
||||
PLANE_VERT(0, x, min[1], min[2], u0, v0)
|
||||
PLANE_VERT(1, x, max[1], min[2], u1, v0)
|
||||
|
||||
@@ -44,7 +44,7 @@ void sphereBuffer(
|
||||
int32_t vi = 0;
|
||||
|
||||
for(int32_t i = 0; i < stacks; i++) {
|
||||
/* Latitude angles: top of band -> bottom of band */
|
||||
// Latitude angles: top of band -> bottom of band
|
||||
const float_t phi1 = (float_t)GLM_PI_2 - (float_t)i * stackStep;
|
||||
const float_t phi2 = (float_t)GLM_PI_2 - (float_t)(i + 1) * stackStep;
|
||||
|
||||
@@ -73,27 +73,33 @@ void sphereBuffer(
|
||||
const float_t u1 = (float_t)j / (float_t)sectors;
|
||||
const float_t u2 = (float_t)(j + 1) / (float_t)sectors;
|
||||
|
||||
vertices[vi].pos[0] = center[0] + x11; vertices[vi].pos[1] = center[1] + y1;
|
||||
vertices[vi].pos[0] = center[0] + x11;
|
||||
vertices[vi].pos[1] = center[1] + y1;
|
||||
vertices[vi].pos[2] = center[2] + z11;
|
||||
vertices[vi].uv[0] = u1; vertices[vi].uv[1] = v1; vi++;
|
||||
|
||||
vertices[vi].pos[0] = center[0] + x21; vertices[vi].pos[1] = center[1] + y2;
|
||||
vertices[vi].pos[0] = center[0] + x21;
|
||||
vertices[vi].pos[1] = center[1] + y2;
|
||||
vertices[vi].pos[2] = center[2] + z21;
|
||||
vertices[vi].uv[0] = u1; vertices[vi].uv[1] = v2; vi++;
|
||||
|
||||
vertices[vi].pos[0] = center[0] + x12; vertices[vi].pos[1] = center[1] + y1;
|
||||
vertices[vi].pos[0] = center[0] + x12;
|
||||
vertices[vi].pos[1] = center[1] + y1;
|
||||
vertices[vi].pos[2] = center[2] + z12;
|
||||
vertices[vi].uv[0] = u2; vertices[vi].uv[1] = v1; vi++;
|
||||
|
||||
vertices[vi].pos[0] = center[0] + x12; vertices[vi].pos[1] = center[1] + y1;
|
||||
vertices[vi].pos[0] = center[0] + x12;
|
||||
vertices[vi].pos[1] = center[1] + y1;
|
||||
vertices[vi].pos[2] = center[2] + z12;
|
||||
vertices[vi].uv[0] = u2; vertices[vi].uv[1] = v1; vi++;
|
||||
|
||||
vertices[vi].pos[0] = center[0] + x21; vertices[vi].pos[1] = center[1] + y2;
|
||||
vertices[vi].pos[0] = center[0] + x21;
|
||||
vertices[vi].pos[1] = center[1] + y2;
|
||||
vertices[vi].pos[2] = center[2] + z21;
|
||||
vertices[vi].uv[0] = u1; vertices[vi].uv[1] = v2; vi++;
|
||||
|
||||
vertices[vi].pos[0] = center[0] + x22; vertices[vi].pos[1] = center[1] + y2;
|
||||
vertices[vi].pos[0] = center[0] + x22;
|
||||
vertices[vi].pos[1] = center[1] + y2;
|
||||
vertices[vi].pos[2] = center[2] + z22;
|
||||
vertices[vi].uv[0] = u2; vertices[vi].uv[1] = v2; vi++;
|
||||
}
|
||||
|
||||
@@ -47,17 +47,17 @@ void triPrismBuffer(
|
||||
vertices[vi].uv[1] = (v); \
|
||||
vi++;
|
||||
|
||||
/* --- Front face (z = maxZ), CCW from +Z --- */
|
||||
// --- Front face (z = maxZ), CCW from +Z ---
|
||||
PRISM_VERT(x0, y0, maxZ, 0.0f, 0.0f)
|
||||
PRISM_VERT(x1, y1, maxZ, 1.0f, 0.0f)
|
||||
PRISM_VERT(x2, y2, maxZ, 0.5f, 1.0f)
|
||||
|
||||
/* --- Back face (z = minZ), CCW from -Z (reverse winding) --- */
|
||||
// --- Back face (z = minZ), CCW from -Z (reverse winding) ---
|
||||
PRISM_VERT(x2, y2, minZ, 0.5f, 1.0f)
|
||||
PRISM_VERT(x1, y1, minZ, 1.0f, 0.0f)
|
||||
PRISM_VERT(x0, y0, minZ, 0.0f, 0.0f)
|
||||
|
||||
/* --- Side face 0: edge p0->p1 --- */
|
||||
// --- Side face 0: edge p0->p1 ---
|
||||
PRISM_VERT(x0, y0, minZ, 0.0f, 0.0f)
|
||||
PRISM_VERT(x1, y1, minZ, 1.0f, 0.0f)
|
||||
PRISM_VERT(x1, y1, maxZ, 1.0f, 1.0f)
|
||||
@@ -66,7 +66,7 @@ void triPrismBuffer(
|
||||
PRISM_VERT(x1, y1, maxZ, 1.0f, 1.0f)
|
||||
PRISM_VERT(x0, y0, maxZ, 0.0f, 1.0f)
|
||||
|
||||
/* --- Side face 1: edge p1->p2 --- */
|
||||
// --- Side face 1: edge p1->p2 ---
|
||||
PRISM_VERT(x1, y1, minZ, 0.0f, 0.0f)
|
||||
PRISM_VERT(x2, y2, minZ, 1.0f, 0.0f)
|
||||
PRISM_VERT(x2, y2, maxZ, 1.0f, 1.0f)
|
||||
@@ -75,7 +75,7 @@ void triPrismBuffer(
|
||||
PRISM_VERT(x2, y2, maxZ, 1.0f, 1.0f)
|
||||
PRISM_VERT(x1, y1, maxZ, 0.0f, 1.0f)
|
||||
|
||||
/* --- Side face 2: edge p2->p0 --- */
|
||||
// --- Side face 2: edge p2->p0 ---
|
||||
PRISM_VERT(x2, y2, minZ, 0.0f, 0.0f)
|
||||
PRISM_VERT(x0, y0, minZ, 1.0f, 0.0f)
|
||||
PRISM_VERT(x0, y0, maxZ, 1.0f, 1.0f)
|
||||
|
||||
@@ -13,14 +13,14 @@
|
||||
shader_t *bound = NULL;
|
||||
|
||||
errorret_t shaderInit(shader_t *shader, const shaderdefinition_t *def) {
|
||||
assertNotNull(shader, "Shader cannot be null");
|
||||
assertNotNull(shader, "Shader cannot be NULL");
|
||||
errorChain(shaderInitPlatform(shader, def));
|
||||
bound = NULL;
|
||||
errorOk();
|
||||
}
|
||||
|
||||
errorret_t shaderBind(shader_t *shader) {
|
||||
assertNotNull(shader, "Shader cannot be null");
|
||||
assertNotNull(shader, "Shader cannot be NULL");
|
||||
errorChain(shaderBindPlatform(shader));
|
||||
bound = shader;
|
||||
errorOk();
|
||||
@@ -31,9 +31,9 @@ errorret_t shaderSetMatrix(
|
||||
const char_t *name,
|
||||
mat4 matrix
|
||||
) {
|
||||
assertNotNull(shader, "Shader cannot be null");
|
||||
assertNotNull(shader, "Shader cannot be NULL");
|
||||
assertStrLenMin(name, 1, "Uniform name cannot be empty");
|
||||
assertNotNull(matrix, "Matrix cannot be null");
|
||||
assertNotNull(matrix, "Matrix cannot be NULL");
|
||||
assertTrue(bound == shader, "Shader must be bound.");
|
||||
errorChain(shaderSetMatrixPlatform(shader, name, matrix));
|
||||
errorOk();
|
||||
@@ -44,7 +44,7 @@ errorret_t shaderSetTexture(
|
||||
const char_t *name,
|
||||
texture_t *texture
|
||||
) {
|
||||
assertNotNull(shader, "Shader cannot be null");
|
||||
assertNotNull(shader, "Shader cannot be NULL");
|
||||
assertStrLenMin(name, 1, "Uniform name cannot be empty");
|
||||
assertTrue(bound == shader, "Shader must be bound.");
|
||||
errorChain(shaderSetTexturePlatform(shader, name, texture));
|
||||
@@ -56,7 +56,7 @@ errorret_t shaderSetColor(
|
||||
const char_t *name,
|
||||
color_t color
|
||||
) {
|
||||
assertNotNull(shader, "Shader cannot be null");
|
||||
assertNotNull(shader, "Shader cannot be NULL");
|
||||
assertStrLenMin(name, 1, "Uniform name cannot be empty");
|
||||
assertTrue(bound == shader, "Shader must be bound.");
|
||||
errorChain(shaderSetColorPlatform(shader, name, color));
|
||||
@@ -67,16 +67,16 @@ errorret_t shaderSetMaterial(
|
||||
shader_t *shader,
|
||||
const shadermaterial_t *material
|
||||
) {
|
||||
assertNotNull(shader, "Shader cannot be null");
|
||||
assertNotNull(material, "Material cannot be null");
|
||||
assertNotNull(shader, "Shader cannot be NULL");
|
||||
assertNotNull(material, "Material cannot be NULL");
|
||||
assertTrue(bound == shader, "Shader must be bound.");
|
||||
assertNotNull(shader->definition, "Shader definition cannot be null");
|
||||
assertNotNull(shader->definition, "Shader definition cannot be NULL");
|
||||
assertNotNull(shader->definition->setMaterial, "Def lacks setMaterial");
|
||||
return shader->definition->setMaterial(shader, material);
|
||||
}
|
||||
|
||||
errorret_t shaderDispose(shader_t *shader) {
|
||||
assertNotNull(shader, "Shader cannot be null");
|
||||
assertNotNull(shader, "Shader cannot be NULL");
|
||||
bound = NULL;
|
||||
errorChain(shaderDisposePlatform(shader));
|
||||
errorOk();
|
||||
|
||||
@@ -41,10 +41,10 @@ errorret_t shaderListInit() {
|
||||
}
|
||||
|
||||
assertNotNull(
|
||||
SHADER_LIST_DEFS[i].shader, "Shader cannot be null"
|
||||
SHADER_LIST_DEFS[i].shader, "Shader cannot be NULL"
|
||||
);
|
||||
assertNotNull(
|
||||
SHADER_LIST_DEFS[i].definition, "Shader definition cannot be null"
|
||||
SHADER_LIST_DEFS[i].definition, "Shader definition cannot be NULL"
|
||||
);
|
||||
|
||||
errorChain(shaderInit(
|
||||
@@ -78,7 +78,7 @@ errorret_t shaderListDispose(void) {
|
||||
}
|
||||
|
||||
assertNotNull(
|
||||
SHADER_LIST_DEFS[i].shader, "Shader cannot be null"
|
||||
SHADER_LIST_DEFS[i].shader, "Shader cannot be NULL"
|
||||
);
|
||||
|
||||
errorChain(shaderDispose(SHADER_LIST_DEFS[i].shader));
|
||||
|
||||
@@ -31,9 +31,9 @@ errorret_t spriteBatchBuffer(
|
||||
shader_t *shader,
|
||||
const shadermaterial_t material
|
||||
) {
|
||||
assertNotNull(sprites, "Sprites cannot be null");
|
||||
assertNotNull(sprites, "Sprites cannot be NULL");
|
||||
assertTrue(count > 0, "Count must be greater than zero");
|
||||
assertNotNull(shader, "Shader cannot be null");
|
||||
assertNotNull(shader, "Shader cannot be NULL");
|
||||
|
||||
// Did the shader or material data change?
|
||||
if(shader != SPRITEBATCH.shader) {
|
||||
@@ -76,7 +76,8 @@ errorret_t spriteBatchBuffer(
|
||||
|
||||
// Buffer to the mesh vertices.
|
||||
spriteBatchBufferToMesh(
|
||||
sprites + (count - remaining), batchCount, v, batchCount * QUAD_VERTEX_COUNT
|
||||
sprites + (count - remaining), batchCount, v,
|
||||
batchCount * QUAD_VERTEX_COUNT
|
||||
);
|
||||
SPRITEBATCH.spriteCount += batchCount;
|
||||
remaining -= batchCount;
|
||||
@@ -91,9 +92,9 @@ void spriteBatchBufferToMesh(
|
||||
meshvertex_t *vertices,
|
||||
const uint32_t verticesSize
|
||||
) {
|
||||
assertNotNull(sprites, "Sprites cannot be null");
|
||||
assertNotNull(sprites, "Sprites cannot be NULL");
|
||||
assertTrue(count > 0, "Count must be greater than zero");
|
||||
assertNotNull(vertices, "Vertices cannot be null");
|
||||
assertNotNull(vertices, "Vertices cannot be NULL");
|
||||
assertTrue(
|
||||
verticesSize >= count * QUAD_VERTEX_COUNT, "Vertices array too small"
|
||||
);
|
||||
|
||||
@@ -27,7 +27,7 @@ typedef struct {
|
||||
* @param y Screen y position of the sprite's top-left corner.
|
||||
* @param width Width of the sprite in screen space.
|
||||
* @param height Height of the sprite in screen space.
|
||||
* @returns The populated sprite.
|
||||
* @return The populated sprite.
|
||||
*/
|
||||
spritebatchsprite_t spriteBatchSpriteTilesetPosition(
|
||||
const tileset_t *tileset,
|
||||
|
||||
@@ -82,9 +82,11 @@ const uint8_t FONT_DEFAULT_GLYPHS[FONT_DEFAULT_TILE_COUNT][
|
||||
// Caps Lock's row widths becomes a column height here, centered
|
||||
// vertically). Backslash was never drawn anyway, and isn't a key this
|
||||
// virtual keyboard can type - see FONT_ICON_BACKSPACE.
|
||||
{ 0x00, 0x00, 0x08, 0x1F, 0x3F, 0x3F, 0x1F, 0x08, 0x00, 0x00 }, // FONT_ICON_BACKSPACE
|
||||
// FONT_ICON_BACKSPACE
|
||||
{ 0x00, 0x00, 0x08, 0x1F, 0x3F, 0x3F, 0x1F, 0x08, 0x00, 0x00 },
|
||||
{ 0x00, 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x18, 0x00, 0x00 }, // ]
|
||||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // ^ (not drawn in source font)
|
||||
// ^ (not drawn in source font)
|
||||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
|
||||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E }, // _
|
||||
// Custom icon glyph, not a real backtick - an up arrow for Shift, same
|
||||
// head as Caps Lock's (see FONT_ICON_CAPSLOCK) but with a shaft 2px
|
||||
@@ -92,7 +94,8 @@ const uint8_t FONT_DEFAULT_GLYPHS[FONT_DEFAULT_TILE_COUNT][
|
||||
// lighter/broken version of Caps Lock's thicker uninterrupted one.
|
||||
// Backtick was never drawn anyway, and isn't a key this virtual
|
||||
// keyboard can type - see FONT_ICON_SHIFT.
|
||||
{ 0x0C, 0x1E, 0x3F, 0x0C, 0x0C, 0x0C, 0x0C, 0x00, 0x0C, 0x00 }, // FONT_ICON_SHIFT
|
||||
// FONT_ICON_SHIFT
|
||||
{ 0x0C, 0x1E, 0x3F, 0x0C, 0x0C, 0x0C, 0x0C, 0x00, 0x0C, 0x00 },
|
||||
{ 0x00, 0x00, 0x00, 0x1E, 0x22, 0x22, 0x22, 0x1E, 0x00, 0x00 }, // a
|
||||
{ 0x00, 0x20, 0x20, 0x3C, 0x22, 0x22, 0x22, 0x3C, 0x00, 0x00 }, // b
|
||||
{ 0x00, 0x00, 0x00, 0x1C, 0x22, 0x20, 0x22, 0x1C, 0x00, 0x00 }, // c
|
||||
@@ -125,21 +128,25 @@ const uint8_t FONT_DEFAULT_GLYPHS[FONT_DEFAULT_TILE_COUNT][
|
||||
// hooks left into a leftward-pointing arrowhead, i.e. "<-|" rotated
|
||||
// into an L. Pipe was never drawn anyway, and isn't a key this
|
||||
// virtual keyboard can type - see FONT_ICON_NEWLINE.
|
||||
{ 0x02, 0x02, 0x02, 0x02, 0x0E, 0x1E, 0x08, 0x00, 0x00, 0x00 }, // FONT_ICON_NEWLINE
|
||||
// FONT_ICON_NEWLINE
|
||||
{ 0x02, 0x02, 0x02, 0x02, 0x0E, 0x1E, 0x08, 0x00, 0x00, 0x00 },
|
||||
{ 0x00, 0x10, 0x08, 0x08, 0x04, 0x08, 0x08, 0x10, 0x00, 0x00 }, // }
|
||||
// Custom icon glyph, not a real tilde - a spacebar symbol for the
|
||||
// keyboard's space key: an underscore with a tick at each end, like
|
||||
// "|___|". Tilde was never drawn anyway, and was explicitly dropped
|
||||
// from this virtual keyboard's own key set - see FONT_ICON_SPACE.
|
||||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x3F }, // FONT_ICON_SPACE
|
||||
// FONT_ICON_SPACE
|
||||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x3F },
|
||||
// Custom icon glyph, not a real ASCII character - a thick, solid,
|
||||
// uninterrupted up arrow for Caps Lock (contrast FONT_ICON_SHIFT's
|
||||
// same head but a thinner, gapped shaft). Assigned to char code 127
|
||||
// (DEL) since that codepoint is never legitimately typed text and
|
||||
// (unlike 128+) is still a positive value regardless of whether this
|
||||
// platform's plain `char` is signed - see FONT_ICON_CAPSLOCK.
|
||||
{ 0x0C, 0x1E, 0x3F, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x00 }, // FONT_ICON_CAPSLOCK
|
||||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // unused trailing tile
|
||||
// FONT_ICON_CAPSLOCK
|
||||
{ 0x0C, 0x1E, 0x3F, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x00 },
|
||||
// unused trailing tile
|
||||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
|
||||
};
|
||||
|
||||
errorret_t fontDefaultInit(void) {
|
||||
@@ -155,7 +162,8 @@ errorret_t fontDefaultInit(void) {
|
||||
|
||||
for(uint16_t i = 0; i < FONT_DEFAULT_TILE_COUNT; i++) {
|
||||
const uint16_t tileX = (i % FONT_DEFAULT_COLUMNS) * FONT_DEFAULT_TILE_WIDTH;
|
||||
const uint16_t tileY = (i / FONT_DEFAULT_COLUMNS) * FONT_DEFAULT_TILE_HEIGHT;
|
||||
const uint16_t tileY =
|
||||
(i / FONT_DEFAULT_COLUMNS) * FONT_DEFAULT_TILE_HEIGHT;
|
||||
|
||||
for(uint8_t row = 0; row < FONT_DEFAULT_TILE_HEIGHT; row++) {
|
||||
const uint8_t bits = FONT_DEFAULT_GLYPHS[i][row];
|
||||
@@ -172,8 +180,10 @@ errorret_t fontDefaultInit(void) {
|
||||
FONT_DEFAULT_TILESET.columns = FONT_DEFAULT_COLUMNS;
|
||||
FONT_DEFAULT_TILESET.rows = FONT_DEFAULT_ROWS;
|
||||
FONT_DEFAULT_TILESET.tileCount = FONT_DEFAULT_TILE_COUNT;
|
||||
FONT_DEFAULT_TILESET.uv[0] = (float_t)FONT_DEFAULT_TILE_WIDTH / (float_t)width;
|
||||
FONT_DEFAULT_TILESET.uv[1] = (float_t)FONT_DEFAULT_TILE_HEIGHT / (float_t)height;
|
||||
FONT_DEFAULT_TILESET.uv[0] =
|
||||
(float_t)FONT_DEFAULT_TILE_WIDTH / (float_t)width;
|
||||
FONT_DEFAULT_TILESET.uv[1] =
|
||||
(float_t)FONT_DEFAULT_TILE_HEIGHT / (float_t)height;
|
||||
|
||||
const texturedata_t data = { .rgbaColors = pixels };
|
||||
errorret_t textureResult = textureInit(
|
||||
|
||||
@@ -21,7 +21,9 @@
|
||||
#endif
|
||||
#include "system/system.h"
|
||||
#include "console/console.h"
|
||||
#include "save/save.h"\
|
||||
#include "save/save.h"
|
||||
#include "audio/audio.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
|
||||
engine_t ENGINE;
|
||||
|
||||
@@ -42,6 +44,7 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
|
||||
errorChain(saveInit());
|
||||
errorChain(localeManagerInit());
|
||||
errorChain(displayInit());
|
||||
errorChain(audioInit());
|
||||
errorChain(uiInit());
|
||||
errorChain(rpgInit());
|
||||
#ifdef DUSK_NETWORK
|
||||
@@ -71,6 +74,7 @@ errorret_t engineUpdate(void) {
|
||||
timeUpdate();
|
||||
inputUpdate();
|
||||
consoleUpdate();
|
||||
errorChain(audioUpdateEarly());
|
||||
errorChain(rpgUpdate());
|
||||
errorChain(sceneUpdate());
|
||||
errorChain(assetUpdate());
|
||||
@@ -78,6 +82,7 @@ errorret_t engineUpdate(void) {
|
||||
|
||||
// Render
|
||||
errorChain(displayUpdate());
|
||||
errorChain(audioUpdateLate());
|
||||
if(inputPressed(INPUT_ACTION_RAGEQUIT)) ENGINE.running = false;
|
||||
errorOk();
|
||||
}
|
||||
@@ -94,6 +99,7 @@ errorret_t engineDispose(void) {
|
||||
errorChain(rpgDispose());
|
||||
localeManagerDispose();
|
||||
errorChain(uiDispose());
|
||||
errorChain(audioDispose());
|
||||
consoleDispose();
|
||||
errorChain(displayDispose());
|
||||
errorChain(saveDispose());
|
||||
|
||||
@@ -152,7 +152,7 @@ float_t inputGetLastValue(const inputaction_t action) {
|
||||
const inputaction_t negY, const inputaction_t posY,
|
||||
vec2 result
|
||||
) {
|
||||
assertNotNull(result, "Result vector cannot be null");
|
||||
assertNotNull(result, "Result vector cannot be NULL");
|
||||
result[0] = inputAxisDynamic(negX, posX);
|
||||
result[1] = inputAxisDynamic(negY, posY);
|
||||
}
|
||||
@@ -162,7 +162,7 @@ float_t inputGetLastValue(const inputaction_t action) {
|
||||
const inputaction_t negY, const inputaction_t posY,
|
||||
vec2 result
|
||||
) {
|
||||
assertNotNull(result, "Result vector cannot be null");
|
||||
assertNotNull(result, "Result vector cannot be NULL");
|
||||
float_t x = inputAxisDynamic(negX, posX);
|
||||
float_t y = inputAxisDynamic(negY, posY);
|
||||
float_t mag = sqrtf(x * x + y * y);
|
||||
@@ -208,7 +208,7 @@ void inputAxis2D(
|
||||
const inputaction_t negY, const inputaction_t posY,
|
||||
vec2 result
|
||||
) {
|
||||
assertNotNull(result, "Result vector cannot be null");
|
||||
assertNotNull(result, "Result vector cannot be NULL");
|
||||
result[0] = inputAxis(negX, posX);
|
||||
result[1] = inputAxis(negY, posY);
|
||||
}
|
||||
@@ -218,7 +218,7 @@ void inputAngle2D(
|
||||
const inputaction_t negY, const inputaction_t posY,
|
||||
vec2 result
|
||||
) {
|
||||
assertNotNull(result, "Result vector cannot be null");
|
||||
assertNotNull(result, "Result vector cannot be NULL");
|
||||
float_t x = inputAxis(negX, posX);
|
||||
float_t y = inputAxis(negY, posY);
|
||||
float_t mag = sqrtf(x * x + y * y);
|
||||
|
||||
@@ -34,13 +34,43 @@ errorret_t localeManagerInit();
|
||||
errorret_t localeManagerSetLocale(const localeinfo_t *locale);
|
||||
|
||||
/**
|
||||
* Get a localized string for the given message ID.
|
||||
*
|
||||
* Get a localized string for the given message ID verbatim, with no
|
||||
* printf-style formatting applied - use this (rather than
|
||||
* localeManagerGetText with no variadic args) whenever the raw string
|
||||
* is displayed as-is, or cached to be formatted later (e.g. a
|
||||
* "_format" message ID whose %-specifiers are filled in by the caller
|
||||
* itself via stringFormat once the actual values are known). Passing a
|
||||
* "_format" string through localeManagerGetText/GetTextArgs instead
|
||||
* would consume it immediately as a format string with zero args,
|
||||
* which is wrong for this use, and would also mishandle any literal
|
||||
* '%' in a plain display string.
|
||||
*
|
||||
* @param id The message ID to retrieve.
|
||||
* @param buffer Buffer to write the retrieved string to.
|
||||
* @param bufferSize Size of the buffer.
|
||||
* @param plural Plural index to retrieve.
|
||||
* @param ... Additional arguments for formatting the string.
|
||||
* @return An error code if a failure occurs.
|
||||
*/
|
||||
#define localeManagerGetString(id, buffer, bufferSize, plural) \
|
||||
assetLocaleGetString( \
|
||||
&LOCALE.entry->data.locale, \
|
||||
id, \
|
||||
plural, \
|
||||
buffer, \
|
||||
bufferSize \
|
||||
)
|
||||
|
||||
/**
|
||||
* Get a localized string for the given message ID, formatted
|
||||
* printf-style with the given variadic arguments.
|
||||
*
|
||||
* @param id The message ID to retrieve.
|
||||
* @param buffer Buffer to write the retrieved string to.
|
||||
* @param bufferSize Size of the buffer.
|
||||
* @param plural Plural index to retrieve.
|
||||
* @param ... Arguments for formatting the string - must not be empty,
|
||||
* since the retrieved string is always run through vsnprintf; see
|
||||
* localeManagerGetString for a message ID with no format args at all.
|
||||
* @return An error code if a failure occurs.
|
||||
*/
|
||||
#define localeManagerGetText(id, buffer, bufferSize, plural, ...) \
|
||||
|
||||
@@ -214,7 +214,9 @@ void battleMoveTeamFirst(const battlefighterteam_t team) {
|
||||
sorted[count++] = BATTLE.executionOrder[i];
|
||||
}
|
||||
|
||||
memoryCopy(BATTLE.executionOrder, sorted, sizeof(uint8_t) * BATTLE.executionCount);
|
||||
memoryCopy(
|
||||
BATTLE.executionOrder, sorted, sizeof(uint8_t) * BATTLE.executionCount
|
||||
);
|
||||
}
|
||||
|
||||
battlefighter_t *battleAIChooseTarget(const battlefighter_t *fighter) {
|
||||
|
||||
@@ -82,6 +82,6 @@ void battleFighterInit(
|
||||
* is not dead).
|
||||
*
|
||||
* @param fighter Pointer to the fighter to check.
|
||||
* @returns True if the fighter can act.
|
||||
* @return True if the fighter can act.
|
||||
*/
|
||||
bool_t battleFighterIsAlive(const battlefighter_t *fighter);
|
||||
@@ -65,6 +65,17 @@ typedef struct cutscene_s {
|
||||
#define CUTSCENE_RESTART() \
|
||||
{ .type = CUTSCENE_ITEM_TYPE_RESTART }
|
||||
|
||||
// Blocks the cutscene here indefinitely - it never completes on its own,
|
||||
// only cutsceneGoTo (called externally, e.g. from a UI callback) can move
|
||||
// execution past it.
|
||||
#define CUTSCENE_IDLE() \
|
||||
{ .type = CUTSCENE_ITEM_TYPE_IDLE }
|
||||
|
||||
// Opens a full-screen UI panel (e.g. the main menu) declaratively, then
|
||||
// immediately continues on to whatever follows this item.
|
||||
#define CUTSCENE_UI_SHOW(SCREEN) \
|
||||
{ .type = CUTSCENE_ITEM_TYPE_UI_SHOW, .uiShow = { .screen = SCREEN } }
|
||||
|
||||
// Requests a switch to a different SCENE_TYPE via sceneSet, then
|
||||
// immediately continues on to whatever follows this item - the switch
|
||||
// itself doesn't happen until the next sceneUpdate() tick, so it does
|
||||
@@ -389,3 +400,114 @@ typedef struct cutscene_s {
|
||||
), \
|
||||
CUTSCENE_MAP_AREA_WAIT(CUTSCENE_AREA_LAST_CREATED), \
|
||||
CUTSCENE_MAP_AREA_REMOVE(CUTSCENE_AREA_LAST_CREATED)
|
||||
|
||||
// Longhand - every audioMixerQueuePlay() parameter. See
|
||||
// CUTSCENE_AUDIO_PLAY_SIMPLE/CUTSCENE_AUDIO_PLAY_LOOPED below for the
|
||||
// shorthands.
|
||||
#define CUTSCENE_AUDIO_PLAY( \
|
||||
FILE, CHANNEL, VOLUME, PAN, LOOPING, LOOP_COUNT, LOOP_START, LOOP_TO \
|
||||
) \
|
||||
{ \
|
||||
.type = CUTSCENE_ITEM_TYPE_AUDIO_PLAY, \
|
||||
.audioPlay = { \
|
||||
.file = FILE, \
|
||||
.channel = CHANNEL, \
|
||||
.volume = VOLUME, \
|
||||
.pan = PAN, \
|
||||
.looping = LOOPING, \
|
||||
.loopCount = LOOP_COUNT, \
|
||||
.loopStart = LOOP_START, \
|
||||
.loopTo = LOOP_TO \
|
||||
} \
|
||||
}
|
||||
|
||||
// Shorthand: play FILE on CHANNEL once, full volume, centered (0.0f, same
|
||||
// as AUDIO_STREAM_CENTER), no loop.
|
||||
#define CUTSCENE_AUDIO_PLAY_SIMPLE(FILE, CHANNEL) \
|
||||
CUTSCENE_AUDIO_PLAY(FILE, CHANNEL, 1.0f, 0.0f, false, 0, -1.0f, 0.0f)
|
||||
|
||||
// Shorthand: play FILE on CHANNEL looping the whole clip forever, full
|
||||
// volume, centered (0.0f, same as AUDIO_STREAM_CENTER).
|
||||
#define CUTSCENE_AUDIO_PLAY_LOOPED(FILE, CHANNEL) \
|
||||
CUTSCENE_AUDIO_PLAY(FILE, CHANNEL, 1.0f, 0.0f, true, 0, -1.0f, 0.0f)
|
||||
|
||||
#define CUTSCENE_AUDIO_STOP(CHANNEL) \
|
||||
{ .type = CUTSCENE_ITEM_TYPE_AUDIO_STOP, .audioStopChannel = CHANNEL }
|
||||
|
||||
#define CUTSCENE_AUDIO_PAUSE(CHANNEL) \
|
||||
{ .type = CUTSCENE_ITEM_TYPE_AUDIO_PAUSE, .audioPauseChannel = CHANNEL }
|
||||
|
||||
#define CUTSCENE_AUDIO_RESUME(CHANNEL) \
|
||||
{ .type = CUTSCENE_ITEM_TYPE_AUDIO_RESUME, .audioResumeChannel = CHANNEL }
|
||||
|
||||
// Longhand - starts CHANNEL fading from FROM to TO over DURATION seconds,
|
||||
// eased by EASING. Doesn't wait for it - pair with
|
||||
// CUTSCENE_AUDIO_FADE_WAIT(CHANNEL) to block until it finishes. See
|
||||
// CUTSCENE_AUDIO_FADE_OUT/CUTSCENE_AUDIO_FADE_IN below for the shorthands;
|
||||
// use this directly for a custom range, e.g.
|
||||
// CUTSCENE_AUDIO_FADE(CHANNEL, 1.0f, 0.3f, 5.0f, EASING_LINEAR) to fade
|
||||
// down to "playing quietly" rather than silent.
|
||||
#define CUTSCENE_AUDIO_FADE(CHANNEL, FROM, TO, DURATION, EASING) \
|
||||
{ \
|
||||
.type = CUTSCENE_ITEM_TYPE_AUDIO_FADE, \
|
||||
.audioFade = { \
|
||||
.channel = CHANNEL, \
|
||||
.from = FROM, \
|
||||
.to = TO, \
|
||||
.duration = DURATION, \
|
||||
.easing = EASING \
|
||||
} \
|
||||
}
|
||||
|
||||
// Shorthand: fade CHANNEL from full volume to silent over DURATION seconds.
|
||||
#define CUTSCENE_AUDIO_FADE_OUT(CHANNEL, DURATION) \
|
||||
CUTSCENE_AUDIO_FADE(CHANNEL, 1.0f, 0.0f, DURATION, EASING_LINEAR)
|
||||
|
||||
// Shorthand: fade CHANNEL from silent to full volume over DURATION seconds.
|
||||
#define CUTSCENE_AUDIO_FADE_IN(CHANNEL, DURATION) \
|
||||
CUTSCENE_AUDIO_FADE(CHANNEL, 0.0f, 1.0f, DURATION, EASING_LINEAR)
|
||||
|
||||
// Waits until CHANNEL's fade (started elsewhere by CUTSCENE_AUDIO_FADE)
|
||||
// has finished - a no-op wait if CHANNEL isn't fading.
|
||||
#define CUTSCENE_AUDIO_FADE_WAIT(CHANNEL) \
|
||||
{ \
|
||||
.type = CUTSCENE_ITEM_TYPE_AUDIO_FADE_WAIT, \
|
||||
.audioFadeWaitChannel = CHANNEL \
|
||||
}
|
||||
|
||||
#define CUTSCENE_AUDIO_SET_PAN(CHANNEL, PAN) \
|
||||
{ \
|
||||
.type = CUTSCENE_ITEM_TYPE_AUDIO_SET_PAN, \
|
||||
.audioSetPan = { .channel = CHANNEL, .pan = PAN } \
|
||||
}
|
||||
|
||||
#define CUTSCENE_AUDIO_SET_LOOP( \
|
||||
CHANNEL, LOOPING, LOOP_COUNT, LOOP_START, LOOP_TO \
|
||||
) \
|
||||
{ \
|
||||
.type = CUTSCENE_ITEM_TYPE_AUDIO_SET_LOOP, \
|
||||
.audioSetLoop = { \
|
||||
.channel = CHANNEL, \
|
||||
.looping = LOOPING, \
|
||||
.loopCount = LOOP_COUNT, \
|
||||
.loopStart = LOOP_START, \
|
||||
.loopTo = LOOP_TO \
|
||||
} \
|
||||
}
|
||||
|
||||
// Combined form of CUTSCENE_AUDIO_SET_PAN + CUTSCENE_AUDIO_SET_LOOP, for
|
||||
// setting both at once rather than as two separate items.
|
||||
#define CUTSCENE_AUDIO_SET( \
|
||||
CHANNEL, PAN, LOOPING, LOOP_COUNT, LOOP_START, LOOP_TO \
|
||||
) \
|
||||
{ \
|
||||
.type = CUTSCENE_ITEM_TYPE_AUDIO_SET, \
|
||||
.audioSet = { \
|
||||
.channel = CHANNEL, \
|
||||
.pan = PAN, \
|
||||
.looping = LOOPING, \
|
||||
.loopCount = LOOP_COUNT, \
|
||||
.loopStart = LOOP_START, \
|
||||
.loopTo = LOOP_TO \
|
||||
} \
|
||||
}
|
||||
@@ -10,6 +10,8 @@
|
||||
#include "util/memory.h"
|
||||
#include "util/string.h"
|
||||
#include "assert/assert.h"
|
||||
#include "asset/asset.h"
|
||||
#include "ui/overlay/uifatalerror.h"
|
||||
|
||||
cutscenesystem_t CUTSCENE_SYSTEM;
|
||||
|
||||
@@ -61,6 +63,21 @@ void cutsceneSystemStartCutsceneAndGoToMarker(
|
||||
cutsceneGoTo(marker);
|
||||
}
|
||||
|
||||
void cutsceneSystemLoad(const char_t *file) {
|
||||
char_t path[ASSET_FILE_NAME_MAX];
|
||||
stringFormat(path, sizeof(path), "cutscenes/%s", file);
|
||||
|
||||
assetentry_t *entry = assetLock(path, ASSET_LOADER_TYPE_CUTSCENE, NULL);
|
||||
errorret_t result = assetRequireLoaded(entry);
|
||||
if(errorIsNotOk(result)) {
|
||||
errorCatch(errorPrint(result));
|
||||
uiFatalErrorOpen(NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
cutsceneSystemStartCutscene(&entry->data.cutscene.cutscene);
|
||||
}
|
||||
|
||||
void cutsceneRestart(void) {
|
||||
assertNotNull(
|
||||
CUTSCENE_SYSTEM.scene, "cutsceneRestart called with no cutscene running"
|
||||
@@ -119,7 +136,7 @@ void cutsceneSystemNext() {
|
||||
|
||||
// Start item.
|
||||
const cutsceneitem_t *item = cutsceneSystemGetCurrentItem();
|
||||
memset(&CUTSCENE_SYSTEM.data, 0, sizeof(CUTSCENE_SYSTEM.data));
|
||||
memoryZero(&CUTSCENE_SYSTEM.data, sizeof(CUTSCENE_SYSTEM.data));
|
||||
cutsceneItemStart(item, &CUTSCENE_SYSTEM.data);
|
||||
}
|
||||
|
||||
|
||||
@@ -96,6 +96,22 @@ void cutsceneSystemStartCutsceneAndGoToMarker(
|
||||
const char_t *marker
|
||||
);
|
||||
|
||||
/**
|
||||
* Locks, loads and immediately starts a cutscene asset by file name,
|
||||
* e.g. cutsceneSystemLoad("main_menu.jsonc") loads and starts
|
||||
* assets/cutscenes/main_menu.jsonc - same lock/assetRequireLoaded/start
|
||||
* sequence as sceneInitialInit's INITIAL_CUTSCENE_ENTRY. The entry is
|
||||
* locked forever (never unlocked), same lifetime convention as
|
||||
* LOCALE.entry - it's fine to call this again later for the same file,
|
||||
* it'll just resolve to the same already-loaded entry. Opens the fatal
|
||||
* error overlay (see uiFatalErrorOpen) instead of starting anything if
|
||||
* the asset fails to load.
|
||||
*
|
||||
* @param file Cutscene file name (with .jsonc extension), relative to
|
||||
* assets/cutscenes/.
|
||||
*/
|
||||
void cutsceneSystemLoad(const char_t *file);
|
||||
|
||||
/**
|
||||
* Restarts the currently running cutscene from its first item,
|
||||
* preserving whatever interact/interacted entities triggered it.
|
||||
@@ -130,7 +146,7 @@ void cutsceneSystemSetOnComplete(cutscenecallback_t onComplete);
|
||||
* Asserts the resolved entity is within bounds.
|
||||
*
|
||||
* @param entityIndex Raw entity index or sentinel value.
|
||||
* @returns Pointer to the resolved entity.
|
||||
* @return Pointer to the resolved entity.
|
||||
*/
|
||||
entity_t * cutsceneSystemGetEntity(const uint8_t entityIndex);
|
||||
|
||||
@@ -139,7 +155,7 @@ entity_t * cutsceneSystemGetEntity(const uint8_t entityIndex);
|
||||
* a concrete map area ID.
|
||||
*
|
||||
* @param areaId Raw map area ID or sentinel value.
|
||||
* @returns The resolved map area ID.
|
||||
* @return The resolved map area ID.
|
||||
*/
|
||||
uint8_t cutsceneSystemGetAreaId(const uint8_t areaId);
|
||||
|
||||
@@ -148,7 +164,7 @@ uint8_t cutsceneSystemGetAreaId(const uint8_t areaId);
|
||||
* sentinel) to a concrete UI_TEXTBOX_MINI_LIST slot index.
|
||||
*
|
||||
* @param index Raw slot index or sentinel value.
|
||||
* @returns The resolved slot index.
|
||||
* @return The resolved slot index.
|
||||
*/
|
||||
uint8_t cutsceneSystemGetTextMiniId(const uint8_t index);
|
||||
|
||||
@@ -158,7 +174,7 @@ uint8_t cutsceneSystemGetTextMiniId(const uint8_t index);
|
||||
* once its keyboard closes). Empty ("") if nothing has been cached yet
|
||||
* for the running cutscene.
|
||||
*
|
||||
* @returns The cached text.
|
||||
* @return The cached text.
|
||||
*/
|
||||
const char_t * cutsceneSystemGetTextCache(void);
|
||||
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
cutsceneitem.c
|
||||
cutsceneitembase.c
|
||||
cutscenecallback.c
|
||||
cutsceneprint.c
|
||||
)
|
||||
@@ -17,3 +18,5 @@ add_subdirectory(maparea)
|
||||
add_subdirectory(ui)
|
||||
add_subdirectory(battle)
|
||||
add_subdirectory(save)
|
||||
add_subdirectory(audio)
|
||||
add_subdirectory(json)
|
||||
@@ -0,0 +1,17 @@
|
||||
# Copyright (c) 2026 Dominic Masters
|
||||
#
|
||||
# This software is released under the MIT License.
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
target_sources(${DUSK_LIBRARY_TARGET_NAME}
|
||||
PUBLIC
|
||||
cutsceneaudioplay.c
|
||||
cutsceneaudiostop.c
|
||||
cutsceneaudiopause.c
|
||||
cutsceneaudioresume.c
|
||||
cutsceneaudiofade.c
|
||||
cutsceneaudiofadewait.c
|
||||
cutsceneaudiosetpan.c
|
||||
cutsceneaudiosetloop.c
|
||||
cutsceneaudioset.c
|
||||
)
|
||||
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonaudiochannel.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsoneasing.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonfield.h"
|
||||
|
||||
void cutsceneAudioFadeStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
audioMixerFadeTo(
|
||||
item->audioFade.channel,
|
||||
item->audioFade.from,
|
||||
item->audioFade.to,
|
||||
item->audioFade.duration,
|
||||
item->audioFade.easing
|
||||
);
|
||||
}
|
||||
|
||||
bool_t cutsceneAudioFadeUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
errorret_t cutsceneAudioFadeLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
) {
|
||||
audiomixerchannel_t channelValue;
|
||||
if(!cutsceneJsonLookupAudioChannel(
|
||||
yyjson_get_str(yyjson_obj_get(itemObj, "channel")), &channelValue
|
||||
)) {
|
||||
errorThrow("Cutscene item (AUDIO_FADE): invalid 'channel'");
|
||||
}
|
||||
item->audioFade.channel = channelValue;
|
||||
item->audioFade.from = cutsceneJsonGetFloat(itemObj, "from", 0.0f);
|
||||
item->audioFade.to = cutsceneJsonGetFloat(itemObj, "to", 0.0f);
|
||||
item->audioFade.duration = cutsceneJsonGetFloat(itemObj, "duration", 0.0f);
|
||||
|
||||
const char_t *easingName =
|
||||
yyjson_get_str(yyjson_obj_get(itemObj, "easing"));
|
||||
easingtype_t easingValue = EASING_LINEAR;
|
||||
if(easingName != NULL &&
|
||||
!cutsceneJsonLookupEasing(easingName, &easingValue)) {
|
||||
errorThrow("Cutscene item (AUDIO_FADE): invalid 'easing'");
|
||||
}
|
||||
item->audioFade.easing = easingValue;
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/mixer/audiomixerchannel.h"
|
||||
#include "animation/easing.h"
|
||||
#include "rpg/cutscene/item/cutsceneitembase.h"
|
||||
|
||||
typedef struct {
|
||||
audiomixerchannel_t channel;
|
||||
float_t from;
|
||||
float_t to;
|
||||
float_t duration;
|
||||
easingtype_t easing;
|
||||
} cutsceneaudiofade_t;
|
||||
|
||||
/**
|
||||
* Starts an audio fade step (starts the fade via audioMixerFadeTo() -
|
||||
* doesn't wait for it; pair with CUTSCENE_AUDIO_FADE_WAIT to block on it).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
*/
|
||||
void cutsceneAudioFadeStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Updates an audio fade step (always completes immediately - the fade
|
||||
* itself keeps running independently of cutscene progression).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
* @return true always.
|
||||
*/
|
||||
bool_t cutsceneAudioFadeUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Parses an AUDIO_FADE cutscene item's JSON fields into item.
|
||||
*
|
||||
* @param itemObj The item's JSON object.
|
||||
* @param item Destination item, already zeroed by the caller.
|
||||
* @param pool Unused (AUDIO_FADE needs no pool storage).
|
||||
* @param poolOffset Unused (AUDIO_FADE needs no pool storage).
|
||||
* @return Error code indicating success or failure of the parse.
|
||||
*/
|
||||
errorret_t cutsceneAudioFadeLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
);
|
||||
@@ -0,0 +1,26 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonaudiochannel.h"
|
||||
|
||||
bool_t cutsceneAudioFadeWaitUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
return !audioMixerIsFading(item->audioFadeWaitChannel);
|
||||
}
|
||||
|
||||
errorret_t cutsceneAudioFadeWaitLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
) {
|
||||
return cutsceneJsonLoadAudioChannelOnly(itemObj, &item->audioFadeWaitChannel);
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/mixer/audiomixerchannel.h"
|
||||
#include "rpg/cutscene/item/cutsceneitembase.h"
|
||||
|
||||
/**
|
||||
* Updates an audio fade-wait step, completing once the watched channel's
|
||||
* fade (started by a CUTSCENE_AUDIO_FADE elsewhere) finishes. Has no Start
|
||||
* callback -- there's nothing to do until the fade is actually done.
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
* @return true once the channel is no longer fading.
|
||||
*/
|
||||
bool_t cutsceneAudioFadeWaitUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Parses an AUDIO_FADE_WAIT cutscene item's JSON fields into item.
|
||||
*
|
||||
* @param itemObj The item's JSON object.
|
||||
* @param item Destination item, already zeroed by the caller.
|
||||
* @param pool Unused (AUDIO_FADE_WAIT needs no pool storage).
|
||||
* @param poolOffset Unused (AUDIO_FADE_WAIT needs no pool storage).
|
||||
* @return Error code indicating success or failure of the parse.
|
||||
*/
|
||||
errorret_t cutsceneAudioFadeWaitLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
);
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonaudiochannel.h"
|
||||
|
||||
void cutsceneAudioPauseStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
audioMixerPause(item->audioPauseChannel);
|
||||
}
|
||||
|
||||
bool_t cutsceneAudioPauseUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
errorret_t cutsceneAudioPauseLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
) {
|
||||
return cutsceneJsonLoadAudioChannelOnly(itemObj, &item->audioPauseChannel);
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/mixer/audiomixerchannel.h"
|
||||
#include "rpg/cutscene/item/cutsceneitembase.h"
|
||||
|
||||
/**
|
||||
* Starts an audio pause step (pauses the channel immediately).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
*/
|
||||
void cutsceneAudioPauseStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Updates an audio pause step (always completes immediately).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
* @return true always.
|
||||
*/
|
||||
bool_t cutsceneAudioPauseUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Parses an AUDIO_PAUSE cutscene item's JSON fields into item.
|
||||
*
|
||||
* @param itemObj The item's JSON object.
|
||||
* @param item Destination item, already zeroed by the caller.
|
||||
* @param pool Unused (AUDIO_PAUSE needs no pool storage).
|
||||
* @param poolOffset Unused (AUDIO_PAUSE needs no pool storage).
|
||||
* @return Error code indicating success or failure of the parse.
|
||||
*/
|
||||
errorret_t cutsceneAudioPauseLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
);
|
||||
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonaudiochannel.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonfield.h"
|
||||
|
||||
void cutsceneAudioPlayStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
audioMixerQueuePlay(
|
||||
item->audioPlay.file,
|
||||
item->audioPlay.channel,
|
||||
item->audioPlay.volume,
|
||||
item->audioPlay.pan,
|
||||
item->audioPlay.looping,
|
||||
item->audioPlay.loopCount,
|
||||
item->audioPlay.loopStart,
|
||||
item->audioPlay.loopTo
|
||||
);
|
||||
}
|
||||
|
||||
bool_t cutsceneAudioPlayUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
errorret_t cutsceneAudioPlayLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
) {
|
||||
if(!cutsceneJsonCopyString(
|
||||
itemObj, "file", NULL, item->audioPlay.file, AUDIO_PATH_MAX
|
||||
)) {
|
||||
errorThrow("Cutscene item (AUDIO_PLAY): missing/too-long 'file'");
|
||||
}
|
||||
audiomixerchannel_t channelValue;
|
||||
if(!cutsceneJsonLookupAudioChannel(
|
||||
yyjson_get_str(yyjson_obj_get(itemObj, "channel")), &channelValue
|
||||
)) {
|
||||
errorThrow("Cutscene item (AUDIO_PLAY): invalid 'channel'");
|
||||
}
|
||||
item->audioPlay.channel = channelValue;
|
||||
|
||||
item->audioPlay.volume = cutsceneJsonGetFloat(itemObj, "volume", 1.0f);
|
||||
item->audioPlay.pan = cutsceneJsonGetFloat(itemObj, "pan", 0.0f);
|
||||
item->audioPlay.looping = cutsceneJsonGetBool(itemObj, "looping", false);
|
||||
item->audioPlay.loopCount =
|
||||
(uint8_t)cutsceneJsonGetInt(itemObj, "loopCount", 0);
|
||||
item->audioPlay.loopStart =
|
||||
cutsceneJsonGetFloat(itemObj, "loopStart", -1.0f);
|
||||
item->audioPlay.loopTo = cutsceneJsonGetFloat(itemObj, "loopTo", 0.0f);
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "rpg/cutscene/item/cutsceneitembase.h"
|
||||
|
||||
typedef struct {
|
||||
char_t file[AUDIO_PATH_MAX];
|
||||
audiomixerchannel_t channel;
|
||||
float_t volume;
|
||||
float_t pan;
|
||||
bool_t looping;
|
||||
uint8_t loopCount;
|
||||
float_t loopStart;
|
||||
float_t loopTo;
|
||||
} cutsceneaudioplay_t;
|
||||
|
||||
/**
|
||||
* Starts an audio play step (queues the sound via audioMixerQueuePlay() -
|
||||
* see its own comment on when it actually starts).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
*/
|
||||
void cutsceneAudioPlayStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Updates an audio play step (always completes immediately - the sound
|
||||
* keeps loading/playing independently of cutscene progression).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
* @return true always.
|
||||
*/
|
||||
bool_t cutsceneAudioPlayUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Parses an AUDIO_PLAY cutscene item's JSON fields into item.
|
||||
*
|
||||
* @param itemObj The item's JSON object.
|
||||
* @param item Destination item, already zeroed by the caller.
|
||||
* @param pool Unused (AUDIO_PLAY needs no pool storage).
|
||||
* @param poolOffset Unused (AUDIO_PLAY needs no pool storage).
|
||||
* @return Error code indicating success or failure of the parse.
|
||||
*/
|
||||
errorret_t cutsceneAudioPlayLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
);
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonaudiochannel.h"
|
||||
|
||||
void cutsceneAudioResumeStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
audioMixerResume(item->audioResumeChannel);
|
||||
}
|
||||
|
||||
bool_t cutsceneAudioResumeUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
errorret_t cutsceneAudioResumeLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
) {
|
||||
return cutsceneJsonLoadAudioChannelOnly(itemObj, &item->audioResumeChannel);
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/mixer/audiomixerchannel.h"
|
||||
#include "rpg/cutscene/item/cutsceneitembase.h"
|
||||
|
||||
/**
|
||||
* Starts an audio resume step (resumes the channel immediately).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
*/
|
||||
void cutsceneAudioResumeStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Updates an audio resume step (always completes immediately).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
* @return true always.
|
||||
*/
|
||||
bool_t cutsceneAudioResumeUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Parses an AUDIO_RESUME cutscene item's JSON fields into item.
|
||||
*
|
||||
* @param itemObj The item's JSON object.
|
||||
* @param item Destination item, already zeroed by the caller.
|
||||
* @param pool Unused (AUDIO_RESUME needs no pool storage).
|
||||
* @param poolOffset Unused (AUDIO_RESUME needs no pool storage).
|
||||
* @return Error code indicating success or failure of the parse.
|
||||
*/
|
||||
errorret_t cutsceneAudioResumeLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
);
|
||||
@@ -0,0 +1,56 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonaudiochannel.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonfield.h"
|
||||
|
||||
void cutsceneAudioSetStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
audioMixerSetPan(item->audioSet.channel, item->audioSet.pan);
|
||||
audioMixerSetLoop(
|
||||
item->audioSet.channel,
|
||||
item->audioSet.looping,
|
||||
item->audioSet.loopCount,
|
||||
item->audioSet.loopStart,
|
||||
item->audioSet.loopTo
|
||||
);
|
||||
}
|
||||
|
||||
bool_t cutsceneAudioSetUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
errorret_t cutsceneAudioSetLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
) {
|
||||
audiomixerchannel_t channelValue;
|
||||
if(!cutsceneJsonLookupAudioChannel(
|
||||
yyjson_get_str(yyjson_obj_get(itemObj, "channel")), &channelValue
|
||||
)) {
|
||||
errorThrow("Cutscene item (AUDIO_SET): invalid 'channel'");
|
||||
}
|
||||
item->audioSet.channel = channelValue;
|
||||
item->audioSet.pan = cutsceneJsonGetFloat(itemObj, "pan", 0.0f);
|
||||
item->audioSet.looping = cutsceneJsonGetBool(itemObj, "looping", true);
|
||||
item->audioSet.loopCount =
|
||||
(uint8_t)cutsceneJsonGetInt(itemObj, "loopCount", 0);
|
||||
item->audioSet.loopStart =
|
||||
cutsceneJsonGetFloat(itemObj, "loopStart", -1.0f);
|
||||
item->audioSet.loopTo = cutsceneJsonGetFloat(itemObj, "loopTo", 0.0f);
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/mixer/audiomixerchannel.h"
|
||||
#include "rpg/cutscene/item/cutsceneitembase.h"
|
||||
|
||||
typedef struct {
|
||||
audiomixerchannel_t channel;
|
||||
float_t pan;
|
||||
bool_t looping;
|
||||
uint8_t loopCount;
|
||||
float_t loopStart;
|
||||
float_t loopTo;
|
||||
} cutsceneaudioset_t;
|
||||
|
||||
/**
|
||||
* Starts an audio set step - applies pan and looping behaviour together in
|
||||
* one item (via audioMixerSetPan()/audioMixerSetLoop()), for when you want
|
||||
* to change both at once rather than using CUTSCENE_AUDIO_SET_PAN/
|
||||
* CUTSCENE_AUDIO_SET_LOOP separately.
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
*/
|
||||
void cutsceneAudioSetStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Updates an audio set step (always completes immediately).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
* @return true always.
|
||||
*/
|
||||
bool_t cutsceneAudioSetUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Parses an AUDIO_SET cutscene item's JSON fields into item.
|
||||
*
|
||||
* @param itemObj The item's JSON object.
|
||||
* @param item Destination item, already zeroed by the caller.
|
||||
* @param pool Unused (AUDIO_SET needs no pool storage).
|
||||
* @param poolOffset Unused (AUDIO_SET needs no pool storage).
|
||||
* @return Error code indicating success or failure of the parse.
|
||||
*/
|
||||
errorret_t cutsceneAudioSetLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
);
|
||||
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonaudiochannel.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonfield.h"
|
||||
|
||||
void cutsceneAudioSetLoopStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
audioMixerSetLoop(
|
||||
item->audioSetLoop.channel,
|
||||
item->audioSetLoop.looping,
|
||||
item->audioSetLoop.loopCount,
|
||||
item->audioSetLoop.loopStart,
|
||||
item->audioSetLoop.loopTo
|
||||
);
|
||||
}
|
||||
|
||||
bool_t cutsceneAudioSetLoopUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
errorret_t cutsceneAudioSetLoopLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
) {
|
||||
audiomixerchannel_t channelValue;
|
||||
if(!cutsceneJsonLookupAudioChannel(
|
||||
yyjson_get_str(yyjson_obj_get(itemObj, "channel")), &channelValue
|
||||
)) {
|
||||
errorThrow("Cutscene item (AUDIO_SET_LOOP): invalid 'channel'");
|
||||
}
|
||||
item->audioSetLoop.channel = channelValue;
|
||||
item->audioSetLoop.looping = cutsceneJsonGetBool(itemObj, "looping", true);
|
||||
item->audioSetLoop.loopCount =
|
||||
(uint8_t)cutsceneJsonGetInt(itemObj, "loopCount", 0);
|
||||
item->audioSetLoop.loopStart =
|
||||
cutsceneJsonGetFloat(itemObj, "loopStart", -1.0f);
|
||||
item->audioSetLoop.loopTo = cutsceneJsonGetFloat(itemObj, "loopTo", 0.0f);
|
||||
|
||||
errorOk();
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "audio/mixer/audiomixerchannel.h"
|
||||
#include "rpg/cutscene/item/cutsceneitembase.h"
|
||||
|
||||
typedef struct {
|
||||
audiomixerchannel_t channel;
|
||||
bool_t looping;
|
||||
uint8_t loopCount;
|
||||
float_t loopStart;
|
||||
float_t loopTo;
|
||||
} cutsceneaudiosetloop_t;
|
||||
|
||||
/**
|
||||
* Starts an audio set-loop step (applies the new looping behaviour
|
||||
* immediately, via audioMixerSetLoop()).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
*/
|
||||
void cutsceneAudioSetLoopStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Updates an audio set-loop step (always completes immediately).
|
||||
*
|
||||
* @param item The cutscene item.
|
||||
* @param data Runtime data storage.
|
||||
* @return true always.
|
||||
*/
|
||||
bool_t cutsceneAudioSetLoopUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
);
|
||||
|
||||
/**
|
||||
* Parses an AUDIO_SET_LOOP cutscene item's JSON fields into item.
|
||||
*
|
||||
* @param itemObj The item's JSON object.
|
||||
* @param item Destination item, already zeroed by the caller.
|
||||
* @param pool Unused (AUDIO_SET_LOOP needs no pool storage).
|
||||
* @param poolOffset Unused (AUDIO_SET_LOOP needs no pool storage).
|
||||
* @return Error code indicating success or failure of the parse.
|
||||
*/
|
||||
errorret_t cutsceneAudioSetLoopLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
);
|
||||
@@ -0,0 +1,43 @@
|
||||
/**
|
||||
* Copyright (c) 2026 Dominic Masters
|
||||
*
|
||||
* This software is released under the MIT License.
|
||||
* https://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "rpg/cutscene/item/cutsceneitem.h"
|
||||
#include "audio/mixer/audiomixer.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonaudiochannel.h"
|
||||
#include "rpg/cutscene/item/json/cutscenejsonfield.h"
|
||||
|
||||
void cutsceneAudioSetPanStart(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
audioMixerSetPan(item->audioSetPan.channel, item->audioSetPan.pan);
|
||||
}
|
||||
|
||||
bool_t cutsceneAudioSetPanUpdate(
|
||||
const cutsceneitem_t *item,
|
||||
cutsceneitemdata_t *data
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
|
||||
errorret_t cutsceneAudioSetPanLoad(
|
||||
yyjson_val *itemObj,
|
||||
cutsceneitem_t *item,
|
||||
uint8_t *pool,
|
||||
size_t *poolOffset
|
||||
) {
|
||||
audiomixerchannel_t channelValue;
|
||||
if(!cutsceneJsonLookupAudioChannel(
|
||||
yyjson_get_str(yyjson_obj_get(itemObj, "channel")), &channelValue
|
||||
)) {
|
||||
errorThrow("Cutscene item (AUDIO_SET_PAN): invalid 'channel'");
|
||||
}
|
||||
item->audioSetPan.channel = channelValue;
|
||||
item->audioSetPan.pan = cutsceneJsonGetFloat(itemObj, "pan", 0.0f);
|
||||
|
||||
errorOk();
|
||||
}
|
||||
Loaded 100 of 387 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user