LoaderTR2 supports Animated Textuers

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141129 ]
+    * LoaderTR2 now supports loading animated textiles
+
     [ 20141128 ]
     * Added FPS Histogram Debug UI
+    * Added RunTime Settings Debug UI
 
     [ 20141127 ]
     * Started work on loading the object texture mapping, with debug UI

include/TextureManager.h

     int numTiles();
     TextureTile& getTile(int index);
 
+    void addAnimatedTile(int index, int tile);
+    int numAnimatedTiles();
+    int getFirstTileAnimation(int index);
+    int getNextTileAnimation(int tile);
+
   private:
     std::vector<unsigned int>& getIds(TextureStorage s);
 
     std::vector<unsigned int> mTextureIdsSystem;
 
     std::vector<TextureTile*> tiles;
+    std::vector<std::vector<int>> animations;
 };
 
 TextureManager& getTextureManager();

src/TextureManager.cpp

     return *tiles.at(index);
 }
 
+void TextureManager::addAnimatedTile(int index, int tile) {
+    while (index >= animations.size())
+        animations.push_back(std::vector<int>());
+
+    animations.at(index).push_back(tile);
+}
+
+int TextureManager::numAnimatedTiles() {
+    return animations.size();
+}
+
+int TextureManager::getFirstTileAnimation(int index) {
+    assert(index < animations.size());
+    assert(animations.at(index).size() > 0);
+    return animations.at(index).at(0);
+}
+
+int TextureManager::getNextTileAnimation(int tile) {
+    for (int a = 0; a < animations.size(); a++) {
+        for (int i = 0; i < animations.at(a).size(); i++) {
+            if (animations.at(a).at(i) == tile) {
+                if (i < (animations.at(a).size() - 1))
+                    return animations.at(a).at(i + 1);
+                else
+                    return animations.at(a).at(0);
+            }
+        }
+    }
+    return -1;
+}
+
 std::vector<unsigned int>& TextureManager::getIds(TextureStorage s) {
     if (s == TextureStorage::GAME)
         return mTextureIdsGame;

src/UI.cpp

  */
 
 #include <algorithm>
+#include <cstring>
 
 #include "global.h"
 #include "Console.h"
     Console::display();
 
     if (ImGui::Begin("Engine")) {
-        if (ImGui::CollapsingHeader("RunTime Info")) {
+        if (ImGui::CollapsingHeader("Engine Info")) {
             ImGui::Text("Uptime: %lums", systemTimerGet());
             ImGui::Text("Frames per Second: %luFPS", getRunTime().getFPS());
             if (getRunTime().getHistoryFPS().size() > 1) {
                 static bool scroll = true;
                 if (scroll) {
                     int offset = getRunTime().getHistoryFPS().size() - 1;
-                    if (offset > 15)
-                        offset = 15;
+                    if (offset > 10)
+                        offset = 10;
                     ImGui::PlotLines("FPS", &getRunTime().getHistoryFPS()[1],
                             getRunTime().getHistoryFPS().size() - 1,
                             getRunTime().getHistoryFPS().size() - offset - 1);
             }
         }
 
+        if (ImGui::CollapsingHeader("RunTime Settings")) {
+            bool showFPS = getRunTime().getShowFPS();
+            if (ImGui::Checkbox("Show FPS##runtime", &showFPS)) {
+                getRunTime().setShowFPS(showFPS);
+            }
+            ImGui::SameLine();
+            bool running = getRunTime().isRunning();
+            if (ImGui::Checkbox("Running (!)##runtime", &running)) {
+                getRunTime().setRunning(running);
+            }
+            ImGui::SameLine();
+            bool sound = getSound().getEnabled();
+            if (ImGui::Checkbox("Sound##runtime", &sound)) {
+                getSound().setEnabled(sound);
+            }
+            ImGui::SameLine();
+            bool fullscreen = getWindow().getFullscreen();
+            if (ImGui::Checkbox("Fullscreen##runtime", &fullscreen)) {
+                getWindow().setFullscreen(fullscreen);
+            }
+
+            float vol = getSound().getVolume();
+            if (ImGui::InputFloat("Volume##runtime", &vol, 0.0f, 0.0f, 3, ImGuiInputTextFlags_EnterReturnsTrue)) {
+                if (vol < 0.0f)
+                    vol = 0.0f;
+                if (vol > 1.0f)
+                    vol = 1.0f;
+                getSound().setVolume(vol);
+            }
+
+            int w = getWindow().getWidth();
+            if (ImGui::InputInt("Width##runtime", &w, 10, 100, ImGuiInputTextFlags_EnterReturnsTrue)) {
+                if (w < 1)
+                    w = 1;
+                getWindow().setSize(w, getWindow().getHeight());
+            }
+            int h = getWindow().getHeight();
+            if (ImGui::InputInt("Height##runtime", &h, 10, 100, ImGuiInputTextFlags_EnterReturnsTrue)) {
+                if (h < 1)
+                    h = 1;
+                getWindow().setSize(getWindow().getWidth(), h);
+            }
+
+            static int fr = 0;
+            char buff[1024];
+            strncpy(buff, getRunTime().getBaseDir().c_str(), 1024);
+            if (ImGui::InputText("BaseDir##runtime", buff, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
+                getRunTime().setBaseDir(buff);
+                fr = getRunTime().getFPS();
+            }
+            if (fr > 0) {
+                ImGui::SameLine();
+                ImGui::Text("Done!##runtime1");
+                fr--;
+            }
+
+            static int fr2 = 0;
+            char buff2[1024];
+            strncpy(buff2, getRunTime().getPakDir().c_str(), 1024);
+            if (ImGui::InputText("PakDir##runtime", buff2, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
+                getRunTime().setPakDir(buff2);
+                fr2 = getRunTime().getFPS();
+            }
+            if (fr2 > 0) {
+                ImGui::SameLine();
+                ImGui::Text("Done!##runtime2");
+                fr2--;
+            }
+
+            static int fr3 = 0;
+            char buff3[1024];
+            strncpy(buff3, getRunTime().getAudioDir().c_str(), 1024);
+            if (ImGui::InputText("AudioDir##runtime", buff3, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
+                getRunTime().setAudioDir(buff3);
+                fr3 = getRunTime().getFPS();
+            }
+            if (fr3 > 0) {
+                ImGui::SameLine();
+                ImGui::Text("Done!##runtime3");
+                fr3--;
+            }
+
+            static int fr4 = 0;
+            char buff4[1024];
+            strncpy(buff4, getRunTime().getDataDir().c_str(), 1024);
+            if (ImGui::InputText("DataDir##runtime", buff4, 1024, ImGuiInputTextFlags_EnterReturnsTrue)) {
+                getRunTime().setDataDir(buff4);
+                fr4 = getRunTime().getFPS();
+            }
+            if (fr4 > 0) {
+                ImGui::SameLine();
+                ImGui::Text("Done!##runtime4");
+                fr4--;
+            }
+        }
+
         static bool visibleTex = false;
         static bool visibleTile = false;
+        static bool visibleAnim = false;
         if (ImGui::CollapsingHeader("Texture Viewer")) {
             static bool game = getGame().isLoaded();
             static int index = 0;
             if (ImGui::Button("Show##texshow")) {
                 visibleTex = true;
                 visibleTile = false;
+                visibleAnim = false;
             }
             ImGui::SameLine();
             if (ImGui::Button("Clear##texclear")) {
                 if (ImGui::Button("Show##tileshow")) {
                     visibleTile = true;
                     visibleTex = false;
+                    visibleAnim = false;
                 }
                 ImGui::SameLine();
                 if (ImGui::Button("Clear##tileclear")) {
                             (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
                 }
             } else {
-                ImGui::Text("Please load a level!");
+                ImGui::Text("Please load a level using the new loader!");
+            }
+        }
+
+        if (ImGui::CollapsingHeader("Animated Textile Viewer")) {
+            if (getTextureManager().numAnimatedTiles() > 0) {
+                static int index = 0;
+                static int tile = getTextureManager().getFirstTileAnimation(index);
+                ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
+                if (ImGui::SliderInt("##animslide", &index, 0, getTextureManager().numAnimatedTiles() - 1)) {
+                    tile = getTextureManager().getFirstTileAnimation(index);
+                }
+                ImGui::PopItemWidth();
+                ImGui::SameLine();
+                if (ImGui::Button("+##animplus", ImVec2(0, 0), true)) {
+                    if (index < (getTextureManager().numAnimatedTiles() - 1))
+                        index++;
+                    else
+                        index = 0;
+                    tile = getTextureManager().getFirstTileAnimation(index);
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("-##animminus", ImVec2(0, 0), true)) {
+                    if (index > 0)
+                        index--;
+                    else
+                        index = getTextureManager().numAnimatedTiles() - 1;
+                    tile = getTextureManager().getFirstTileAnimation(index);
+                }
+                ImGui::SameLine();
+                static int fr = 0;
+                if (ImGui::Button("Show##animshow")) {
+                    visibleAnim = true;
+                    visibleTex = false;
+                    visibleTile = false;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("Clear##animclear")) {
+                    getRender().debugDisplayTextile();
+                    visibleAnim = false;
+                }
+                if (visibleAnim) {
+                    if (fr > 0) {
+                        fr--;
+                    } else {
+                        getRender().debugDisplayTextile(tile,
+                                ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
+                                ImGui::GetWindowPos().y,
+                                (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
+                        fr = getRunTime().getFPS() / 2;
+                        tile = getTextureManager().getNextTileAnimation(tile);
+                    }
+                    ImGui::Text("Current Tile: %d", tile);
+                }
+            } else {
+                ImGui::Text("Please load a level with animated textures!");
             }
         }
 
             }
         }
 
-        /*
-        if (ImGui::CollapsingHeader("UI Help")) {
+        if (ImGui::CollapsingHeader("ImGui UI Help")) {
             ImGui::ShowUserGuide();
         }
-        */
     }
     ImGui::End();
 

src/loader/LoaderTR2.cpp

 
         // TODO store floor data somewhere
     }
+
+    if (numFloorData > 0)
+        getLog() << "LoaderTR2: Found " << numFloorData << " words FloorData, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadMeshes() {
     uint32_t numMeshPointers = file.readU32();
 
     if ((numMeshData == 0) || (numMeshPointers == 0)) {
-        //! \fixme debug level regulating output?
         getLog() << "LoaderTR2: No mesh data found!" << Log::endl;
         return;
     }
 
         // TODO store static meshes somewhere
     }
+
+    if (numStaticMeshes > 0)
+        getLog() << "LoaderTR2: Found " << numStaticMeshes << " StaticMeshes, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadTextures() {
 
         // TODO store cameras somewhere
     }
+
+    if (numCameras > 0)
+        getLog() << "LoaderTR2: Found " << numCameras << " Cameras, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadSoundSources() {
 
         // TODO store sound sources somewhere
     }
+
+    if (numSoundSources > 0)
+        getLog() << "LoaderTR2: Found " << numSoundSources << " SoundSources, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadBoxesOverlapsZones() {
 }
 
 void LoaderTR2::loadAnimatedTextures() {
-    uint32_t numAnimatedTextures = file.readU32();
+    uint32_t numWords = file.readU32() - 1;
+    uint16_t numAnimatedTextures = file.readU16();
     std::vector<uint16_t> animatedTextures;
-    for (unsigned int a = 0; a < numAnimatedTextures; a++) {
+    for (unsigned int a = 0; a < numWords; a++) {
         animatedTextures.push_back(file.readU16());
     }
 
-    // TODO store animated textures somewhere. Format?
+    int pos = 0;
+    for (unsigned int a = 0; a < numAnimatedTextures; a++) {
+        int count = animatedTextures.at(pos) + 1;
+        if ((pos + count) >= numWords) {
+            getLog() << "LoaderTR2: Invalid AnimatedTextures ("
+                << pos + count << " >= " << numWords << ")!" << Log::endl;
+            return;
+        }
+
+        for (int i = 0; i < count; i++) {
+            getTextureManager().addAnimatedTile(a, animatedTextures.at(pos + i + 1));
+        }
+
+        pos += count + 1;
+    }
+
+    if (pos != numWords)
+        getLog() << "LoaderTR2: Extra bytes at end of AnimatedTextures?" << Log::endl;
 }
 
 void LoaderTR2::loadItems() {
 
         // TODO store items somewhere
     }
+
+    if (numItems > 0)
+        getLog() << "LoaderTR2: Found " << numItems << " Items, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadCinematicFrames() {
     }
 
     if (numCinematicFrames > 0)
-        getLog() << "LoaderTR2: Found CinematicFrames, not yet implemented!" << Log::endl;
+        getLog() << "LoaderTR2: Found " << numCinematicFrames
+            << " CinematicFrames, not yet implemented!" << Log::endl;
 }
 
 void LoaderTR2::loadDemoData() {
 
     // TODO store demo data somewhere, find out meaning
     if (numDemoData > 0)
-        getLog() << "LoaderTR2: Found DemoData, not yet implemented!" << Log::endl;
+        getLog() << "LoaderTR2: Found " << numDemoData << " bytes DemoData, not yet implemented!" << Log::endl;
 }
 
 void LoaderTR2::loadSoundMap() {
 
         // TODO store sound details somewhere
     }
+
+    if (numSoundDetails > 0)
+        getLog() << "LoaderTR2: Found " << numSoundDetails << " SoundDetails, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadSampleIndices() {
     }
 
     // TODO store sample indices somewhere
+    if (numSampleIndices > 0)
+        getLog() << "LoaderTR2: Found " << numSampleIndices << " SampleIndices, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadExternalSoundFile(std::string f) {