diff --git a/config/SZBE69_B8/objects.json b/config/SZBE69_B8/objects.json
index d36fd1a8..4b14398f 100644
--- a/config/SZBE69_B8/objects.json
+++ b/config/SZBE69_B8/objects.json
@@ -1063,7 +1063,7 @@
             "system/midi/MidiReceiver.cpp": "Matching",
             "system/midi/MidiVarLen.cpp": "Matching",
 
-            "system/movie/CustomSplash_Wii.cpp": "MISSING",
+            "system/movie/CustomSplash_Wii.cpp": "NonMatching",
             "system/movie/Movie_Wii.cpp": "MISSING",
             "system/movie/Movie.cpp": "MISSING",
             "system/movie/Splash.cpp": "NonMatching",
diff --git a/src/band3/bandtrack/Gem.cpp b/src/band3/bandtrack/Gem.cpp
index 3c19fb8a..77008efc 100644
--- a/src/band3/bandtrack/Gem.cpp
+++ b/src/band3/bandtrack/Gem.cpp
@@ -28,8 +28,10 @@ Gem& Gem::operator=(const Gem& g) {
     mWidgets = g.mWidgets;
 }
 
-bool Gem::OnScreen(float) {
+bool Gem::OnScreen(float ms) {
+    float bottomSeconds = mGemManager->mTrackDir->BottomSeconds();
 
+    return (ms / 1000.0f) + bottomSeconds > mEnd;
 }
 
 bool Gem::UseRGChordStyle() const {
diff --git a/src/band3/bandtrack/GemRepTemplate.cpp b/src/band3/bandtrack/GemRepTemplate.cpp
index b83492ae..73db5a86 100644
--- a/src/band3/bandtrack/GemRepTemplate.cpp
+++ b/src/band3/bandtrack/GemRepTemplate.cpp
@@ -19,7 +19,7 @@ GemRepTemplate::GemRepTemplate(const TrackConfig& tc) : mConfig(SystemConfig("tr
     kTailMaxLength(mConfig->FindArray("tail_max_length", true)->Float(1)),
     kTailFrequencyRange(mConfig->FindArray("tail_min_freq", true)->Float(1), mConfig->FindArray("tail_max_freq", true)->Float(1)),
     kTailAmplitudeRange(mConfig->FindArray("tail_min_amp", true)->Float(1), mConfig->FindArray("tail_max_amp", true)->Float(1)),
-    mTrackCfg(tc), unk_0x3C(0), unk_0x40(1.0f), objectDir(NULL) {
+    mTrackCfg(tc), unk_0x3C(0), unk_0x40(1.0f), mObjectDir(NULL) {
     mSlots = (RndMat**)new void*[tc.GetMaxSlots()]; // it doesn't call the ctors, so i have to do This to just alloc
 }
 
@@ -69,7 +69,7 @@ int GemRepTemplate::GetRequiredFaceCount(int i) const {
 
 RndMat* GemRepTemplate::GetMatByTag(const char* c, int slot) {
     const char* s = mConfig->FindArray("mat_formats", true)->FindArray(c, true)->Str(1);
-    return objectDir->Find<RndMat>(MakeString("%s.mat", MakeString(s, slot < mTrackCfg.GetMaxSlots() ? mTrackCfg.GetSlotColor(slot) : "star")), true);
+    return mObjectDir->Find<RndMat>(MakeString("%s.mat", MakeString(s, slot < mTrackCfg.GetMaxSlots() ? mTrackCfg.GetSlotColor(slot) : "star")), true);
 }
 
 bool VertLess(const RndMesh::Vert& v1, const RndMesh::Vert& v2) {
@@ -80,13 +80,13 @@ bool VertLess(const RndMesh::Vert& v1, const RndMesh::Vert& v2) {
 }
 
 void GemRepTemplate::SetupTailVerts() {
-    objectDir->Find<RndMesh>("tail02.mesh", false)->Verts() = mTailVerts; // where assert
+    mObjectDir->Find<RndMesh>("tail02.mesh", false)->Verts() = mTailVerts; // where assert
     MILO_ASSERT(!(mTailVerts.size()%2), 212);
     std::sort(mTailVerts.begin(), mTailVerts.end(), VertLess);
-    unk_0x64 = mTailVerts;
+    mCapVerts = mTailVerts;
     int i = 420;
     mTailVerts.resize(i, true);
-    unk_0x64.resize(i, true);
+    mCapVerts.resize(i, true);
 }
 
 int GemRepTemplate::GetNumTailSections(GemRepTemplate::TailType type) const {
diff --git a/src/band3/bandtrack/GemRepTemplate.h b/src/band3/bandtrack/GemRepTemplate.h
index 839b2811..d5e6d3e4 100644
--- a/src/band3/bandtrack/GemRepTemplate.h
+++ b/src/band3/bandtrack/GemRepTemplate.h
@@ -42,14 +42,14 @@ class GemRepTemplate {
     RndMat** mSlots; // 0x38
     float unk_0x3C;
     float unk_0x40;
-    ObjectDir* objectDir; // 0x44
+    ObjectDir* mObjectDir; // 0x44
     uint mNumTailSections;
     u32 pad1;
     float mTailSectionLen;
     u32 pad2;
 
     RndMesh::VertVector mTailVerts; // 0x58
-    RndMesh::VertVector unk_0x64;
+    RndMesh::VertVector mCapVerts;
 
     int pad[3];
 
diff --git a/src/band3/bandtrack/TrackConfig.cpp b/src/band3/bandtrack/TrackConfig.cpp
index ee9656f9..94f5668f 100644
--- a/src/band3/bandtrack/TrackConfig.cpp
+++ b/src/band3/bandtrack/TrackConfig.cpp
@@ -4,8 +4,8 @@
 
 #include "decomp.h"
 
-TrackConfig::TrackConfig(BandUser* bu) : mUser(bu), unk_0x4(true), mTrackNum(0), mMaxSlots(0), unk_0x10(0),
-    unk_0x14(), mLefty(false), mCymbalLanes(0), mDisableHopos(0) {}
+TrackConfig::TrackConfig(BandUser* bu) : mUser(bu), kDualPerspective(true), mTrackNum(0), mMaxSlots(0), mNumSlots(0),
+    mName(), mLefty(false), mCymbalLanes(0), mDisableHopos(0) {}
 
 const BandUser* TrackConfig::GetBandUser() const { return mUser; }
 
diff --git a/src/band3/bandtrack/TrackConfig.h b/src/band3/bandtrack/TrackConfig.h
index 8ca96e75..6eba68c6 100644
--- a/src/band3/bandtrack/TrackConfig.h
+++ b/src/band3/bandtrack/TrackConfig.h
@@ -8,15 +8,15 @@ class TrackConfig {
 public:
     TrackConfig(BandUser*);
     BandUser* mUser; const BandUser* GetBandUser() const; Symbol Type() const; // 0x0
-    u8 unk_0x4; // 0x4
+    u8 kDualPerspective; // 0x4
     int mTrackNum; int TrackNum() const; void SetTrackNum(int); // 0x8
     int mMaxSlots; int GetMaxSlots() const; void SetMaxSlots(int); // 0xC
-    int unk_0x10; // 0x10
-    Symbol unk_0x14; // 0x14
+    int mNumSlots; // 0x10
+    Symbol mName; // 0x14
     bool mLefty; bool IsLefty() const; bool UseLeftyGems() const; void SetLefty(bool); // 0x18
     uint mCymbalLanes; uint GetGameCymbalLanes() const; void SetGameCymbalLanes(uint); // 0x1c
     bool mDisableHopos; bool GetDisableHopos() const; void SetDisableHopos(bool); // 0x20
-    std::vector<int> unk_0x24;
+    std::vector<int> mSlotSpacing;
 
     bool IsDrumTrack() const;
     bool IsKeyboardTrack() const;
diff --git a/src/band3/meta_band/Award.cpp b/src/band3/meta_band/Award.cpp
index eb00af70..5afc8845 100644
--- a/src/band3/meta_band/Award.cpp
+++ b/src/band3/meta_band/Award.cpp
@@ -6,31 +6,30 @@
 
 #include "decomp.h"
 
-Award::Award(DataArray* configure, int index) : mName(gNullStr), mIcon(gNullStr), mIsSecret(false), mIsBonus(false), mIndex(index) {
+Award::Award(DataArray *configure, int index)
+    : mName(gNullStr), mIcon(gNullStr), mIsSecret(false), mIsBonus(false), mIndex(index) {
 
 }
 
-Award::~Award() {
+Award::~Award() {}
 
-}
-
-class AssetMgr{};
+class AssetMgr {};
 
-void Award::Configure(DataArray* i_pConfig) {
+void Award::Configure(DataArray *i_pConfig) {
     MILO_ASSERT(i_pConfig, 0x25);
 
     mName = i_pConfig->Sym(0);
     i_pConfig->FindData(is_secret, mIsSecret, false);
     i_pConfig->FindData(is_bonus, mIsBonus, false);
     i_pConfig->FindData(icon, mIcon, false);
-    DataArray* pAwardArray = i_pConfig->FindArray(awards, false);
+    DataArray *pAwardArray = i_pConfig->FindArray(awards, false);
 
     MILO_ASSERT(pAwardArray->Size() > 1, 0x39);
 
     int i;
     for (i = 0; i < pAwardArray->Size(); i++) {
         DataNode node = pAwardArray->Node(i);
-        DataArray* pAwardEntryArray  = node.Array(0);
+        DataArray *pAwardEntryArray = node.Array(0);
 
         MILO_ASSERT(pAwardEntryArray, 0x3f);
         MILO_ASSERT(pAwardEntryArray->Size() >= 1, 0x40);
@@ -38,27 +37,29 @@ void Award::Configure(DataArray* i_pConfig) {
     }
 
     // TODO: Temporary to match string pool
-    void* pAssetMgr;
+    void *pAssetMgr;
     MILO_ASSERT(pAssetMgr, 0);
     TheDebug.Notify("Award: %s is granting unknown asset: %s\n");
 
     if (i > 8) {
-        TheDebug.Notify(MakeString("AWARD: %s is awarding too many assets!  count = %i\n", mName, i));
+        TheDebug.Notify(
+            MakeString("AWARD: %s is awarding too many assets!  count = %i\n", mName, i)
+        );
     }
 }
 
-Symbol Award::GetName() const{
+Symbol Award::GetName() const {
     return mName;
 }
 
-Symbol Award::GetDescription() const{
+Symbol Award::GetDescription() const {
     if (HasAssets()) {
         return award_genericdesc;
     }
     return MakeString("%s_desc", mName);
 }
 
-Symbol Award::GetDisplayName() const{
+Symbol Award::GetDisplayName() const {
     if (HasAssets()) {
         return award_generic;
     }
@@ -77,42 +78,46 @@ bool Award::HasIconArt() const {
     return !noIcon;
 }
 
-Symbol Award::GetIconArt() const{
+Symbol Award::GetIconArt() const {
     return mIcon;
 }
 
-bool Award::IsBonus() const{
+bool Award::IsBonus() const {
     return mIsBonus;
 }
 
-DECOMP_FORCEACTIVE(Award,
-    "%s_howto",
-    "%s_gray"
-)
+DECOMP_FORCEACTIVE(Award, "%s_howto", "%s_gray")
 
-void Award::GrantAward(const AwardEntry& awardEntry, BandProfile* i_pProfile) {
+void Award::GrantAward(const AwardEntry &awardEntry, BandProfile *i_pProfile) {
     MILO_ASSERT(i_pProfile, 0xbd);
 
     // TODO: Temporary to match string pool
     // Requires BandProfile and ProfileAssets
-    void* pPerformer;
+    void *pPerformer;
     MILO_ASSERT(pPerformer, 0);
 
-    if(mIndex){
-        TheDebug.Fail("Award Category is not currently supported: %s \n");
+    if (mIndex) {
+        TheDebug.Fail(MakeString("Award Category is not currently supported: %s \n", awardEntry.m_symAwardCategory));
     }
 }
 
-void Award::InqAssets(std::vector<Symbol>& o_rAssets) {
+void Award::InqAssets(std::vector<Symbol> &o_rAssets) {
     MILO_ASSERT(o_rAssets.empty(), 0xe5);
 }
 
 bool Award::HasAssets() const {
-    return 0;
+    for (int i = 0; i < mAwardEntries.size(); i++) {
+        if (mAwardEntries[i].m_symAwardCategory == asset) {
+            return true;
+        }
+    }
+    return false;
 }
 
-void Award::GrantAwards(BandProfile* bandProfile) {
-    for (std::vector<AwardEntry>::iterator it = mAwardEntries.begin(); it != mAwardEntries.end(); it++) {
+void Award::GrantAwards(BandProfile *bandProfile) {
+    for (std::vector<AwardEntry>::iterator it = mAwardEntries.begin();
+         it != mAwardEntries.end();
+         it++) {
         GrantAward(*it, bandProfile);
     }
 }
diff --git a/src/band3/meta_band/Award.h b/src/band3/meta_band/Award.h
index da4ca316..5be06e07 100644
--- a/src/band3/meta_band/Award.h
+++ b/src/band3/meta_band/Award.h
@@ -4,29 +4,33 @@
 
 class BandProfile;
 
-class AwardEntry {};
+class AwardEntry {
+public:
+    Symbol m_symAwardCategory;
+    Symbol m_symAward;
+};
 
-class Award {     
-    Award(DataArray*, int);
+class Award {
+    Award(DataArray *, int);
     virtual ~Award();
-    void Configure(DataArray*);
+    void Configure(DataArray *);
     Symbol GetName() const;
     Symbol GetDescription() const;
     Symbol GetDisplayName() const;
     bool HasIconArt() const;
     Symbol GetIconArt() const;
     bool IsBonus() const;
-    void GrantAward(const AwardEntry&, BandProfile*);
-    void InqAssets(std::vector<Symbol>&);
+    void GrantAward(const AwardEntry &, BandProfile *);
+    void InqAssets(std::vector<Symbol> &);
     bool HasAssets() const;
-    void GrantAwards(BandProfile*);
+    void GrantAwards(BandProfile *);
 
-    Symbol mName;                           // 0x04
-    Symbol mIcon;                           // 0x08
-    int mIndex;                             // 0x0c
-    bool mIsSecret;                         // 0x10
-    std::vector<AwardEntry> mAwardEntries;  // 0x14
-    bool mIsBonus;                          // 0x1c
+    Symbol mName; // 0x04
+    Symbol mIcon; // 0x08
+    int mIndex; // 0x0c
+    bool mIsSecret; // 0x10
+    std::vector<AwardEntry> mAwardEntries; // 0x14
+    bool mIsBonus; // 0x1c
 };
 
 #endif // METABAND_AWARD_H
\ No newline at end of file
diff --git a/src/system/beatmatch/MasterAudio.cpp b/src/system/beatmatch/MasterAudio.cpp
index 3928ba2c..d0e3a819 100644
--- a/src/system/beatmatch/MasterAudio.cpp
+++ b/src/system/beatmatch/MasterAudio.cpp
@@ -8,13 +8,24 @@ namespace {
     int kMaxSlots = 8;
 }
 
-MasterAudio::MasterAudio(DataArray* da, int num_players, BeatMaster* master, SongData* data) : mNumPlayers(num_players), mSongStream(0), mSongData(data), mStreamEnabled(0),
-    mMasterFader(Hmx::Object::New<Fader>()), mForegroundFader(Hmx::Object::New<Fader>()), mMultiplayerFader(Hmx::Object::New<Fader>()),
-    mBackgroundFader(Hmx::Object::New<Fader>()), mBackgroundAttenFader(Hmx::Object::New<Fader>()), mCommonFader(Hmx::Object::New<Fader>()),
-    mRemoteFader(Hmx::Object::New<Fader>()), mPracticeFader(Hmx::Object::New<Fader>()), mVocalDuckFader(Hmx::Object::New<Fader>()),
-    mVocalCueFader(Hmx::Object::New<Fader>()), mVocalFailFader(Hmx::Object::New<Fader>()), mCrowdFader(Hmx::Object::New<Fader>()), mBaseCrowdFader(Hmx::Object::New<Fader>()),
-    mPlayingInCommon(0), mMuteVolume(-96.0f), mVocalMuteVolume(-96.0f), mUnplayedVolume(-96.0f), mCueVolume(-12.0f), mPracticeVolume(0), mRemoteVolume(0), mMuteMaster(0), mMuckWithPitch(1),
-    mPitchMucker(0), mWhammyEnabled(1), mTimeOffset(0) {
+MasterAudio::MasterAudio(
+    DataArray *da, int num_players, BeatMaster *master, SongData *data
+)
+    : mNumPlayers(num_players), mSongStream(0), mSongData(data), mStreamEnabled(0),
+      mMasterFader(Hmx::Object::New<Fader>()),
+      mForegroundFader(Hmx::Object::New<Fader>()),
+      mMultiplayerFader(Hmx::Object::New<Fader>()),
+      mBackgroundFader(Hmx::Object::New<Fader>()),
+      mBackgroundAttenFader(Hmx::Object::New<Fader>()),
+      mCommonFader(Hmx::Object::New<Fader>()), mRemoteFader(Hmx::Object::New<Fader>()),
+      mPracticeFader(Hmx::Object::New<Fader>()),
+      mVocalDuckFader(Hmx::Object::New<Fader>()),
+      mVocalCueFader(Hmx::Object::New<Fader>()),
+      mVocalFailFader(Hmx::Object::New<Fader>()), mCrowdFader(Hmx::Object::New<Fader>()),
+      mBaseCrowdFader(Hmx::Object::New<Fader>()), mPlayingInCommon(0),
+      mMuteVolume(-96.0f), mVocalMuteVolume(-96.0f), mUnplayedVolume(-96.0f),
+      mCueVolume(-12.0f), mPracticeVolume(0), mRemoteVolume(0), mMuteMaster(0),
+      mMuckWithPitch(1), mPitchMucker(0), mWhammyEnabled(1), mTimeOffset(0) {
     mMasterFader->SetName("MasterFader", ObjectDir::Main());
     mForegroundFader->SetName("ForegroundFader", ObjectDir::Main());
     mMultiplayerFader->SetName("MultiplayerFader", ObjectDir::Main());
@@ -37,16 +48,21 @@ MasterAudio::MasterAudio(DataArray* da, int num_players, BeatMaster* master, Son
 
     mMultiplayerCommonVolume = -da->FindFloat("multiplayer_common_attenuation");
     mBackgroundVolume = -da->FindFloat("background_attenuation");
-    if(DataVariable("no_background_atten").Int(0)) mBackgroundVolume = 0;
+    if (DataVariable("no_background_atten").Int(0))
+        mBackgroundVolume = 0;
 
     float practice;
-    if(da->FindData("practice_attenuation", practice, false)) mPracticeVolume = -practice;
+    if (da->FindData("practice_attenuation", practice, false))
+        mPracticeVolume = -practice;
     float unplayed;
-    if(da->FindData("unplayed_attenuation", unplayed, false)) mUnplayedVolume = -unplayed;
+    if (da->FindData("unplayed_attenuation", unplayed, false))
+        mUnplayedVolume = -unplayed;
     float cue;
-    if(da->FindData("cue_attenuation", cue, false)) mCueVolume = -cue;
+    if (da->FindData("cue_attenuation", cue, false))
+        mCueVolume = -cue;
     float remote;
-    if(da->FindData("remote_attenuation", remote, false)) mRemoteVolume = -remote;
+    if (da->FindData("remote_attenuation", remote, false))
+        mRemoteVolume = -remote;
 
     da->FindData("mute_volume", mMuteVolume, false);
     mPassVolume = mMuteVolume;
@@ -60,15 +76,19 @@ MasterAudio::MasterAudio(DataArray* da, int num_players, BeatMaster* master, Son
     mPitchMucker = new PitchMucker();
 }
 
-MasterAudio::~MasterAudio(){
-    for(std::vector<ChannelData*>::iterator it = mChannelData.begin(); it != mChannelData.end(); it++){
+MasterAudio::~MasterAudio() {
+    for (std::vector<ChannelData *>::iterator it = mChannelData.begin();
+         it != mChannelData.end();
+         it++) {
         RELEASE(*it);
     }
-    for(std::vector<TrackData*>::iterator it = mTrackData.mTrackData.begin(); it != mTrackData.mTrackData.end(); it++){
+    for (std::vector<TrackData *>::iterator it = mTrackData.mTrackData.begin();
+         it != mTrackData.mTrackData.end();
+         it++) {
         RELEASE(*it);
     }
-    if(mSongStream){
-        for(int i = 0; i < 2; i++){
+    if (mSongStream) {
+        for (int i = 0; i < 2; i++) {
             mSongStream->SetFX(i, false);
         }
     }
@@ -91,7 +111,7 @@ MasterAudio::~MasterAudio(){
     RELEASE(mPitchMucker);
 }
 
-void MasterAudio::Load(SongInfo* info, PlayerTrackConfigList* player_track_config_list){
+void MasterAudio::Load(SongInfo *info, PlayerTrackConfigList *player_track_config_list) {
     MILO_ASSERT(mSongData, 0x186);
     MILO_ASSERT(player_track_config_list, 0x187);
     mSongStream = TheSynth->NewStream(info->GetBaseFileName(), 0, 0, false);
@@ -106,54 +126,56 @@ void MasterAudio::Load(SongInfo* info, PlayerTrackConfigList* player_track_confi
 
     SetupChannels(info);
     SetupTracks(info, player_track_config_list);
-    if(player_track_config_list->UseVocalHarmony()){
+    if (player_track_config_list->UseVocalHarmony()) {
         count = info->GetNumVocalParts();
     }
 
-    for(int i = 1; i < count; i++){
+    for (int i = 1; i < count; i++) {
         mTrackData.mTrackData.push_back(new TrackData());
     }
 }
 
-bool MasterAudio::IsLoaded(){
+bool MasterAudio::IsLoaded() {
     return mSongStream->IsReady();
 }
 
-void MasterAudio::SetupChannels(SongInfo* info){
+void MasterAudio::SetupChannels(SongInfo *info) {
     info->GetTracks();
-    const std::vector<float>& pans = info->GetPans();
-    const std::vector<float>& vols = info->GetVols();
-    const std::vector<int>& cores = info->GetCores();
-    const std::vector<int>& crowd_channels = info->GetCrowdChannels();
+    const std::vector<float> &pans = info->GetPans();
+    const std::vector<float> &vols = info->GetVols();
+    const std::vector<int> &cores = info->GetCores();
+    const std::vector<int> &crowd_channels = info->GetCrowdChannels();
     MILO_ASSERT(pans.size() == vols.size(), 0x1BE);
     MILO_ASSERT(cores.size() == vols.size(), 0x1BF);
-    
-    int i9 = 0;
-    for(int i = 0; i < vols.size(); i++){
-        if(!info->IsPlayTrackChannel(i)){
 
+    int i9 = 0;
+    for (int i = 0; i < vols.size(); i++) {
+        if (!info->IsPlayTrackChannel(i)) {
         }
         float voltouse = vols[i];
-        if(voltouse < -40.0f){
+        if (voltouse < -40.0f) {
             i9++;
-            if(3 < i9) voltouse = -40.0f;
+            if (3 < i9)
+                voltouse = -40.0f;
         }
-        mChannelData.push_back(new ChannelData(mSongStream, i, voltouse, (float)pans[i], (FXCore)cores[i]));
+        mChannelData.push_back(
+            new ChannelData(mSongStream, i, voltouse, (float)pans[i], (FXCore)cores[i])
+        );
     }
 }
 
-void MasterAudio::ResetTrack(int i, bool b){
+void MasterAudio::ResetTrack(int i, bool b) {
     ResetTrack(mSongData->GetAudioTrackNum(i), b);
 }
 
-void MasterAudio::ResetTrack(AudioTrackNum num, bool b){
+void MasterAudio::ResetTrack(AudioTrackNum num, bool b) {
     std::list<int> iList;
     mTrackData.mTrackData[num.mVal]->FillChannelList(iList);
     mTrackData.mTrackData[num.mVal]->Reset();
     SetAutoOn(num, 0);
-    for(std::list<int>::iterator it = iList.begin(); it != iList.end(); it++){
+    for (std::list<int>::iterator it = iList.begin(); it != iList.end(); it++) {
         int idx = *it;
-        FaderGroup* grp = mSongStream->ChannelFaders(idx);
+        FaderGroup *grp = mSongStream->ChannelFaders(idx);
         grp->Remove(mBackgroundAttenFader);
         grp->Remove(mBackgroundFader);
         grp->Remove(mCommonFader);
@@ -165,51 +187,132 @@ void MasterAudio::ResetTrack(AudioTrackNum num, bool b){
 
         bool b3 = false;
         bool b1 = mTrackData.mTrackData[num.mVal]->mVocals;
-        if(b1 && b) b3 = true;
+        if (b1 && b)
+            b3 = true;
         float f2 = b3 ? mCueVolume : 0;
-        if(b) SetupTrackChannel(idx, b1, f2, b3, false);
-        else SetupBackgroundChannel(idx, b1, f2, b3, false);
+        if (b)
+            SetupTrackChannel(idx, b1, f2, b3, false);
+        else
+            SetupBackgroundChannel(idx, b1, f2, b3, false);
     }
 }
 
-void MasterAudio::ConfigureVocalFaders(int i, bool b){
-    FaderGroup* grp = mSongStream->ChannelFaders(i);
-    if(b) grp->Add(mVocalDuckFader);
-    else grp->Add(mVocalFailFader);
+void MasterAudio::ConfigureVocalFaders(int i, bool b) {
+    FaderGroup *grp = mSongStream->ChannelFaders(i);
+    if (b)
+        grp->Add(mVocalDuckFader);
+    else
+        grp->Add(mVocalFailFader);
+}
+
+void MasterAudio::FadeOutDrums(int trackNum) {
+    // this is very close to being right not quite, can't figure out what is wrong
+    /*    AudioTrackNum audioTrackNum = mSongData->GetAudioTrackNum(trackNum);
+        mTrackData.mTrackData[audioTrackNum.mVal]->mInFill = 1;
+        Symbol drum_fill = Symbol("drum_fill");
+        SetTrackFader(audioTrackNum, -1, drum_fill, -96.0f, 1000.0f);
+        */
+}
+
+bool MasterAudio::Fail() {
+    if (mSongStream)
+        return mSongStream->Fail();
+    else
+        return true;
 }
 
-bool MasterAudio::Fail(){
-    if(mSongStream) return mSongStream->Fail();
-    else return true;
+float MasterAudio::GetTime() const {
+    float time;
+    if (mSongStream != 0) {
+        time = mSongStream->GetTime();
+    } else {
+        time = 0.0f;
+    }
+    return time + mTimeOffset;
 }
 
-bool MasterAudio::IsReady(){
+bool MasterAudio::IsReady() {
     bool b = false;
-    if(mSongStream && mSongStream->IsReady()) b = true;
+    if (mSongStream && mSongStream->IsReady())
+        b = true;
     mStreamEnabled = b;
     return b;
 }
 
 bool MasterAudio::IsFinished() const {
     bool b = false;
-    if(mSongStream && mSongStream->IsFinished()) b = true;
+    if (mSongStream && mSongStream->IsFinished())
+        b = true;
     return b;
 }
 
-void MasterAudio::Play(){
+void MasterAudio::SetBackgroundVolume(float volume) {
+    mBackgroundFader->SetVal(volume);
+}
+
+void MasterAudio::SetForegroundVolume(float volume) {
+    mForegroundFader->SetVal(volume);
+}
+
+void MasterAudio::SetMasterVolume(float volume) {
+    mMasterVolume = volume;
+    UpdateMasterFader();
+}
+
+void MasterAudio::SetMuckWithPitch(bool enabled) {
+    mMuckWithPitch = enabled;
+}
+
+void MasterAudio::SetMuteMaster(bool muted) {
+    mMuteMaster = muted;
+    UpdateMasterFader();
+}
+
+void MasterAudio::SetPracticeMode(bool enabled) {
+    mPracticeFader->SetVal(enabled ? mPracticeVolume : 0.0f);
+}
+
+void MasterAudio::SetStereo(bool b) {
+    for (int i = 0; i < mChannelData.size(); i++) {
+        mChannelData[i]->SetStereo(b);
+    }
+}
+
+void MasterAudio::SetTimeOffset(float offset) {
+    mTimeOffset = offset;
+}
+
+void MasterAudio::ToggleMuteMaster() {
+    bool b = mMuteMaster;
+    SetMuteMaster(!b);
+    return;
+}
+
+void MasterAudio::UpdateMasterFader() {
+    float masterVolume;
+    if (mMuteMaster != 0) {
+        masterVolume = -96.0f;
+    } else {
+        masterVolume = mMasterVolume;
+    }
+    mMasterFader->SetVal(masterVolume);
+    return;
+}
+
+void MasterAudio::Play() {
     MILO_ASSERT(mSongStream, 0x334);
     mSongStream->Play();
-    for(int i = 0; i < mChannelData.size(); i++){
+    for (int i = 0; i < mChannelData.size(); i++) {
         mChannelData[i]->ForceOn();
     }
 }
 
-void MasterAudio::Jump(float f){
+void MasterAudio::Jump(float f) {
     mSongStream->Stop();
     mStreamEnabled = false;
     mSongStream->Resync(f);
     UnmuteAllTracks();
-    for(int i = 0; i < mTrackData.mTrackData.size(); i++){
+    for (int i = 0; i < mTrackData.mTrackData.size(); i++) {
         mTrackData.mTrackData[i]->Reset();
         AudioTrackNum num;
         num.mVal = i;
@@ -217,86 +320,123 @@ void MasterAudio::Jump(float f){
     }
 }
 
-ChannelData::ChannelData(Stream* stream, int chan, float vol, float pan, FXCore core) : mStream(stream), mChannel(chan), mSlipTrack(0), mIsTrackChannel(0),
-    mPan(pan), mOriginalPan(pan), mCore(core), mOverallSpeed(1.0f), mSpeed(1.0f), mDirty(0), mVolume(vol) {
+ChannelData::ChannelData(Stream *stream, int chan, float vol, float pan, FXCore core)
+    : mStream(stream), mChannel(chan), mSlipTrack(0), mIsTrackChannel(0), mPan(pan),
+      mOriginalPan(pan), mCore(core), mOverallSpeed(1.0f), mSpeed(1.0f), mDirty(0),
+      mVolume(vol) {
     mBaseFader = stream->ChannelFaders(chan)->AddLocal("base");
     mBaseFader->SetVal(vol);
     stream->SetPan(chan, mPan);
     stream->SetFXCore(chan, mCore);
 }
 
-ChannelData::~ChannelData(){
+ChannelData::~ChannelData() {
     RELEASE(mSlipTrack);
 }
 
-void ChannelData::SetSlippable(bool b){
-    if(b){
-        if(!mSlipTrack){
+void ChannelData::SetSlippable(bool b) {
+    if (b) {
+        if (!mSlipTrack) {
             mSlipTrack = new SlipTrack(mStream, mChannel);
         }
-    }
-    else if(mSlipTrack) RELEASE(mSlipTrack);
+    } else if (mSlipTrack)
+        RELEASE(mSlipTrack);
 }
 
-void ChannelData::ForceOn(){
-    if(mSlipTrack) mSlipTrack->ForceOn();
+void ChannelData::ForceOn() {
+    if (mSlipTrack)
+        mSlipTrack->ForceOn();
 }
 
-void ChannelData::Reset(bool b){
-    if(mOverallSpeed != 1.0f || mDirty || b){
+void ChannelData::Reset(bool b) {
+    if (mOverallSpeed != 1.0f || mDirty || b) {
         mSlipTrack->SetOffset(0);
         SetSlipTrackSpeed(1.0f);
         mDirty = false;
     }
 }
 
-void ChannelData::Poll(){
-    if(mSlipTrack) mSlipTrack->Poll();
+void ChannelData::Poll() {
+    if (mSlipTrack)
+        mSlipTrack->Poll();
 }
 
-void ChannelData::SetSlipTrackSpeed(float f){
-    if(mSlipTrack){
-        if(mSlipTrack->mMaxSlip * 0.9f < __fabs(mSlipTrack->GetCurrentOffset())){
-            f = 1.0f;
+void ChannelData::SetSlipTrackSpeed(float trackSpeed) {
+    if (mSlipTrack) {
+        if (mSlipTrack->mMaxSlip * 0.9f < __fabs(mSlipTrack->GetCurrentOffset())) {
+            trackSpeed = 1.0f;
         }
-        if(mSpeed != f || mOverallSpeed != 1.0f){
-            mSlipTrack->SetSpeed(f * mOverallSpeed);
-            mSpeed = f;
+        if (mSpeed != trackSpeed || mOverallSpeed != 1.0f) {
+            mSlipTrack->SetSpeed(trackSpeed * mOverallSpeed);
+            mSpeed = trackSpeed;
             mDirty = true;
         }
     }
 }
 
-void ChannelData::SetFX(FXCore core, bool b){
-    if(mCore == core){
+void ChannelData::SetFX(FXCore core, bool b) {
+    if (mCore == core) {
         mStream->SetFX(mChannel, b);
     }
 }
 
-void ChannelData::SetStereo(bool b){
-    mStream->SetPan(mChannel, b ? mPan : 0);
+void ChannelData::SetStereo(bool enabled) {
+    mStream->SetPan(mChannel, enabled ? mPan : 0);
 }
 
-void ChannelData::SetFaderVal(float val){
+void ChannelData::SetFaderVal(float val) {
     mBaseFader->SetVal(val);
 }
 
-void ChannelData::SetPan(float pan){
+void ChannelData::SetPan(float pan) {
     mPan = pan;
     mStream->SetPan(mChannel, mPan);
 }
 
-TrackData::TrackData(){
+TrackData::TrackData() {
     Init(0, false);
 }
 
-TrackData::TrackData(SubmixCollection* submixes, const std::vector<int>& vec, bool b1, bool b2){
+TrackData::TrackData(
+    SubmixCollection *submixes, const std::vector<int> &vec, bool b1, bool b2
+) {
     Init(submixes, b1);
     SetMapping(vec);
     mVocals = b2;
 }
 
-void TrackData::Init(SubmixCollection* submixes, bool b){
+void TrackData::Miss(int i, float f) {
+    SetSucceeding(false, i, f);
+}
+
+void TrackData::SetNonmutable(bool nonmutable) {
+    mNonmutable = nonmutable;
+}
+
+void TrackData::SetSucceeding(bool succeeding, int gemId, float lastGemTime) {
+    if (mMultiSlot != 0) {
+        if (gemId == -1) {
+            int var = 0;
+            for (int j = 0; j < mSucceedingVec.size(); j++) {
+                mSucceedingVec[j] = succeeding;
+                mLastGemTimes[var] = lastGemTime;
+                var++;
+            }
+            return;
+        }
+        mSucceedingVec[gemId] = succeeding;
+        mLastGemTimes[gemId] = lastGemTime;
+    } else {
+        mSucceeding = succeeding;
+        return;
+    }
+}
+
+void TrackData::SetUserGuid(const UserGuid &guid) {
+    mUserGuid = guid;
+}
+
+void TrackData::Init(SubmixCollection *submixes, bool b) {
     mSubmixes = submixes;
     mMultiSlot = false;
     mSucceeding = false;
diff --git a/src/system/beatmatch/MasterAudio.h b/src/system/beatmatch/MasterAudio.h
index 8b95ee20..47b249c3 100644
--- a/src/system/beatmatch/MasterAudio.h
+++ b/src/system/beatmatch/MasterAudio.h
@@ -50,14 +50,17 @@ class TrackData {
     TrackData(SubmixCollection*, const std::vector<int>&, bool, bool);
     ~TrackData();
     void Init(SubmixCollection*, bool);
+    void Miss(int, float);
     void SetMapping(const std::vector<int>&);
     void SetSucceeding(bool, int, float);
     void SetMapping(const char*);
+    void SetNonmutable(bool);
+    void SetUserGuid(const UserGuid&);
     void FillChannelList(std::list<int>&) const;
     void Reset();
 
     bool mSucceeding; // 0x0
-    std::vector<int> mSucceedingVec; // 0x4 - needs to be bool but errors out for some reason
+    std::vector<bool> mSucceedingVec; // 0x4
     std::vector<float> mLastGemTimes; // 0xc
     bool mMultiSlot; // 0x14
     int mLastPlayedGem; // 0x18
@@ -115,7 +118,7 @@ class MasterAudio : public BeatMasterSink, public BeatMatchSink, public Hmx::Obj
     virtual void FilteredWhammyBar(float){}
     virtual void SwingAtHopo(int, float, int){}
     virtual void Hopo(int, float, int){}
-    virtual void SetCurrentPhrase(int, const PhraseInfo&){}
+    virtual void SetCurrentPhrase(int, const PhraseInfo&){ return;}
     virtual void NoCurrentPhrase(int){}
     virtual void FillReset(){}
     virtual void FillComplete(int, int){}
@@ -124,17 +127,27 @@ class MasterAudio : public BeatMasterSink, public BeatMatchSink, public Hmx::Obj
     void SetupChannels(SongInfo*);
     void SetupTracks(SongInfo*, PlayerTrackConfigList*);
     bool IsLoaded();
+    void FadeOutDrums(int);
     void ResetTrack(int, bool);
     void ResetTrack(AudioTrackNum, bool);
     void SetAutoOn(AudioTrackNum, int);
     void SetupTrackChannel(int, bool, float, bool, bool);
     void SetupBackgroundChannel(int, bool, float, bool, bool);
+    void SetBackgroundVolume(float);
+    void SetForegroundVolume(float);
+    void SetMuckWithPitch(bool);
+    void SetMuteMaster(bool);
+    void SetPracticeMode(bool);
+    void SetStereo(bool);
+    void SetTrackFader(AudioTrackNum, int, Symbol, float, float);
+    void ToggleMuteMaster();
     void ConfigureVocalFaders(int, bool);
     bool Fail();
     bool IsFinished() const;
     void Play();
     void Jump(float);
     void UnmuteAllTracks();
+    void UpdateMasterFader();
     void ResetSlipTrack(AudioTrackNum, bool);
     void SetTimeOffset(float);
 
diff --git a/src/system/beatmatch/PlayerTrackConfig.h b/src/system/beatmatch/PlayerTrackConfig.h
index b21b85ba..d8c8f44f 100644
--- a/src/system/beatmatch/PlayerTrackConfig.h
+++ b/src/system/beatmatch/PlayerTrackConfig.h
@@ -8,10 +8,11 @@
 
 class PlayerTrackConfig {
 public:
-    PlayerTrackConfig(const UserGuid& u, TrackType ty, int i, int j, bool b) : 
-        mUserGuid(u), mTrackType(ty), mDifficulty(i), mSlot(j), mRemote(b), mTrackNum(-1) {}
+    PlayerTrackConfig(const UserGuid &u, TrackType ty, int i, int j, bool b)
+        : mUserGuid(u), mTrackType(ty), mDifficulty(i), mSlot(j), mRemote(b),
+          mTrackNum(-1) {}
 
-    void Update(TrackType ty, int i, int slot, bool remote){
+    void Update(TrackType ty, int i, int slot, bool remote) {
         mTrackType = ty;
         mDifficulty = i;
         MILO_ASSERT(mSlot == slot, 0x34);
@@ -30,13 +31,13 @@ class PlayerTrackConfigList {
 public:
     PlayerTrackConfigList(int);
     void Reset();
-    void AddPlaceholderConfig(const UserGuid&, int, bool);
-    void AddConfig(const UserGuid&, TrackType, int, int, bool);
-    void UpdateConfig(const UserGuid&, TrackType, int, int, bool);
-    void ChangeDifficulty(const UserGuid&, int);
-    const UserGuid& GetUserGuidByIndex(int) const;
-    PlayerTrackConfig& GetConfigByUserGuid(const UserGuid&) const;
-    PlayerTrackConfig& GetConfigByUserGuid(const UserGuid&);
+    void AddPlaceholderConfig(const UserGuid &, int, bool);
+    void AddConfig(const UserGuid &, TrackType, int, int, bool);
+    void UpdateConfig(const UserGuid &, TrackType, int, int, bool);
+    void ChangeDifficulty(const UserGuid &, int);
+    const UserGuid &GetUserGuidByIndex(int) const;
+    PlayerTrackConfig &GetConfigByUserGuid(const UserGuid &) const;
+    PlayerTrackConfig &GetConfigByUserGuid(const UserGuid &);
     void SetAutoVocals(bool);
     bool GetAutoVocals() const;
     void SetUseVocalHarmony(bool);
@@ -46,16 +47,16 @@ class PlayerTrackConfigList {
     bool UseRealDrums() const;
     void SetGameCymbalLanes(unsigned int);
     unsigned int GetGameCymbalLanes() const;
-    UserGuid& InstrumentPlayer(SongInfoAudioType, int) const;
-    void Process(std::vector<TrackType>&);
-    void ProcessConfig(PlayerTrackConfig&);
-    void ProcessConfig(const UserGuid&);
+    UserGuid &InstrumentPlayer(SongInfoAudioType, int) const;
+    void Process(std::vector<TrackType> &);
+    void ProcessConfig(PlayerTrackConfig &);
+    void ProcessConfig(const UserGuid &);
     int TrackNumOfExactType(TrackType);
     int TrackNumOfType(TrackType);
     bool TrackUsed(int) const;
-    const UserGuid& TrackPlayer(int) const;
-    bool UserPresent(const UserGuid&);
-    void RemoveConfig(const UserGuid&);
+    const UserGuid &TrackPlayer(int) const;
+    bool UserPresent(const UserGuid &);
+    void RemoveConfig(const UserGuid &);
 
     std::vector<int> mTrackDiffs; // 0x0
     std::vector<int> mTrackNums; // 0x8
@@ -68,9 +69,9 @@ class PlayerTrackConfigList {
     bool mDiscoUnflip; // 0x2b
     bool unk2c; // 0x2c
     unsigned int mGameCymbalLanes; // 0x30
-    bool unk34; // 0x34
-    int unk38; // 0x38
-    bool unk3c; // 0x3c
+    bool mUseGHDrums; // 0x34
+    int mDefaultDifficulty; // 0x38
+    bool mNeedsProcessing; // 0x3c
     bool mProcessed; // 0x3d
 };
 
diff --git a/src/system/beatmatch/PlayerTrackConfigList.cpp b/src/system/beatmatch/PlayerTrackConfigList.cpp
index cf3b34bc..4b196b3b 100644
--- a/src/system/beatmatch/PlayerTrackConfigList.cpp
+++ b/src/system/beatmatch/PlayerTrackConfigList.cpp
@@ -5,7 +5,7 @@
 
 // fn_80472568
 PlayerTrackConfigList::PlayerTrackConfigList(int reserve_num_players) : mAutoVocals(0), mUseVocalHarmony(0), mUseRealDrums(0), mDiscoUnflip(0), unk2c(0),
-    mGameCymbalLanes(0), unk34(0), unk38(0), unk3c(1), mProcessed(0) {
+    mGameCymbalLanes(0), mUseGHDrums(0), mDefaultDifficulty(0), mNeedsProcessing(1), mProcessed(0) {
     MILO_ASSERT(kMorePlayersThanWeWillEverNeed > reserve_num_players, 0x21);
     mTrackDiffs.reserve(kMorePlayersThanWeWillEverNeed);
     mTrackNums.reserve(kMorePlayersThanWeWillEverNeed);
@@ -21,7 +21,7 @@ void PlayerTrackConfigList::Reset(){
     mTrackOccupied.clear();
     mConfigs.clear();
     mProcessed = false;
-    unk38 = 0;
+    mDefaultDifficulty = 0;
     mAutoVocals = false;
     mUseRealDrums = false;
     mDiscoUnflip = false;
@@ -126,11 +126,11 @@ void PlayerTrackConfigList::Process(std::vector<TrackType>& tracktypes){
     mTrackNums.reserve(size);
     mTrackOccupied.reserve(size);
     for(int i = 0; i < size; i++){
-        mTrackDiffs.push_back(unk38);
+        mTrackDiffs.push_back(mDefaultDifficulty);
         mTrackNums.push_back(i);
         mTrackOccupied.push_back(0);
     }
-    if(unk3c){
+    if(mNeedsProcessing){
         for(int i = 0; i < mConfigs.size(); i++){
             ProcessConfig(mConfigs[i]);
         }
diff --git a/src/system/movie/CustomSplash_Wii.cpp b/src/system/movie/CustomSplash_Wii.cpp
new file mode 100644
index 00000000..cc960d8b
--- /dev/null
+++ b/src/system/movie/CustomSplash_Wii.cpp
@@ -0,0 +1,31 @@
+#include "CustomSplash_Wii.h"
+
+DECOMP_FORCEACTIVE(
+    CustomSplash,
+    "16_9",
+    "4_3",
+    "StrapUsage/StrapUsage_eng_%s.tpl",
+    "StrapUsage/StrapUsage_fre_%s.tpl",
+    "StrapUsage/StrapUsage_ita_%s.tpl",
+    "StrapUsage/StrapUsage_deu_%s.tpl",
+    "StrapUsage/StrapUsage_esl_%s.tpl",
+    "StrapUsage/StrapUsage_nld_%s.tpl",
+    "StrapUsage/Loading.tpl",
+    "StrapUsage/Loading_fre.tpl",
+    "StrapUsage/Loading_ita.tpl",
+    "StrapUsage/Loading_deu.tpl",
+    "StrapUsage/Loading_esl.tpl"
+)
+
+void AllocateMEM2(int size) {
+    _MemAlloc(size, 0x20);
+}
+
+CustomSplash::CustomSplash() : mTimer1(), mTimer2() {
+    unk_64 = 0;
+    unk_48c = 0;
+    float val = 250.0f;
+    unk_60 = -val;
+    unk_48d = 0;
+    unk_490 = 1;
+}
\ No newline at end of file
diff --git a/src/system/movie/CustomSplash_Wii.h b/src/system/movie/CustomSplash_Wii.h
new file mode 100644
index 00000000..6e5c9224
--- /dev/null
+++ b/src/system/movie/CustomSplash_Wii.h
@@ -0,0 +1,26 @@
+#pragma once
+#include "os/Timer.h"
+#include "sdk/RVL_SDK/revolution/tpl/TPL.h"
+#include "system/utl/MemMgr.h"
+
+class CustomSplash {
+public:
+    CustomSplash();
+    ~CustomSplash();
+
+    Timer mTimer1; // 0x0
+    Timer mTimer2; // 0x30
+    float unk_60; // 0x60
+    unsigned int unk_64; // 0x64
+    TPLPalette *mPalette; // 0x68
+    GXTexObj *mGXTexObj; // 0x6C
+
+    // no clue what this is
+    char unknownBytes[0x41c];
+
+    char unk_48c; // 0x48C
+    char unk_48d; // 0x48D
+    char unk_48e; // 0x48E
+    char unk_48f; // 0x48F
+    char unk_490; // 0x490
+};
\ No newline at end of file
diff --git a/src/system/os/File.cpp b/src/system/os/File.cpp
index 65dc94c5..dee23d17 100644
--- a/src/system/os/File.cpp
+++ b/src/system/os/File.cpp
@@ -4,116 +4,125 @@
 #include "os/Debug.h"
 #include "utl/FilePath.h"
 #include <vector>
+#include "os/BlockMgr.h"
 #include "os/System.h"
 #include "utl/Loader.h"
 #include "obj/DataFunc.h"
 #include "utl/Option.h"
 
 int File::sOpenCount[4];
-std::vector<File*> gFiles;
-File* gOpenCaptureFile;
+std::vector<File *> gFiles;
+File *gOpenCaptureFile;
 int gCaptureFileMode;
 static char gRoot[256];
 static char gExecRoot[256];
 static char gSystemRoot[256];
 std::vector<String> gDirList;
 int kNoHandle;
-DataArray* gFrameRateArray;
+DataArray *gFrameRateArray;
 bool gNullFiles;
 
-void DirListCB(const char* cc1, const char* cc2){
+void DirListCB(const char *cc1, const char *cc2) {
     gDirList.push_back(String(cc2));
 }
 
-const char* FileRoot(){
+const char *FileRoot() {
     return gRoot;
 }
 
-const char* FileExecRoot(){
+const char *FileExecRoot() {
     return gExecRoot;
 }
 
-const char* FileSystemRoot(){
+const char *FileSystemRoot() {
     return gSystemRoot;
 }
 
-static DataNode OnFileExecRoot(DataArray* da){
+static DataNode OnFileExecRoot(DataArray *da) {
     return DataNode(gExecRoot);
 }
 
-static DataNode OnFileRoot(DataArray* da){
+static DataNode OnFileRoot(DataArray *da) {
     return DataNode(gRoot);
 }
 
-static DataNode OnFileGetDrive(DataArray* da){
+static DataNode OnFileGetDrive(DataArray *da) {
     return DataNode(FileGetDrive(da->Str(1)));
 }
 
-static DataNode OnFileGetPath(DataArray* da){
+static DataNode OnFileGetPath(DataArray *da) {
     return DataNode(FileGetPath(da->Str(1), 0));
 }
 
-static DataNode OnFileGetBase(DataArray* da){
+static DataNode OnFileGetBase(DataArray *da) {
     return DataNode(FileGetBase(da->Str(1), 0));
 }
 
-static DataNode OnFileGetExt(DataArray* da){
+static DataNode OnFileGetExt(DataArray *da) {
     return DataNode(FileGetExt(da->Str(1)));
 }
 
-static DataNode OnFileMatch(DataArray* da){
+static DataNode OnFileMatch(DataArray *da) {
     return DataNode(FileMatch(da->Str(1), da->Str(2)));
 }
 
-static DataNode OnFileAbsolutePath(DataArray* da){
+static DataNode OnFileAbsolutePath(DataArray *da) {
     return DataNode(FileMakePath(da->Str(1), da->Str(2), 0));
 }
 
-static DataNode OnFileRelativePath(DataArray* da){
+static DataNode OnFileRelativePath(DataArray *da) {
     return DataNode(FileRelativePath(da->Str(1), da->Str(2)));
 }
 
-static DataNode OnWithFileRoot(DataArray* da){
+static DataNode OnWithFileRoot(DataArray *da) {
     FilePathTracker fpt(da->Str(1));
     int i;
     int thresh = da->Size() - 1;
-    for(i = 2; i < thresh; i++){
+    for (i = 2; i < thresh; i++) {
         da->Command(i)->Execute();
     }
     DataNode ret = da->Evaluate(i);
     return ret;
 }
 
-static DataNode OnSynchProc(DataArray* da){
+static DataNode OnSynchProc(DataArray *da) {
     TheDebug.Fail(MakeString("calling synchproc on non-pc platform"));
     return DataNode("");
 }
 
-static DataNode OnToggleFakeFileErrors(DataArray* da){
+static DataNode OnToggleFakeFileErrors(DataArray *da) {
     return DataNode(0);
 }
 
-void OnFrameRateRecurseCB(const char* cc1, const char* cc2){
+void OnFrameRateRecurseCB(const char *cc1, const char *cc2) {
     MILO_ASSERT(gFrameRateArray, 0x148);
     String str(cc2);
-    const char* keepStr = MakeString("_keep_%s.dta", PlatformSymbol(TheLoadMgr.GetPlatform()));
+    const char *keepStr =
+        MakeString("_keep_%s.dta", PlatformSymbol(TheLoadMgr.GetPlatform()));
     int theStrLen = strlen(str.c_str());
     int keepLen = strlen(keepStr);
     str = str.substr(0, theStrLen - keepLen);
     gFrameRateArray->Insert(gFrameRateArray->Size(), DataNode(str));
 }
 
-static DataNode OnEnumerateFrameRateResults(DataArray* da){
+static DataNode OnEnumerateFrameRateResults(DataArray *da) {
     DataNode ret(new DataArray(0), kDataArray);
     gFrameRateArray = ret.Array(0);
-    FileRecursePattern(MakeString("ui/framerate/venue_test/*%s", MakeString("_keep_%s.dta", PlatformSymbol(TheLoadMgr.GetPlatform()))), OnFrameRateRecurseCB, false);
+    FileRecursePattern(
+        MakeString(
+            "ui/framerate/venue_test/*%s",
+            MakeString("_keep_%s.dta", PlatformSymbol(TheLoadMgr.GetPlatform()))
+        ),
+        OnFrameRateRecurseCB,
+        false
+    );
     gFrameRateArray = 0;
     return ret;
 }
 
 extern void HolmesClientInit();
 
-void FileInit(){
+void FileInit() {
     strcpy(gRoot, ".");
     strcpy(gExecRoot, ".");
     strcpy(gSystemRoot, FileMakePath(gExecRoot, "../../system/run", 0));
@@ -132,14 +141,14 @@ void FileInit(){
     DataRegisterFunc("toggle_fake_file_errors", OnToggleFakeFileErrors);
     DataRegisterFunc("enumerate_frame_rate_results", OnEnumerateFrameRateResults);
     HolmesClientInit();
-    const char* optionStr = OptionStr("file_order", 0);
-    if(optionStr && *optionStr){
+    const char *optionStr = OptionStr("file_order", 0);
+    if (optionStr && *optionStr) {
         gOpenCaptureFile = NewFile(optionStr, 0xA04);
         MILO_ASSERT(gOpenCaptureFile, 0x1AE);
     }
 }
 
-void FileTerminate(){
+void FileTerminate() {
     delete gOpenCaptureFile;
     gOpenCaptureFile = 0;
     *gRoot = 0;
@@ -147,41 +156,43 @@ void FileTerminate(){
     *gSystemRoot = 0;
 }
 
-File* NewFile(const char* cc, int i){
-    File* retFile = 0;
-    if(gNullFiles){
+File *NewFile(const char *cc, int i) {
+    File *retFile = 0;
+    if (gNullFiles) {
         return new NullFile();
-    }
-    else {
-        if(!MainThread()){
+    } else {
+        if (!MainThread()) {
             MILO_WARN("NewFile(%s) from !MainThread()", cc);
         }
-        if(!cc || !*cc) return 0;
+        if (!cc || !*cc)
+            return 0;
         else {
-            if(strstr(cc, "/band3_ng/")){
+            if (strstr(cc, "/band3_ng/")) {
                 MILO_WARN("Loading files from the wrong branch: %s", cc);
                 return 0;
-            }
-            else {
-                
+            } else {
             }
         }
     }
 }
 
-bool FileExists(const char* filepath, int iMode){
+void FileDiscSpinUp() { TheBlockMgr.SpinUp(); }
+
+bool FileExists(const char *filepath, int iMode) {
     MILO_ASSERT((iMode & ~FILE_OPEN_NOARK) == 0, 0x2D5);
-    File* theFile = NewFile(filepath, iMode | 0x40002);
-    if(theFile){
+    File *theFile = NewFile(filepath, iMode | 0x40002);
+    if (theFile) {
         delete theFile;
         return true;
-    }
-    else return false;
+    } else
+        return false;
 }
 
-bool FileReadOnly(const char*){ return true; }
+bool FileReadOnly(const char *) {
+    return true;
+}
 
-const char* FileGetPath(const char* arg1, char* arg2){
+const char *FileGetPath(const char *arg1, char *arg2) {
     static char static_path[256];
     char *p2;
     if (arg2 == 0)
@@ -206,7 +217,7 @@ const char* FileGetPath(const char* arg1, char* arg2){
     return arg2;
 }
 
-const char* FileGetExt(const char* root) {
+const char *FileGetExt(const char *root) {
     const char *end = root + strlen(root);
     for (const char *search = end - 1; search >= root; search--) {
         if (*search == '.') {
@@ -218,40 +229,43 @@ const char* FileGetExt(const char* root) {
     return end;
 }
 
-const char* FileGetDrive(const char* file){
+const char *FileGetDrive(const char *file) {
     static char drive[256];
-    const char* p = strchr(file, ':');
-    if(p != 0){
+    const char *p = strchr(file, ':');
+    if (p != 0) {
         strncpy(drive, file, p - file);
         drive[p - file] = '\0';
-    }
-    else drive[0] = '\0';
+    } else
+        drive[0] = '\0';
     return drive;
 }
 
-const char* FileGetBase(const char* file, char* base){
+const char *FileGetBase(const char *file, char *base) {
     static char my_path[256];
-    const char* dir;
-    char* ext;
-    if(base == 0 && !MainThread())
+    const char *dir;
+    char *ext;
+    if (base == 0 && !MainThread())
         MILO_WARN("FileGetBase called from !MainThread with \"%s\"\n", file);
-    if(base == 0) base = my_path;
+    if (base == 0)
+        base = my_path;
     dir = strrchr(file, '/');
-    if((dir != 0) || (dir = strrchr(file, '\\'), (dir != 0)))
+    if ((dir != 0) || (dir = strrchr(file, '\\'), (dir != 0)))
         strcpy(base, dir + 1);
-    else strcpy(base, file);
+    else
+        strcpy(base, file);
     ext = strrchr(base, '.');
-    if(ext != 0) *ext = 0;
+    if (ext != 0)
+        *ext = 0;
     return base;
 }
 
-const char* FileGetName(const char* file){
+const char *FileGetName(const char *file) {
     static char path[256];
-    const char* dir = strrchr(file, '/');
-    if((dir != 0) || (dir = strrchr(file, '\\'), (dir != 0))){
+    const char *dir = strrchr(file, '/');
+    if ((dir != 0) || (dir = strrchr(file, '\\'), (dir != 0))) {
         strcpy(path, dir + 1);
-    }
-    else strcpy(path, file);
+    } else
+        strcpy(path, file);
     return path;
 }
 
diff --git a/src/system/os/File.h b/src/system/os/File.h
index 6573af64..85162f5a 100644
--- a/src/system/os/File.h
+++ b/src/system/os/File.h
@@ -88,6 +88,8 @@ extern "C" {
     int FileWrite(int iFd, void* iBuff, unsigned int iLen);
     int FileMkDir();
 
+    void FileDiscSpinUp();
+
     bool FileMatch(const char*, const char*);
     void FileEnumerate(const char*, void(*)(const char*, const char*), bool, const char*, bool);
     void FileRecursePattern(const char*, void (*)(char const *,char const *), bool);
diff --git a/src/system/rndobj/PostProc.cpp b/src/system/rndobj/PostProc.cpp
index c45f0a77..22abc105 100644
--- a/src/system/rndobj/PostProc.cpp
+++ b/src/system/rndobj/PostProc.cpp
@@ -10,123 +10,186 @@
 #include "utl/Messages.h"
 #include "utl/Symbols.h"
 
-RndPostProc* RndPostProc::sCurrent = 0;
+RndPostProc *RndPostProc::sCurrent = 0;
 DOFOverrideParams RndPostProc::sDOFOverride;
 
 INIT_REVS(RndPostProc)
 
-RndPostProc::RndPostProc() : mPriority(1.0f), mBloomColor(1.0f, 1.0f, 1.0f, 0.0f), mBloomThreshold(4.0f), mBloomIntensity(0.0f), 
-    mBloomGlare(0), mBloomStreak(0), mBloomStreakAttenuation(0.9f), mBloomStreakAngle(0.0f), mLuminanceMap(this, 0), 
-    mForceCurrentInterp(0), mColorXfm(), mNumLevels(0.0f), mMinIntensity(1.0f), mKaleidoscopeComplexity(0.0f), 
-    mKaleidoscopeSize(0.5f), mKaleidoscopeAngle(0.0f), mKaleidoscopeRadius(0.0f), mKaleidoscopeFlipUVs(1),
-    mFlickerIntensity(0.0f, 0.0f), mFlickerSecsRange(0.001f, 0.007f), unk108(0.0f, 0.0f), unk110(1.0f),
-    mNoiseBaseScale(32.0f, 24.0f), unk11c(1.35914f), mNoiseIntensity(0.0f), mNoiseStationary(0), mNoiseMidtone(1), mNoiseMap(this, 0), 
-    mThreshold(1.0f), mDuration(0.0f), unk13c(1.0f, 1.0f, 0.0f), mEmulateFPS(30.0f), unk14c(0.0f), mHallOfTimeType(0), 
-    mHallOfTimeRate(0.0f), mHallOfTimeColor(1.0f, 1.0f, 1.0f, 0.0f), mHallOfTimeMix(0.0f), mMotionBlurWeight(1.0f, 1.0f, 1.0f, 0.0f),
-    mMotionBlurBlend(0.0f), mMotionBlurVelocity(1), mGradientMap(this, 0), 
-    mGradientMapOpacity(0.0f), mGradientMapIndex(0.0f), mGradientMapStart(0.0f), mGradientMapEnd(1.0f), mRefractMap(this, 0),
-    mRefractDist(0.05f), mRefractScale(1.0f, 1.0f), mRefractPanning(0.0f, 0.0f), mRefractVelocity(0.0f, 0.0f), mRefractAngle(0.0f),
-    mChromaticAberrationOffset(0.0f), mChromaticSharpen(0), mVignetteColor(0.0f, 0.0f, 0.0f, 0.0f), mVignetteIntensity(0.0f) {
+RndPostProc::RndPostProc()
+    : mPriority(1.0f), mBloomColor(1.0f, 1.0f, 1.0f, 0.0f), mBloomThreshold(4.0f),
+      mBloomIntensity(0.0f), mBloomGlare(0), mBloomStreak(0),
+      mBloomStreakAttenuation(0.9f), mBloomStreakAngle(0.0f), mLuminanceMap(this, 0),
+      mForceCurrentInterp(0), mColorXfm(), mPosterLevels(0.0f), mPosterMin(1.0f),
+      mKaleidoscopeComplexity(0.0f), mKaleidoscopeSize(0.5f), mKaleidoscopeAngle(0.0f),
+      mKaleidoscopeRadius(0.0f), mKaleidoscopeFlipUVs(1), mFlickerModBounds(0.0f, 0.0f),
+      mFlickerTimeBounds(0.001f, 0.007f), mFlickerSeconds(0.0f, 0.0f), mColorModulation(1.0f),
+      mNoiseBaseScale(32.0f, 24.0f), mNoiseTopScale(1.35914f), mNoiseIntensity(0.0f),
+      mNoiseStationary(0), mNoiseMidtone(1), mNoiseMap(this, 0), mTrailThreshold(1.0f),
+      mTrailDuration(0.0f), mBlendVec(1.0f, 1.0f, 0.0f), mEmulateFPS(30.0f), mLastRender(0.0f),
+      mHallOfTimeType(0), mHallOfTimeRate(0.0f), mHallOfTimeColor(1.0f, 1.0f, 1.0f, 0.0f),
+      mHallOfTimeMix(0.0f), mMotionBlurWeight(1.0f, 1.0f, 1.0f, 0.0f),
+      mMotionBlurBlend(0.0f), mMotionBlurVelocity(1), mGradientMap(this, 0),
+      mGradientMapOpacity(0.0f), mGradientMapIndex(0.0f), mGradientMapStart(0.0f),
+      mGradientMapEnd(1.0f), mRefractMap(this, 0), mRefractDist(0.05f),
+      mRefractScale(1.0f, 1.0f), mRefractPanning(0.0f, 0.0f),
+      mRefractVelocity(0.0f, 0.0f), mRefractAngle(0.0f), mChromaticAberrationOffset(0.0f),
+      mChromaticSharpen(0), mVignetteColor(0.0f, 0.0f, 0.0f, 0.0f),
+      mVignetteIntensity(0.0f) {
     mColorXfm.Reset();
 }
 
-RndPostProc::~RndPostProc(){
+RndPostProc::~RndPostProc() {
     Unselect();
-    if(TheRnd->GetPostProcOverride() == this) TheRnd->SetPostProcOverride(0);
+    if (TheRnd->GetPostProcOverride() == this)
+        TheRnd->SetPostProcOverride(0);
 }
 
-void RndPostProc::Select(){
-    if(sCurrent != this){
-        if(sCurrent) sCurrent->OnUnselect();
+void RndPostProc::Select() {
+    if (sCurrent != this) {
+        if (sCurrent)
+            sCurrent->OnUnselect();
         sCurrent = this;
         OnSelect();
     }
 }
 
-void RndPostProc::Unselect(){
-    if(sCurrent == this){
+void RndPostProc::Unselect() {
+    if (sCurrent == this) {
         sCurrent->OnUnselect();
         sCurrent = 0;
     }
 }
 
-void RndPostProc::Reset(){
-    if(sCurrent){
+void RndPostProc::Reset() {
+    if (sCurrent) {
         sCurrent->OnUnselect();
         sCurrent = 0;
     }
 }
 
-void RndPostProc::OnSelect(){
+void RndPostProc::OnSelect() {
     TheRnd->RegisterPostProcessor(this);
     Handle(selected_msg, false);
 }
 
-void RndPostProc::OnUnselect(){
+void RndPostProc::OnUnselect() {
     TheRnd->UnregisterPostProcessor(this);
     Handle(unselected_msg, false);
 }
 
-RndPostProc* RndPostProc::Current(){ return sCurrent; }
+RndPostProc *RndPostProc::Current() {
+    return sCurrent;
+}
+
+float RndPostProc::BloomIntensity() const {
+    if (mBloomGlare != 0 && TheHiResScreen->mActive != 0) {
+        return mBloomIntensity / 3.0f;
+    }
+    return mBloomIntensity;
+}
+
+bool RndPostProc::DoGradientMap() const {
+    bool ret = false;
+
+    if ((mGradientMapOpacity > 0.0f) && mGradientMap.mPtr != 0) {
+        ret = 1;
+    }
+    return ret;
+}
+
+bool RndPostProc::DoRefraction() const {
+    bool ret = false;
+
+    if (mRefractMap.mPtr != 0 && (0.0f != mRefractDist)) {
+        ret = 1;
+    }
+    return ret;
+}
+
+bool RndPostProc::DoVignette() const {
+    return mVignetteIntensity != 0.0f;
+}
+
+bool RndPostProc::HallOfTime() const {
+    return mHallOfTimeRate != 0.0f;
+}
 
 // fn_80624B04
-void RndPostProc::UpdateTimeDelta(){
+void RndPostProc::UpdateTimeDelta() {
     float secs = TheTaskMgr.Seconds(TaskMgr::b);
-    float val150 = secs - unk14c;
-    unk150 = val150;
-    unk150 = Clamp(0.0f, 1.0f, val150);
-    unk14c = secs;
+    float val150 = secs - mLastRender;
+    mDeltaSecs = val150;
+    mDeltaSecs = Clamp(0.0f, 1.0f, val150);
+    mLastRender = secs;
 }
 
-void RndPostProc::DoPost(){
+void RndPostProc::DoPost() {
     UpdateTimeDelta();
     UpdateColorModulation();
     UpdateBlendPrevious();
 }
 
 // fn_80624BB4
-void RndPostProc::UpdateColorModulation(){
-    if(mFlickerSecsRange.x > 0 && mFlickerSecsRange.y > 0 && mFlickerIntensity.y > 0){
-        if(unk108.x >= unk108.y){
-            float unk108diff = unk108.x - unk108.y;
-            unk108.x = unk108diff;
+void RndPostProc::UpdateColorModulation() {
+    if (mFlickerTimeBounds.x > 0 && mFlickerTimeBounds.y > 0 && mFlickerModBounds.y > 0) {
+        if (mFlickerSeconds.x >= mFlickerSeconds.y) {
+            float unk108diff = mFlickerSeconds.x - mFlickerSeconds.y;
+            mFlickerSeconds.x = unk108diff;
             float maxed = Max(unk108diff, 0.0f);
-            unk108.x = maxed;
-            unk110 = 1.0f - RandomFloat(mFlickerIntensity.x, mFlickerIntensity.y);
-            unk108.y = RandomFloat(mFlickerSecsRange.x, mFlickerSecsRange.y);
-            float maxed2 = Max(unk108.x, unk108.y);
-            unk108.y = maxed2;
+            mFlickerSeconds.x = maxed;
+            mColorModulation = 1.0f - RandomFloat(mFlickerModBounds.x, mFlickerModBounds.y);
+            mFlickerSeconds.y = RandomFloat(mFlickerTimeBounds.x, mFlickerTimeBounds.y);
+            float maxed2 = Max(mFlickerSeconds.x, mFlickerSeconds.y);
+            mFlickerSeconds.y = maxed2;
         }
-        unk108.x += unk150;
+        mFlickerSeconds.x += mDeltaSecs;
+    } else
+        mColorModulation = 1.0f;
+}
+
+void RndPostProc::UpdateBlendPrevious() {
+    bool shouldBlend = mTrailThreshold < 1.0f && mTrailDuration > 0.0f && !TheHiResScreen->IsActive();
+    if(shouldBlend) {
+        if(mTrailDuration <= 0.0f) {
+            MILO_ASSERT(mTrailDuration > 0.0f, 0xf6);
+        }
+        mBlendVec.x = mTrailThreshold;
+        mBlendVec.y = mDeltaSecs / mTrailDuration;
+        mBlendVec.z = 0.3333333333f;
     }
-    else unk110 = 1.0f;
+    return;
 }
 
 bool RndPostProc::BlendPrevious() const {
-    return mThreshold < 1.0f && mDuration > 0.0f && !TheHiResScreen->IsActive();
+    return mTrailThreshold < 1.0f && mTrailDuration > 0.0f && !TheHiResScreen->IsActive();
 }
 
 SAVE_OBJ(RndPostProc, 524)
 
 BEGIN_LOADS(RndPostProc)
-    LOAD_REVS(bs)
-    ASSERT_REVS(37, 0)
-    if (gRev == 16) {
-        int dRev;
-        bs >> dRev;
-        MILO_ASSERT(dRev == 3, 667);
-        bool x; bs >> x;
-        int a,b,c,d,e;
-        bs >> a >> b >> c >> d >> e;
-    } else Hmx::Object::Load(bs);
-    LoadRev(bs, gRev);
+LOAD_REVS(bs)
+ASSERT_REVS(37, 0)
+if (gRev == 16) {
+    int dRev;
+    bs >> dRev;
+    MILO_ASSERT(dRev == 3, 667);
+    bool x;
+    bs >> x;
+    int a, b, c, d, e;
+    bs >> a >> b >> c >> d >> e;
+} else
+    Hmx::Object::Load(bs);
+LoadRev(bs, gRev);
 END_LOADS
 
-void RndPostProc::LoadRev(BinStream& bs, int rev) {
+void RndPostProc::LoadRev(BinStream &bs, int rev) {
     if (rev > 4) {
         if (rev > 10) {
             bs >> mBloomColor;
-            if (rev < 24) { int x; bs >> x; }
+            if (rev < 24) {
+                int x;
+                bs >> x;
+            }
             bs >> mBloomIntensity;
             bs >> mBloomThreshold;
         } else {
@@ -134,10 +197,27 @@ void RndPostProc::LoadRev(BinStream& bs, int rev) {
             bs >> c;
         }
     }
-    if (rev > 5) bs >> mLuminanceMap;
+    if (rev > 5)
+        bs >> mLuminanceMap;
+
+    if (rev > 7) {
+        bs >> mTrailThreshold;
+        bs >> mTrailDuration;
+        bs >> mEmulateFPS;
+    }
+
+    if (rev > 9 ) {
+        if (rev > 0x12) {
+            // color correction stuff?
+        }
+        bs >> mPosterLevels;
+    }
 
+    if(rev >> 13)
+        bs >> mPosterMin;
 
-    if (rev > 32) bs >> mBloomGlare;
+    if (rev > 32)
+        bs >> mBloomGlare;
     if (rev > 35) {
         bs >> mBloomStreak;
         bs >> mBloomStreakAttenuation;
@@ -146,32 +226,75 @@ void RndPostProc::LoadRev(BinStream& bs, int rev) {
 }
 
 BEGIN_HANDLERS(RndPostProc)
-    HANDLE_SUPERCLASS(Hmx::Object)
-    HANDLE_ACTION(select, Select())
-    HANDLE_ACTION(unselect, Unselect())
-    HANDLE_ACTION(multi_select, OnSelect())
-    HANDLE_ACTION(multi_unselect, OnUnselect())
-    HANDLE_ACTION(interp, Interp(_msg->Obj<RndPostProc>(2), _msg->Obj<RndPostProc>(3), _msg->Float(4)))
-    HANDLE(allowed_normal_map, OnAllowedNormalMap)
-    HANDLE_CHECK(0x3BB)
+HANDLE_SUPERCLASS(Hmx::Object)
+HANDLE_ACTION(select, Select())
+HANDLE_ACTION(unselect, Unselect())
+HANDLE_ACTION(multi_select, OnSelect())
+HANDLE_ACTION(multi_unselect, OnUnselect())
+HANDLE_ACTION(
+    interp, Interp(_msg->Obj<RndPostProc>(2), _msg->Obj<RndPostProc>(3), _msg->Float(4))
+)
+HANDLE(allowed_normal_map, OnAllowedNormalMap)
+HANDLE_CHECK(0x3BB)
 END_HANDLERS
 
-ProcCounter::ProcCounter() : mProcAndLock(0), mCount(0), mSwitch(0), mOdd(0), mFPS(0), mEvenOddDisabled(0), mTriFrameRendering(0) {
-    
-}
+ProcCounter::ProcCounter()
+    : mProcAndLock(0), mCount(0), mSwitch(0), mOdd(0), mFPS(0), mEvenOddDisabled(0),
+      mTriFrameRendering(0) {}
 
-void ProcCounter::SetProcAndLock(bool pandl){
+void ProcCounter::SetProcAndLock(bool pandl) {
     mProcAndLock = pandl;
     mCount = -1;
 }
 
-void ProcCounter::SetEvenOddDisabled(bool eod){
-    if(mEvenOddDisabled == eod) return;
-    else mEvenOddDisabled = eod;
-    if(mEvenOddDisabled) mCount = -1;
+void ProcCounter::SetEvenOddDisabled(bool eod) {
+    if (mEvenOddDisabled == eod)
+        return;
+    else
+        mEvenOddDisabled = eod;
+    if (mEvenOddDisabled)
+        mCount = -1;
 }
 
-DOFOverrideParams::DOFOverrideParams() : mDepthScale(1.0f), mDepthOffset(0.0f), mMinBlurScale(1.0f), mMinBlurOffset(0.0f),
-    mMaxBlurScale(1.0f), mMaxBlurOffset(0.0f), mBlurWidthScale(1.0f) {
+int ProcCounter::ProcCommands() {
+  int count;
+  int retCmd;
+  
+  if ((this->mProcAndLock != false) && (this->mCount == 0)) {
+    return 0;
+  }
+  if (this->mEvenOddDisabled == false) {
+    count = this->mCount;
+    retCmd = 0;
+    if (count == -1) {
+      this->mCount = -1;
+      retCmd = 7;
+    }
+    else if (count == 0) {
+      retCmd = 1;
+    }
+    else if (count == 1) {
+      retCmd = 6;
+      if (this->mTriFrameRendering != false) {
+        retCmd = 4;
+      }
+    }
+    else if (count == 2) {
+      retCmd = 2;
+    }
+    count = this->mCount + 1;
+    this->mCount = count;
+    int compare_value = (mTriFrameRendering != 0) ? 2 : 1;
+
+    if (count > compare_value) {
+      this->mCount = 0;
+    }
+    return retCmd;
+  }
+  return 7;
+
+}
 
-}
\ No newline at end of file
+DOFOverrideParams::DOFOverrideParams()
+    : mDepthScale(1.0f), mDepthOffset(0.0f), mMinBlurScale(1.0f), mMinBlurOffset(0.0f),
+      mMaxBlurScale(1.0f), mMaxBlurOffset(0.0f), mBlurWidthScale(1.0f) {}
\ No newline at end of file
diff --git a/src/system/rndobj/PostProc.h b/src/system/rndobj/PostProc.h
index 058e9902..bf1e083b 100644
--- a/src/system/rndobj/PostProc.h
+++ b/src/system/rndobj/PostProc.h
@@ -27,13 +27,15 @@ class ProcCounter {
 
 class PostProcessor {
 public:
-    PostProcessor(){}
-    virtual ~PostProcessor(){}
-    virtual void BeginWorld(){}
-    virtual void EndWorld(){}
-    virtual void DoPost(){}
-    virtual void OnGPHangRecover(){ OSReport("Base PostProcessor::OnGPHangRecover called.\n"); }
-    virtual float Priority(){ return 1.0f; }
+    PostProcessor() {}
+    virtual ~PostProcessor() {}
+    virtual void BeginWorld() {}
+    virtual void EndWorld() {}
+    virtual void DoPost() {}
+    virtual void OnGPHangRecover() {
+        OSReport("Base PostProcessor::OnGPHangRecover called.\n");
+    }
+    virtual float Priority() { return 1.0f; }
 };
 
 class RndPostProc : public Hmx::Object, public PostProcessor {
@@ -42,46 +44,49 @@ class RndPostProc : public Hmx::Object, public PostProcessor {
     virtual ~RndPostProc();
     OBJ_CLASSNAME(PostProc);
     OBJ_SET_TYPE(PostProc);
-    virtual DataNode Handle(DataArray*, bool);
-    virtual bool SyncProperty(DataNode&, DataArray*, int, PropOp);
-    virtual void Save(BinStream&);
-    virtual void Copy(const Hmx::Object*, Hmx::Object::CopyType);
-    virtual void Load(BinStream&);
+    virtual DataNode Handle(DataArray *, bool);
+    virtual bool SyncProperty(DataNode &, DataArray *, int, PropOp);
+    virtual void Save(BinStream &);
+    virtual void Copy(const Hmx::Object *, Hmx::Object::CopyType);
+    virtual void Load(BinStream &);
 
     virtual void Select();
     virtual void Unselect();
-    virtual void EndWorld(){}
+    virtual void EndWorld() {}
     virtual void DoPost();
-    virtual void OnGPHangRecover(){}
-    virtual void SetPriority(float f){ mPriority = f; }
-    virtual float Priority(){ return mPriority; }
-    virtual void QueueMotionBlurObject(RndDrawable*){}
-    virtual void SetBloomColor(){}
+    virtual void OnGPHangRecover() {}
+    virtual void SetPriority(float f) { mPriority = f; }
+    virtual float Priority() { return mPriority; }
+    virtual void QueueMotionBlurObject(RndDrawable *) {}
+    virtual void SetBloomColor() {}
     virtual void OnSelect();
     virtual void OnUnselect();
-    
+
+    float BloomIntensity() const;
+    bool DoGradientMap() const;
+    bool DoRefraction() const;
+    bool DoVignette() const;
+    bool HallOfTime() const;
     void UpdateTimeDelta();
     void UpdateColorModulation();
     void UpdateBlendPrevious();
-    void Interp(const RndPostProc*, const RndPostProc*, float);
-    void LoadRev(BinStream&, int);
-    DataNode OnAllowedNormalMap(const DataArray*);
+    void Interp(const RndPostProc *, const RndPostProc *, float);
+    void LoadRev(BinStream &, int);
+    DataNode OnAllowedNormalMap(const DataArray *);
     bool BlendPrevious() const;
     float EmulateFPS() const { return mEmulateFPS; }
 
     static void Reset();
-    static RndPostProc* sCurrent;
-    static RndPostProc* Current();
+    static RndPostProc *sCurrent;
+    static RndPostProc *Current();
     static DOFOverrideParams sDOFOverride;
-    static DOFOverrideParams& DOFOverrides(){ return sDOFOverride; }
+    static DOFOverrideParams &DOFOverrides() { return sDOFOverride; }
 
     NEW_OVERLOAD
     DELETE_OVERLOAD
     DECLARE_REVS
     NEW_OBJ(RndPostProc)
-    static void Init(){
-        REGISTER_OBJ_FACTORY(RndPostProc)
-    }
+    static void Init() { REGISTER_OBJ_FACTORY(RndPostProc) }
 
     float mPriority; // 0x20
     Hmx::Color mBloomColor; // 0x24
@@ -93,35 +98,35 @@ class RndPostProc : public Hmx::Object, public PostProcessor {
     float mBloomStreakAngle; // 0x44
     ObjPtr<RndTex, ObjectDir> mLuminanceMap; // 0x48
     bool mForceCurrentInterp;
-    RndColorXfm mColorXfm;
-    float mNumLevels;
-    float mMinIntensity;
+    RndColorXfm mColorXfm; // 0x6c
+    float mPosterLevels;
+    float mPosterMin;
     float mKaleidoscopeComplexity;
     float mKaleidoscopeSize;
     float mKaleidoscopeAngle;
     float mKaleidoscopeRadius;
     bool mKaleidoscopeFlipUVs;
-    Vector2 mFlickerIntensity; // 0xf8
-    Vector2 mFlickerSecsRange; // 0x100
+    Vector2 mFlickerModBounds; // 0xf8
+    Vector2 mFlickerTimeBounds; // 0x100
+    Vector2 mFlickerSeconds;
 
-    Vector2 unk108;
-    float unk110;
+    float mColorModulation;
 
     Vector2 mNoiseBaseScale;
 
-    float unk11c;
+    float mNoiseTopScale;
 
     float mNoiseIntensity;
     bool mNoiseStationary;
     bool mNoiseMidtone;
     ObjPtr<RndTex, ObjectDir> mNoiseMap;
-    float mThreshold; // 0x134
-    float mDuration; // 0x138
+    float mTrailThreshold; // 0x134
+    float mTrailDuration; // 0x138
 
-    Vector3 unk13c;
+    Vector3 mBlendVec; // 0x13c
     float mEmulateFPS; // 0x148
-    float unk14c;
-    float unk150;
+    float mLastRender;
+    float mDeltaSecs;
 
     int mHallOfTimeType;
     float mHallOfTimeRate;