Archive/portal64-still-alive
1
0
Fork 0
mirror of https://github.com/mwpenny/portal64-still-alive.git synced 2024-10-20 10:37:37 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Finish up audio options using the menu builder

Browse source
This commit is contained in:
James Lambert 2023-11-05 08:48:58 -07:00
parent 9ec21b9c1a
commit 00bdc90861
6 changed files with 211 additions and 261 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
Makefile
View file

@ -497,12 +497,12 @@ build/src/decor/decor_object_list.o: build/src/audio/clips.h
## Subtitles
####################
SUBTITLE_LANGUAGES = brazilian \
SUBTITLE_LANGUAGES = english \
brazilian \
bulgarian \
czech \
danish \
german \
english \
spanish \
greek \
french \
@ -523,7 +523,7 @@ SUBTITLE_LANGUAGES = brazilian \
SUBTITLE_SOURCES = $(SUBTITLE_LANGUAGES:%=build/src/audio/subtitles_%.c)
SUBTITLE_OBJECTS = $(SUBTITLE_LANGUAGES:%=build/src/audio/subtitles_%.o)
build/src/audio/subtitles.h build/src/audio/subtitles.c build/subtitles.ld $(SUBTITLE_SOURCES): vpk/Portal/portal/resource/closecaption_english.txt vpk/Portal/hl2/resource/gameui_english.txt tools/level_scripts/subtitle_generate.py
build/src/audio/subtitles.h build/src/audio/subtitles.c build/subtitles.ld $(SUBTITLE_SOURCES): vpk/Portal/portal/resource/closecaption_english.txt vpk/Portal/hl2/resource/gameui_english.txt tools/level_scripts/subtitle_generate.py assets/translations/extra_english.txt
python3 tools/level_scripts/subtitle_generate.py $(SUBTITLE_LANGUAGES)
####################

BIN
assets/translations/extra_english.txt
View file

Binary file not shown.

399
src/menu/audio_options.c
View file

