4.BIOS is updating Thunderbolt Nvm firmware. Do not shut down or reset the system to prevent system bootup failure. ImageSize : 0x66000 Written so far : 0x64000 bytes Image write finished.
いずれも not shut down or reset the system to prevent system bootup failure. なので触らない事
自動的に再起動する。絶対に電源を切らない
Before making any adjustments in the BIOS, please press F5 to load the factory default settings to ensure smooth operation. If setting up Intel RAID, configure VD options according to the interface type for better compatibility. Now, please press F1 to enter BIOS setup.
// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "AudioManager.generated.h"
class USoundBase;
class UAudioComponent;
/**
* Game-wide audio manager — BGM playlist + volume control.
*
* Access from anywhere:
* UGameInstance* GI = GetGameInstance(); // or GetWorld()->GetGameInstance()
* UAudioManager* AM = GI->GetSubsystem<UAudioManager>();
*
* BGM asset note:
* USoundBase assets used as BGM tracks must have looping DISABLED so that
* OnAudioFinished fires when the track ends and the playlist advances.
*/
UCLASS()
class UE573PETIT25CL_API UAudioManager : public UGameInstanceSubsystem
{
GENERATED_BODY()
public:
// -------------------------------------------------------
// Playlist
// -------------------------------------------------------
/** BGM tracks to play in order (or randomly when bRandomPlayback is true) */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="BGM")
TArray<TObjectPtr<USoundBase>> BGMPlaylist;
/**
* If true, tracks are played in a random order.
* A full cycle (every track plays once) is guaranteed before any track repeats.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="BGM")
bool bRandomPlayback = false;
// -------------------------------------------------------
// Volume (0.0 – 1.0)
// -------------------------------------------------------
/** Overall volume multiplier applied to all audio */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Volume", meta=(ClampMin=0, ClampMax=1))
float MasterVolume = 1.0f;
/** Volume multiplier applied to BGM on top of MasterVolume */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Volume", meta=(ClampMin=0, ClampMax=1))
float BGMVolume = 1.0f;
/** Volume multiplier applied to SE on top of MasterVolume */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Volume", meta=(ClampMin=0, ClampMax=1))
float SEVolume = 1.0f;
public:
// -------------------------------------------------------
// BGM API
// -------------------------------------------------------
/**
* Starts BGM playlist playback.
* @param TrackIndex 0-based index of the first track to play.
* Ignored in random mode — a fresh shuffle is always started.
*/
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void PlayBGM(int32 TrackIndex = 0);
/** Stops BGM playback and destroys the internal audio component */
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void StopBGM();
/** Pauses BGM playback */
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void PauseBGM();
/** Resumes a paused BGM */
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void ResumeBGM();
/** Skips to the next track immediately */
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void SkipTrack();
// -------------------------------------------------------
// Volume API
// -------------------------------------------------------
/** Sets the master volume and immediately applies it to the playing BGM */
UFUNCTION(BlueprintCallable, Category="Audio|Volume")
void SetMasterVolume(float Volume);
/** Sets the BGM volume and immediately applies it to the playing BGM */
UFUNCTION(BlueprintCallable, Category="Audio|Volume")
void SetBGMVolume(float Volume);
/** Sets the SE volume (applied to subsequent PlaySE calls) */
UFUNCTION(BlueprintCallable, Category="Audio|Volume")
void SetSEVolume(float Volume);
// -------------------------------------------------------
// SE API
// -------------------------------------------------------
/** Plays a non-spatialized sound effect at MasterVolume * SEVolume */
UFUNCTION(BlueprintCallable, Category="Audio|SE")
void PlaySE2D(USoundBase* Sound);
/** Plays a spatialized sound effect at the given world location at MasterVolume * SEVolume */
UFUNCTION(BlueprintCallable, Category="Audio|SE", meta=(WorldContext="WorldContextObject"))
void PlaySE3D(USoundBase* Sound, const FVector& Location, UObject* WorldContextObject);
private:
/** Currently active BGM audio component */
UPROPERTY()
TObjectPtr<UAudioComponent> BGMComponent;
/** Index of the track that is currently playing */
int32 CurrentTrackIndex = 0;
/** Remaining track indices for random mode; rebuilt when the list is exhausted */
TArray<int32> ShuffledIndices;
/** Plays the track at the given playlist index */
void PlayTrackAtIndex(int32 Index);
/** Called when the current BGM track finishes — advances to the next track */
UFUNCTION()
void OnBGMFinished();
/** Returns the index of the next track to play */
int32 PickNextTrackIndex();
/** Applies the current MasterVolume * BGMVolume to the active audio component */
void RefreshBGMVolume();
/** Fills ShuffledIndices with a fresh Fisher-Yates permutation of all track indices */
void RebuildShuffledIndices();
};
AudioManager.cpp
// Copyright Epic Games, Inc. All Rights Reserved.
#include "AudioManager.h"
#include "Components/AudioComponent.h"
#include "Kismet/GameplayStatics.h"
#include "Sound/SoundBase.h"
// -------------------------------------------------------
// BGM API
// -------------------------------------------------------
void UAudioManager::PlayBGM(int32 TrackIndex)
{
if (BGMPlaylist.IsEmpty())
{
return;
}
// Stop any currently playing track before starting the playlist
StopBGM();
if (bRandomPlayback)
{
// Start a fresh shuffle so every track plays before any repeats
RebuildShuffledIndices();
PlayTrackAtIndex(ShuffledIndices.Pop(EAllowShrinking::No));
}
else
{
PlayTrackAtIndex(FMath::Clamp(TrackIndex, 0, BGMPlaylist.Num() - 1));
}
}
void UAudioManager::StopBGM()
{
if (BGMComponent)
{
// Remove delegate first so Stop() does not accidentally trigger OnBGMFinished
BGMComponent->OnAudioFinished.RemoveDynamic(this, &UAudioManager::OnBGMFinished);
BGMComponent->Stop();
BGMComponent->DestroyComponent();
BGMComponent = nullptr;
}
}
void UAudioManager::PauseBGM()
{
if (BGMComponent)
{
BGMComponent->SetPaused(true);
}
}
void UAudioManager::ResumeBGM()
{
if (BGMComponent)
{
BGMComponent->SetPaused(false);
}
}
void UAudioManager::SkipTrack()
{
if (BGMPlaylist.IsEmpty())
{
return;
}
PlayTrackAtIndex(PickNextTrackIndex());
}
// -------------------------------------------------------
// Volume API
// -------------------------------------------------------
void UAudioManager::SetMasterVolume(float Volume)
{
MasterVolume = FMath::Clamp(Volume, 0.0f, 1.0f);
RefreshBGMVolume();
}
void UAudioManager::SetBGMVolume(float Volume)
{
BGMVolume = FMath::Clamp(Volume, 0.0f, 1.0f);
RefreshBGMVolume();
}
void UAudioManager::SetSEVolume(float Volume)
{
SEVolume = FMath::Clamp(Volume, 0.0f, 1.0f);
}
// -------------------------------------------------------
// SE API
// -------------------------------------------------------
void UAudioManager::PlaySE2D(USoundBase* Sound)
{
if (!Sound)
{
return;
}
UGameplayStatics::SpawnSound2D(GetGameInstance(), Sound, MasterVolume * SEVolume);
}
void UAudioManager::PlaySE3D(USoundBase* Sound, const FVector& Location, UObject* WorldContextObject)
{
if (!Sound || !WorldContextObject)
{
return;
}
UGameplayStatics::SpawnSoundAtLocation(WorldContextObject, Sound, Location,
FRotator::ZeroRotator, MasterVolume * SEVolume);
}
// -------------------------------------------------------
// Private helpers
// -------------------------------------------------------
void UAudioManager::PlayTrackAtIndex(int32 Index)
{
if (!BGMPlaylist.IsValidIndex(Index) || !BGMPlaylist[Index])
{
return;
}
CurrentTrackIndex = Index;
// Tear down previous component and unsubscribe before spawning a new one
if (BGMComponent)
{
BGMComponent->OnAudioFinished.RemoveDynamic(this, &UAudioManager::OnBGMFinished);
BGMComponent->Stop();
BGMComponent->DestroyComponent();
BGMComponent = nullptr;
}
// Spawn a 2D audio component:
// bPersistAcrossLevelTransition = true — BGM survives level loads
// bAutoDestroy = false — we control the lifetime manually
BGMComponent = UGameplayStatics::SpawnSound2D(
GetGameInstance(),
BGMPlaylist[Index],
MasterVolume * BGMVolume,
1.0f, // PitchMultiplier
0.0f, // StartTime
nullptr,// ConcurrencySettings
true, // bPersistAcrossLevelTransition
false // bAutoDestroy
);
if (BGMComponent)
{
BGMComponent->OnAudioFinished.AddDynamic(this, &UAudioManager::OnBGMFinished);
}
}
void UAudioManager::OnBGMFinished()
{
if (BGMPlaylist.IsEmpty())
{
return;
}
PlayTrackAtIndex(PickNextTrackIndex());
}
int32 UAudioManager::PickNextTrackIndex()
{
if (bRandomPlayback)
{
// Rebuild the shuffle pool when every track has been played once
if (ShuffledIndices.IsEmpty())
{
RebuildShuffledIndices();
}
return ShuffledIndices.Pop(EAllowShrinking::No);
}
// Sequential: wrap around to the beginning after the last track
return (CurrentTrackIndex + 1) % BGMPlaylist.Num();
}
void UAudioManager::RefreshBGMVolume()
{
if (BGMComponent)
{
BGMComponent->SetVolumeMultiplier(MasterVolume * BGMVolume);
}
}
void UAudioManager::RebuildShuffledIndices()
{
const int32 Count = BGMPlaylist.Num();
ShuffledIndices.Reset(Count);
for (int32 i = 0; i < Count; ++i)
{
ShuffledIndices.Add(i);
}
// Fisher-Yates shuffle
for (int32 i = Count - 1; i > 0; --i)
{
const int32 j = FMath::RandRange(0, i);
ShuffledIndices.Swap(i, j);
}
}