@ -15,93 +15,6 @@
#define GAMEPLAY_HEIGHT 124
#define GAMEPLAY_X ((SCREEN_WD - GAMEPLAY_WIDTH) / 2)
#define SCROLL_TICKS_VOLUME 9
#define SCROLL_INTERVALS_VOLUME (int)maxf((SCROLL_TICKS_VOLUME-1), 1)
#define SCROLL_CHUNK_SIZE_VOLUME (0x10000 / SCROLL_INTERVALS_VOLUME)
#define SCROLL_TICKS_SUBTITLES (int)maxf(NUM_SUBTITLE_LANGUAGES, 1)
#define SCROLL_INTERVALS_SUBTITLES (int)maxf((SCROLL_TICKS_SUBTITLES - 1), 1)
#define SCROLL_CHUNK_SIZE_SUBTITLES (0x10000 / SCROLL_INTERVALS_SUBTITLES)
#define SCROLL_TICKS_LANGUAGE (int)maxf(NUM_AUDIO_LANGUAGES, 1)
#define SCROLL_INTERVALS_LANGUAGE (int)maxf((SCROLL_TICKS_LANGUAGE - 1), 1)
#define SCROLL_CHUNK_SIZE_LANGUAGE (0x10000 / SCROLL_INTERVALS_LANGUAGE)
#define FULL_SCROLL_TIME 2.0f
#define SCROLL_MULTIPLIER (int)(0x10000 * FIXED_DELTA_TIME / (80 * FULL_SCROLL_TIME))
void audioOptionsHandleSlider(short selectedItem, unsigned short* settingValue, float* sliderValue) {
unsigned int chunk_size = 0;
switch (selectedItem) {
default:
case AudioOptionGameVolume:
case AudioOptionMusicVolume:
chunk_size = SCROLL_CHUNK_SIZE_VOLUME;
break;
case AudioOptionSubtitlesLanguage:
chunk_size = SCROLL_CHUNK_SIZE_SUBTITLES;
break;
case AudioOptionAudioLanguage:
chunk_size = SCROLL_CHUNK_SIZE_LANGUAGE;
break;
}
OSContPad* pad = controllersGetControllerData(0);
int newValue = (int)*settingValue + pad->stick_x * SCROLL_MULTIPLIER;
if (controllerGetButtonDown(0, A_BUTTON | R_JPAD)) {
if (newValue >= 0xFFFF && controllerGetButtonDown(0, A_BUTTON)) {
newValue = 0;
} else {
newValue = newValue + chunk_size;
if ((0x10000 - newValue) > 0 && (0x10000 - newValue) < chunk_size && controllerGetButtonDown(0, A_BUTTON))
newValue = 0x10000;
else
newValue = newValue - (newValue % chunk_size);
}
soundPlayerPlay(SOUNDS_BUTTONCLICKRELEASE, 1.0f, 0.5f, NULL, NULL, SoundTypeAll);
}
if (controllerGetButtonDown(0, L_JPAD)) {
newValue = newValue - 1;
newValue = newValue - (newValue % chunk_size);
soundPlayerPlay(SOUNDS_BUTTONCLICKRELEASE, 1.0f, 0.5f, NULL, NULL, SoundTypeAll);
}
if (newValue < 0) {
newValue = 0;
}
if (newValue > 0xFFFF) {
newValue = 0xFFFF;
}
*settingValue = newValue;
*sliderValue = (float)newValue / 0xFFFF;
}
void audioOptionsRenderText(struct AudioOptions* audioOptions) {
audioOptions->subtitlesEnabled.prerenderedText = menuBuildPrerenderedText(
&gDejaVuSansFont,
translationsGet(GAMEUI_SUBTITLESANDSOUNDEFFECTS),
audioOptions->subtitlesEnabled.x + CHECKBOX_SIZE + 6,
audioOptions->subtitlesEnabled.y
);
audioOptions->allSubtitlesEnabled.prerenderedText = menuBuildPrerenderedText(
&gDejaVuSansFont,
"All Captions",
audioOptions->allSubtitlesEnabled.x + CHECKBOX_SIZE + 6,
audioOptions->allSubtitlesEnabled.y
);
audioOptions->subtitlesLanguageText = menuBuildPrerenderedText(&gDejaVuSansFont, "Captions Language: ", GAMEPLAY_X + 8, GAMEPLAY_Y + 88);
audioOptions->subtitlesLanguageDynamicText = menuBuildPrerenderedText(&gDejaVuSansFont, SubtitleLanguages[gSaveData.controls.subtitleLanguage], GAMEPLAY_X + 125, GAMEPLAY_Y + 88);
audioOptions->audioLanguageText = menuBuildPrerenderedText(&gDejaVuSansFont, "Audio Language: ", GAMEPLAY_X + 8, GAMEPLAY_Y + 124);
audioOptions->audioLanguageDynamicText = menuBuildPrerenderedText(&gDejaVuSansFont, AudioLanguages[gSaveData.audio.audioLanguage], GAMEPLAY_X + 125, GAMEPLAY_Y + 124);
}
struct MenuElementParams gAudioMenuParams[] = {
{
.type = MenuElementTypeText,
@ -153,9 +66,120 @@ struct MenuElementParams gAudioMenuParams[] = {
},
.selectionIndex = AudioOptionMusicVolume,
},
{
.type = MenuElementTypeCheckbox,
.x = GAMEPLAY_X + 8,
.y = GAMEPLAY_Y + 48,
.params = {
.checkbox = {
.font = &gDejaVuSansFont,
.messageId = GAMEUI_SUBTITLESANDSOUNDEFFECTS,
},
},
.selectionIndex = AudioOptionSubtitlesEnabled,
},
{
.type = MenuElementTypeCheckbox,
.x = GAMEPLAY_X + 8,
.y = GAMEPLAY_Y + 68,
.params = {
.checkbox = {
.font = &gDejaVuSansFont,
.messageId = AUDIO_ALL_CAPTIONS,
}
},
.selectionIndex = AudioOptionAllSubtitlesEnabled,
},
{
.type = MenuElementTypeSlider,
.x = GAMEPLAY_X + 8,
.y = GAMEPLAY_Y + 104,
.params = {
.slider = {
.width = 232,
.numberOfTicks = NUM_SUBTITLE_LANGUAGES,
.discrete = 1,
},
},
.selectionIndex = AudioOptionSubtitlesLanguage,
},
{
.type = MenuElementTypeText,
.x = GAMEPLAY_X + 8,
.y = GAMEPLAY_Y + 88,
.params = {
.text = {
.font = &gDejaVuSansFont,
.messageId = AUDIO_TEXT_LANGUAGE,
},
},
.selectionIndex = AudioOptionSubtitlesLanguage,
},
{
.type = MenuElementTypeText,
.x = GAMEPLAY_X + 125,
.y = GAMEPLAY_Y + 88,
.params = {
.text = {
.font = &gDejaVuSansFont,
.message = "",
},
},
.selectionIndex = AudioOptionSubtitlesLanguage,
},
{
.type = MenuElementTypeSlider,
.x = GAMEPLAY_X + 8,
.y = GAMEPLAY_Y + 140,
.params = {
.slider = {
.width = 232,
.numberOfTicks = NUM_AUDIO_LANGUAGES,
.discrete = 1,
},
},
.selectionIndex = AudioOptionAudioLanguage,
},
{
.type = MenuElementTypeText,
.x = GAMEPLAY_X + 8,
.y = GAMEPLAY_Y + 124,
.params = {
.text = {
.font = &gDejaVuSansFont,
.messageId = AUDIO_TEXT_LANGUAGE,
},
},
.selectionIndex = AudioOptionAudioLanguage,
},
{
.type = MenuElementTypeText,
.x = GAMEPLAY_X + 125,
.y = GAMEPLAY_Y + 124,
.params = {
.text = {
.font = &gDejaVuSansFont,
.message = "",
},
},
.selectionIndex = AudioOptionAudioLanguage,
},
};
#define AUDIO_VOLUME_VALUE_INDEX 1
#define MUSIC_VOLUME_VALUE_INDEX 3
#define SUBTITLES_CHECKBOX_INDEX 4
#define ALL_SUBTITLES_CHECKBOX_INDEX 5
#define TEXT_LANGUAGE_VALUE_INDEX 6
#define TEXT_LANGUAGE_TEXT_INDEX 8
#define AUDIO_LANGUAGE_VALUE_INDEX 9
#define AUDIO_LANGUAGE_TEXT_INDEX 11
void audioOptionsActoin(void* data, int selection, struct MenuAction* action) {
struct AudioOptions* audioOptions = (struct AudioOptions*)data;
switch (selection) {
case AudioOptionGameVolume:
gSaveData.audio.soundVolume = (int)(0xFFFF * action->state.fSlider.value);
@ -165,10 +189,50 @@ void audioOptionsActoin(void* data, int selection, struct MenuAction* action) {
gSaveData.audio.musicVolume = (int)(0xFFFF * action->state.fSlider.value);
soundPlayerGameVolumeUpdate();
break;
case AudioOptionSubtitlesEnabled:
if (action->state.checkbox.isChecked) {
gSaveData.controls.flags |= ControlSaveSubtitlesEnabled;
gSaveData.controls.flags &= ~ControlSaveAllSubtitlesEnabled;
struct MenuCheckbox* allSubtitles = (struct MenuCheckbox*)audioOptions->menuBuilder.elements[ALL_SUBTITLES_CHECKBOX_INDEX].data;
allSubtitles->checked = 0;
} else {
gSaveData.controls.flags &= ~ControlSaveSubtitlesEnabled;
}
break;
case AudioOptionAllSubtitlesEnabled:
if (action->state.checkbox.isChecked) {
gSaveData.controls.flags |= ControlSaveAllSubtitlesEnabled;
gSaveData.controls.flags &= ~ControlSaveSubtitlesEnabled;
struct MenuCheckbox* subtitles = (struct MenuCheckbox*)audioOptions->menuBuilder.elements[SUBTITLES_CHECKBOX_INDEX].data;
subtitles->checked = 0;
} else {
gSaveData.controls.flags &= ~ControlSaveAllSubtitlesEnabled;
}
break;
case AudioOptionSubtitlesLanguage:
gSaveData.controls.subtitleLanguage = action->state.iSlider.value;
gAudioMenuParams[TEXT_LANGUAGE_TEXT_INDEX].params.text.message = SubtitleLanguages[gSaveData.controls.subtitleLanguage];
translationsReload(gSaveData.controls.subtitleLanguage);
break;
case AudioOptionAudioLanguage:
gSaveData.audio.audioLanguage = action->state.iSlider.value;
audioOptions->menuBuilder.elements[AUDIO_LANGUAGE_TEXT_INDEX].data = menuBuildPrerenderedText(&gDejaVuSansFont, AudioLanguages[gSaveData.audio.audioLanguage], GAMEPLAY_X + 125, GAMEPLAY_Y + 124);
break;
}
}
void audioOptionsInit(struct AudioOptions* audioOptions) {
if (gSaveData.controls.subtitleLanguage < 0 || gSaveData.controls.subtitleLanguage >= NUM_SUBTITLE_LANGUAGES) {
gSaveData.controls.subtitleLanguage = 0;
}
if (gSaveData.audio.audioLanguage < 0 || gSaveData.audio.audioLanguage >= NUM_AUDIO_LANGUAGES) {
gSaveData.audio.audioLanguage = 0;
}
gAudioMenuParams[TEXT_LANGUAGE_TEXT_INDEX].params.text.message = SubtitleLanguages[gSaveData.controls.subtitleLanguage];
gAudioMenuParams[AUDIO_LANGUAGE_TEXT_INDEX].params.text.message = AudioLanguages[gSaveData.audio.audioLanguage];
menuBuilderInit(
&audioOptions->menuBuilder,
gAudioMenuParams,
@ -178,171 +242,24 @@ void audioOptionsInit(struct AudioOptions* audioOptions) {
audioOptions
);
audioOptions->selectedItem = AudioOptionGameVolume;
int temp;
menuBuilderSetFSlider(&audioOptions->menuBuilder.elements[AUDIO_VOLUME_VALUE_INDEX], gSaveData.audio.soundVolume / (float)(0xFFFF));
menuBuilderSetFSlider(&audioOptions->menuBuilder.elements[MUSIC_VOLUME_VALUE_INDEX], gSaveData.audio.musicVolume / (float)(0xFFFF));
audioOptions->subtitlesEnabled = menuBuildCheckbox(&gDejaVuSansFont, translationsGet(GAMEUI_SUBTITLESANDSOUNDEFFECTS), GAMEPLAY_X + 8, GAMEPLAY_Y + 48, 1);
audioOptions->subtitlesEnabled.checked = (gSaveData.controls.flags & ControlSaveSubtitlesEnabled) != 0;
menuBuilderSetCheckbox(&audioOptions->menuBuilder.elements[ALL_SUBTITLES_CHECKBOX_INDEX], (gSaveData.controls.flags & ControlSaveAllSubtitlesEnabled) != 0);
menuBuilderSetCheckbox(&audioOptions->menuBuilder.elements[SUBTITLES_CHECKBOX_INDEX], (gSaveData.controls.flags & ControlSaveSubtitlesEnabled) != 0);
audioOptions->allSubtitlesEnabled = menuBuildCheckbox(&gDejaVuSansFont, "All Captions", GAMEPLAY_X + 8, GAMEPLAY_Y + 68, 1);
audioOptions->allSubtitlesEnabled.checked = (gSaveData.controls.flags & ControlSaveAllSubtitlesEnabled) != 0;
audioOptions->subtitlesLanguage= menuBuildSlider(GAMEPLAY_X + 8, GAMEPLAY_Y + 104, 232, NUM_SUBTITLE_LANGUAGES);
temp = (int)(maxf(NUM_SUBTITLE_LANGUAGES-1, 1));
audioOptions->subtitles_language_temp = (0xFFFF/temp)* gSaveData.controls.subtitleLanguage;
if ((0xFFFF - audioOptions->subtitles_language_temp) > 0 && (0xFFFF - audioOptions->subtitles_language_temp) < (0xFFFF/temp))
audioOptions->subtitles_language_temp = 0xFFFF;
audioOptions->subtitlesLanguage.value = (float)(audioOptions->subtitles_language_temp)/0xFFFF;
audioOptions->audioLanguage= menuBuildSlider(GAMEPLAY_X + 8, GAMEPLAY_Y + 140, 232, NUM_AUDIO_LANGUAGES);
temp = (int)(maxf(NUM_AUDIO_LANGUAGES-1, 1));
audioOptions->audio_language_temp = (int)((0xFFFF/temp) * gSaveData.audio.audioLanguage);
if ((0xFFFF - audioOptions->audio_language_temp) > 0 && (0xFFFF - audioOptions->audio_language_temp) < (0xFFFF/temp))
audioOptions->audio_language_temp = 0xFFFF;
audioOptions->audioLanguage.value = (float)(audioOptions->audio_language_temp)/0xFFFF;
audioOptionsRenderText(audioOptions);
menuBuilderSetISlider(&audioOptions->menuBuilder.elements[TEXT_LANGUAGE_VALUE_INDEX], gSaveData.controls.subtitleLanguage);
menuBuilderSetISlider(&audioOptions->menuBuilder.elements[AUDIO_LANGUAGE_VALUE_INDEX], gSaveData.audio.audioLanguage);
}
void audioOptionsRebuildtext(struct AudioOptions* audioOptions) {
prerenderedTextFree(audioOptions->subtitlesEnabled.prerenderedText);
prerenderedTextFree(audioOptions->allSubtitlesEnabled.prerenderedText);
prerenderedTextFree(audioOptions->subtitlesLanguageText);
prerenderedTextFree(audioOptions->subtitlesLanguageDynamicText);
prerenderedTextFree(audioOptions->audioLanguageText);
prerenderedTextFree(audioOptions->audioLanguageDynamicText);
audioOptionsRenderText(audioOptions);
menuBuilderRebuildText(&audioOptions->menuBuilder);
}
enum MenuDirection audioOptionsUpdate(struct AudioOptions* audioOptions) {
int controllerDir = controllerGetDirectionDown(0);
if (controllerGetButtonDown(0, B_BUTTON)) {
return MenuDirectionUp;
}
if (controllerDir & ControllerDirectionDown) {
++audioOptions->selectedItem;
if (audioOptions->selectedItem == AudioOptionCount) {
audioOptions->selectedItem = 0;
}
soundPlayerPlay(SOUNDS_BUTTONROLLOVER, 1.0f, 0.5f, NULL, NULL, SoundTypeAll);
}
if (controllerDir & ControllerDirectionUp) {
if (audioOptions->selectedItem == 0) {
audioOptions->selectedItem = AudioOptionCount - 1;
} else {
--audioOptions->selectedItem;
}
soundPlayerPlay(SOUNDS_BUTTONROLLOVER, 1.0f, 0.5f, NULL, NULL, SoundTypeAll);
}
switch (audioOptions->selectedItem) {
case AudioOptionSubtitlesEnabled:
if (controllerGetButtonDown(0, A_BUTTON)) {
audioOptions->subtitlesEnabled.checked = !audioOptions->subtitlesEnabled.checked;
soundPlayerPlay(SOUNDS_BUTTONCLICKRELEASE, 1.0f, 0.5f, NULL, NULL, SoundTypeAll);
if (audioOptions->subtitlesEnabled.checked) {
gSaveData.controls.flags |= ControlSaveSubtitlesEnabled;
gSaveData.controls.flags &= ~ControlSaveAllSubtitlesEnabled;
audioOptions->allSubtitlesEnabled.checked = 0;
} else {
gSaveData.controls.flags &= ~ControlSaveSubtitlesEnabled;
}
}
break;
case AudioOptionAllSubtitlesEnabled:
if (controllerGetButtonDown(0, A_BUTTON)) {
audioOptions->allSubtitlesEnabled.checked = !audioOptions->allSubtitlesEnabled.checked;
soundPlayerPlay(SOUNDS_BUTTONCLICKRELEASE, 1.0f, 0.5f, NULL, NULL, SoundTypeAll);
if (audioOptions->allSubtitlesEnabled.checked) {
gSaveData.controls.flags |= ControlSaveAllSubtitlesEnabled;
gSaveData.controls.flags &= ~ControlSaveSubtitlesEnabled;
audioOptions->subtitlesEnabled.checked = 0;
} else {
gSaveData.controls.flags &= ~ControlSaveAllSubtitlesEnabled;
}
}
break;
case AudioOptionSubtitlesLanguage:
audioOptionsHandleSlider(audioOptions->selectedItem, &audioOptions->subtitles_language_temp, &audioOptions->subtitlesLanguage.value);
int temp = (int)((audioOptions->subtitles_language_temp * (1.0f/0xFFFF) * NUM_SUBTITLE_LANGUAGES));
temp = (int)minf(maxf(0.0, temp), NUM_SUBTITLE_LANGUAGES-1);
gSaveData.controls.subtitleLanguage = temp;
translationsReload(temp);
break;
case AudioOptionAudioLanguage:
audioOptionsHandleSlider(audioOptions->selectedItem, &audioOptions->audio_language_temp, &audioOptions->audioLanguage.value);
int tempAudio = (int)((audioOptions->audio_language_temp * (1.0f/0xFFFF) * NUM_AUDIO_LANGUAGES));
tempAudio = (int)minf(maxf(0.0f, tempAudio), NUM_AUDIO_LANGUAGES-1);
gSaveData.audio.audioLanguage = tempAudio;
audioOptions->audioLanguageDynamicText = menuBuildPrerenderedText(&gDejaVuSansFont, AudioLanguages[gSaveData.audio.audioLanguage], GAMEPLAY_X + 125, GAMEPLAY_Y + 124);
break;
}
if (audioOptions->selectedItem == AudioOptionSubtitlesLanguage ||
audioOptions->selectedItem == AudioOptionGameVolume ||
audioOptions->selectedItem == AudioOptionMusicVolume ||
audioOptions->selectedItem == AudioOptionAudioLanguage){
if ((controllerGetButtonDown(0, L_TRIG) || controllerGetButtonDown(0, Z_TRIG))) {
return MenuDirectionLeft;
}
if ((controllerGetButtonDown(0, R_TRIG))) {
return MenuDirectionRight;
}
}
else{
if (controllerDir & ControllerDirectionLeft || controllerGetButtonDown(0, L_TRIG) || controllerGetButtonDown(0, Z_TRIG)) {
return MenuDirectionLeft;
}
if (controllerDir & ControllerDirectionRight || controllerGetButtonDown(0, R_TRIG)) {
return MenuDirectionRight;
}
}
return MenuDirectionStay;
return menuBuilderUpdate(&audioOptions->menuBuilder);
}
void audioOptionsRender(struct AudioOptions* audioOptions, struct RenderState* renderState, struct GraphicsTask* task) {
gSPDisplayList(renderState->dl++, ui_material_list[SOLID_ENV_INDEX]);
gSPDisplayList(renderState->dl++, audioOptions->subtitlesEnabled.outline);
renderState->dl = menuCheckboxRender(&audioOptions->subtitlesEnabled, renderState->dl);
gSPDisplayList(renderState->dl++, audioOptions->allSubtitlesEnabled.outline);
renderState->dl = menuCheckboxRender(&audioOptions->allSubtitlesEnabled, renderState->dl);
gSPDisplayList(renderState->dl++, audioOptions->subtitlesLanguage.back);
renderState->dl = menuSliderRender(&audioOptions->subtitlesLanguage, renderState->dl);
gSPDisplayList(renderState->dl++, audioOptions->audioLanguage.back);
renderState->dl = menuSliderRender(&audioOptions->audioLanguage, renderState->dl);
gSPDisplayList(renderState->dl++, ui_material_revert_list[SOLID_ENV_INDEX]);
struct PrerenderedTextBatch* batch = prerenderedBatchStart();
prerenderedBatchAdd(batch, audioOptions->subtitlesEnabled.prerenderedText, audioOptions->selectedItem == AudioOptionSubtitlesEnabled ? &gSelectionGray : &gColorWhite);
prerenderedBatchAdd(batch, audioOptions->allSubtitlesEnabled.prerenderedText, audioOptions->selectedItem == AudioOptionAllSubtitlesEnabled ? &gSelectionGray : &gColorWhite);
prerenderedBatchAdd(batch, audioOptions->subtitlesLanguageText, audioOptions->selectedItem == AudioOptionSubtitlesLanguage ? &gSelectionGray : &gColorWhite);
prerenderedBatchAdd(batch, audioOptions->subtitlesLanguageDynamicText, audioOptions->selectedItem == AudioOptionSubtitlesLanguage ? &gSelectionGray : &gColorWhite);
prerenderedBatchAdd(batch, audioOptions->audioLanguageText, audioOptions->selectedItem == AudioOptionAudioLanguage ? &gSelectionGray : &gColorWhite);
prerenderedBatchAdd(batch, audioOptions->audioLanguageDynamicText, audioOptions->selectedItem == AudioOptionAudioLanguage ? &gSelectionGray : &gColorWhite);
renderState->dl = prerenderedBatchFinish(batch, gDejaVuSansImages, renderState->dl);
gSPDisplayList(renderState->dl++, ui_material_revert_list[DEJAVU_SANS_0_INDEX]);
menuBuilderRender(&audioOptions->menuBuilder, renderState);
}

12
src/menu/audio_options.h
View file

@ -17,18 +17,6 @@ enum AudioOption {
struct AudioOptions {
struct MenuBuilder menuBuilder;
struct MenuCheckbox subtitlesEnabled;
struct MenuCheckbox allSubtitlesEnabled;
struct MenuSlider subtitlesLanguage;
struct PrerenderedText* subtitlesLanguageText;
struct PrerenderedText* subtitlesLanguageDynamicText;
unsigned short subtitles_language_temp;
struct MenuSlider audioLanguage;
struct PrerenderedText* audioLanguageText;
struct PrerenderedText* audioLanguageDynamicText;
unsigned short audio_language_temp;
short selectedItem;
};
void audioOptionsInit(struct AudioOptions* audioOptions);

50
src/menu/menu_builder.c
View file

@ -12,9 +12,15 @@
#include "../build/src/audio/clips.h"
void textMenuItemInit(struct MenuBuilderElement* element) {
char* message = element->params->params.text.message;
if (!message) {
message = translationsGet(element->params->params.text.messageId);
}
element->data = menuBuildPrerenderedText(
element->params->params.text.font,
translationsGet(element->params->params.text.messageId),
message,
element->params->x,
element->params->y
);
@ -53,6 +59,7 @@ enum MenuDirection checkboxMenuItemUpdate(struct MenuBuilderElement* element, Me
action.type = MenuElementTypeCheckbox;
action.state.checkbox.isChecked = checkbox->checked;
actionCallback(data, element->selectionIndex, &action);
soundPlayerPlay(SOUNDS_BUTTONCLICKRELEASE, 1.0f, 0.5f, NULL, NULL, SoundTypeAll);
}
return MenuDirectionStay;
@ -109,13 +116,13 @@ enum MenuDirection sliderMenuItemUpdate(struct MenuBuilderElement* element, Menu
int controllerDir = controllerGetDirectionDown(0);
int numTicks = element->params->params.slider.numberOfTicks;
int currentValue = (int)floorf(slider->value * numTicks);
int currentValue = (int)floorf(slider->value * (numTicks - 1));
int newValue = currentValue;
if (controllerDir & ControllerDirectionRight) {
++numTicks;
++newValue;
} else if (controllerDir & ControllerDirectionLeft) {
--numTicks;
--newValue;
}
if (newValue < 0) {
@ -132,7 +139,11 @@ enum MenuDirection sliderMenuItemUpdate(struct MenuBuilderElement* element, Menu
slider->value = newValue;
}
slider->value = (float)newValue / (float)numTicks;
if (numTicks > 1) {
slider->value = (float)newValue / (float)(numTicks - 1);
} else {
slider->value = 0.0f;
}
} else {
OSContPad* pad = controllersGetControllerData(0);
float newValue = slider->value + pad->stick_x * SCROLL_MULTIPLIER;
@ -261,3 +272,32 @@ void menuBuilderRender(struct MenuBuilder* menuBuilder, struct RenderState* rend
renderState->dl = prerenderedBatchFinish(batch, gDejaVuSansImages, renderState->dl);
gSPDisplayList(renderState->dl++, ui_material_revert_list[DEJAVU_SANS_0_INDEX]);
}
void menuBuilderSetCheckbox(struct MenuBuilderElement* element, int value) {
if (element->params->type != MenuElementTypeCheckbox) {
return;
}
struct MenuCheckbox* checkbox = (struct MenuCheckbox*)element->data;
checkbox->checked = value;
}
void menuBuilderSetFSlider(struct MenuBuilderElement* element, float value) {
if (element->params->type != MenuElementTypeSlider || element->params->params.slider.discrete) {
return;
}
struct MenuSlider* slider = (struct MenuSlider*)element->data;
slider->value = value;
}
void menuBuilderSetISlider(struct MenuBuilderElement* element, int value) {
if (element->params->type != MenuElementTypeSlider ||
!element->params->params.slider.discrete ||
element->params->params.slider.numberOfTicks <= 1) {
return;
}
struct MenuSlider* slider = (struct MenuSlider*)element->data;
slider->value = (float)value / (float)(element->params->params.slider.numberOfTicks - 1);
}

5
src/menu/menu_builder.h
View file

@ -55,6 +55,7 @@ struct MenuElementParams {
struct {
struct Font* font;
short messageId;
char* message;
} text;
struct {
struct Font* font;
@ -99,4 +100,8 @@ enum MenuDirection menuBuilderUpdate(struct MenuBuilder* menuBuilder);
void menuBuilderRebuildText(struct MenuBuilder* menuBuilder);
void menuBuilderRender(struct MenuBuilder* menuBuilder, struct RenderState* renderState);
void menuBuilderSetCheckbox(struct MenuBuilderElement* element, int value);
void menuBuilderSetFSlider(struct MenuBuilderElement* element, float value);
void menuBuilderSetISlider(struct MenuBuilderElement* element, int value);
#endif