Fixed crashing TR3 levels. SoundSources working.

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140307 ]
+    * Can now load all TR3 levels without crashing
+    * Sound Sources now working, with (more or less) proper 3D Sound
+    * Fixed bug that caused entities to display the wrong object
+    * Improved Debug UI
+    * Updated imgui
+
     [ 20140306 ]
     * Fixed LoaderTR1, can now also open the Unfinished Business levels
     * Walk key can now be used to increase free-camera movement speed

include/Camera.h

     static void handleControllerAxis(float value, KeyboardButton axis);
 
     //! \fixme The Y axis seems to be the source of all evil?
-    static void setPosition(glm::vec3 p) { pos = glm::vec3(p.x, -p.y, p.z); }
+    static void setPosition(glm::vec3 p) { pos = glm::vec3(p.x, -p.y, p.z); dirty = true; }
     static glm::vec3 getPosition() { return glm::vec3(pos.x, -pos.y, pos.z); }
 
     static glm::vec2 getRotation() { return rot; }

include/SoundManager.h

 
 #include <vector>
 
-struct SoundSource {
-    glm::vec3 pos;
-    int id, flags;
-
+class SoundSource {
+  public:
     SoundSource(glm::vec3 p, int i, int f)
-        : pos(p), id(i), flags(f) { }
+        : pos(p), id(i), flags(f), source(-1) { }
+    void prepare();
+    glm::vec3 getPos() { return pos; }
+    int getID() { return id; }
+    int getFlags() { return flags; }
+    int getSource() { return source; }
+
+  private:
+    glm::vec3 pos;
+    int id, flags, source;
 };
 
-struct SoundDetail {
-    int sample;
-    float volume;
+class SoundDetail {
+  public:
+    SoundDetail(int s, float v) : sample(s), source(-1), volume(v) { }
+    int getSample() { return sample; }
+    float getVolume() { return volume; }
+    int getSource() { return source; }
+    void setSource(int s) { source = s; }
 
-    SoundDetail(int s, float v) : sample(s), volume(v) { }
+  private:
+    int sample, source;
+    float volume;
 };
 
 class SoundManager {
     static void addSoundDetail(int sample, float volume);
     static void addSampleIndex(int index);
 
-    static int getIndex(int index, float* volume = nullptr);
-
     // index --> SoundMap --> SoundDetails --> SampleIndices --> play
+    static int getIndex(int index, float* volume = nullptr, SoundDetail** sd = nullptr);
     static int playSound(int index);
 
+    static void listenAt(glm::vec3 pos, glm::vec3 at, glm::vec3 up);
     static void display();
 
   private:

src/Camera.cpp

 #include "global.h"
 #include "RunTime.h"
 #include "system/Shader.h"
+#include "system/Sound.h"
 #include "system/Window.h"
 #include "Camera.h"
 
     if (updateViewFrustum)
         calculateFrustumPlanes();
 
+    glm::vec3 at(0.0f, 0.0f, -1.0f);
+    glm::vec3 up(0.0f, -1.0f, 0.0f);
+    Sound::listenAt(pos, quaternion * at, quaternion * up);
+
     dirty = false;
     return updateViewFrustum;
 }

src/Entity.cpp

 
 void Entity::display(glm::mat4 VP) {
     if ((cache == -1) || (cacheType == -1)) {
-        for (int i = 0; i < getWorld().sizeSpriteSequence(); i++) {
-            auto& s = getWorld().getSpriteSequence(i);
+        /*
+         * The order in which to look for matching objects with the same ID
+         * seems to be very important!
+         * If sprites and meshes are searched before models, many objects will
+         * be displayed wrong (eg. 'bad guy' becomes 'clothes' in tr2/boat)...
+         */
+
+        for (int i = 0; (i < getWorld().sizeSkeletalModel()) && (cache == -1); i++) {
+            auto& s = getWorld().getSkeletalModel(i);
             if (s.getID() == id) {
-                cacheType = CACHE_SPRITE;
+                cacheType = CACHE_MODEL;
                 cache = i;
                 break;
             }
             }
         }
 
-        for (int i = 0; (i < getWorld().sizeSkeletalModel()) && (cache == -1); i++) {
-            auto& s = getWorld().getSkeletalModel(i);
+        for (int i = 0; i < getWorld().sizeSpriteSequence(); i++) {
+            auto& s = getWorld().getSpriteSequence(i);
             if (s.getID() == id) {
-                cacheType = CACHE_MODEL;
+                cacheType = CACHE_SPRITE;
                 cache = i;
                 break;
             }

src/RunTime.cpp

         }
 
         float vol = Sound::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;
+        if (ImGui::SliderFloat("Volume##runtime", &vol, 0.0f, 1.0f)) {
             Sound::setVolume(vol);
         }
 

src/SoundManager.cpp

 #include "imgui/imgui.h"
 
 #include "global.h"
+#include "Camera.h"
+#include "Log.h"
 #include "system/Sound.h"
 #include "SoundManager.h"
 
+void SoundSource::prepare() {
+    if (source != -1)
+        return;
+
+    float vol;
+    int index = SoundManager::getIndex(id, &vol);
+    if ((index < 0) || (index > Sound::numBuffers())) {
+        Log::get(LOG_ERROR) << "Invalid SoundSource ID (" << index << ", "
+                            << Sound::numBuffers() << ")!" << Log::endl;
+        source = -2;
+    } else {
+        source = Sound::addSource(index, vol, false, true);
+        if (source < 0) {
+            source = -2;
+        } else {
+            int ret = Sound::sourceAt(source, pos);
+            if (ret < 0) {
+                Log::get(LOG_ERROR) << "Error positioning SoundSource " << id << Log::endl;
+            }
+            Sound::play(source, false);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
 std::vector<SoundSource> SoundManager::soundSources;
 std::vector<int> SoundManager::soundMap;
 std::vector<SoundDetail> SoundManager::soundDetails;
 }
 
 int SoundManager::prepareSources() {
-    for (int i = 0; i < soundSources.size(); i++) {
-        float vol;
-        int index = getIndex(soundSources.at(i).id, &vol);
-        int ret = Sound::addSource(index, vol, false, true);
-        assertEqual(ret, i);
-        glm::vec3 pos = soundSources.at(i).pos;
-        ret = Sound::sourceAt(i, pos);
-        assertEqual(ret, 0);
-        Sound::play(i, false);
-    }
-
     for (int i = 0; i < soundMap.size(); i++) {
         float vol;
-        int index = getIndex(i, &vol);
+        SoundDetail* sd;
+        int index = getIndex(i, &vol, &sd);
         if ((index >= 0) && (index < Sound::numBuffers())) {
             int ret = Sound::addSource(index, vol, true, false);
-            assertGreaterThanEqual(ret, 0);
+            if (ret < 0) {
+                Log::get(LOG_ERROR) << "Error adding SoundSource " << index << Log::endl;
+            }
+            sd->setSource(ret);
         }
     }
 
+    for (int i = 0; i < soundSources.size(); i++) {
+        soundSources.at(i).prepare();
+    }
+
     return 0;
 }
 
     sampleIndices.push_back(index);
 }
 
-int SoundManager::getIndex(int index, float* volume) {
+int SoundManager::getIndex(int index, float* volume, SoundDetail** sd) {
     if (index <= -1)
         return -1;
 
 
     SoundDetail s = soundDetails.at(index);
 
+    if (sd != nullptr)
+        *sd = &soundDetails.at(index);
+
     if (volume != nullptr)
-        *volume = s.volume;
+        *volume = s.getVolume();
 
-    if (s.sample <= -1)
+    if (s.getSample() <= -1)
         return -5; // SoundDetail has no entry here (-1)
 
-    if (s.sample >= sampleIndices.size())
+    if (s.getSample() >= sampleIndices.size())
         return -6; // SoundDetail entry is bigger than SampleIndices
 
-    index = sampleIndices.at(s.sample);
+    index = sampleIndices.at(s.getSample());
 
     if (index <= -1)
         return -7; // SampleIndices has no entry here (-1)
 
 int SoundManager::playSound(int index) {
     if ((index >= 0) && (index < soundMap.size())) {
-        if (soundMap.at(index) == -1)
-            return 0;
+        SoundDetail* sd;
+        int i = getIndex(index, nullptr, &sd);
+        if ((i < 0) || (i >= Sound::numBuffers()))
+            return -2;
 
-        int c = 1;
-        for (int i = 0; i < index; i++)
-            if (soundMap.at(i) != -1)
-                c++;
-
-        Sound::play(c, true);
+        Sound::play(sd->getSource(), true);
         return 0;
     } else {
         return -1;
 }
 
 void SoundManager::display() {
+    if (ImGui::CollapsingHeader("Sound Sources")) {
+        ImGui::Columns(5, "soundsources");
+        ImGui::Text("No"); ImGui::NextColumn();
+        ImGui::Text("ID"); ImGui::NextColumn();
+        ImGui::Text("Flags"); ImGui::NextColumn();
+        ImGui::Text("Pos"); ImGui::NextColumn();
+        ImGui::Text("Go"); ImGui::NextColumn();
+        ImGui::Separator();
+        for (int i = 0; i < soundSources.size(); i++) {
+            auto& ss = soundSources.at(i);
+            ImGui::Text("%03d", i);
+            ImGui::NextColumn();
+            ImGui::Text("%d", ss.getID());
+            ImGui::NextColumn();
+            ImGui::Text("%X", ss.getFlags());
+            ImGui::NextColumn();
+            ImGui::Text("%.1f %.1f %.1f", ss.getPos().x, ss.getPos().y, ss.getPos().z);
+            ImGui::NextColumn();
+            ImGui::PushID(i);
+            if (ImGui::Button("Go!")) {
+                Camera::setPosition(ss.getPos());
+            }
+            ImGui::PopID();
+            ImGui::NextColumn();
+        }
+        ImGui::Columns(1);
+    }
+
     if (ImGui::CollapsingHeader("Sound Player")) {
         if (!Sound::getEnabled()) {
             ImGui::Text("Please enable Sound first!");

src/UI.cpp

 }
 
 void UI::display() {
-    if (RunTime::getShowFPS()) {
+    if (RunTime::getShowFPS() && (!getMenu().isVisible())) {
         if (ImGui::Begin("Debug Overlay", nullptr, ImVec2(0, 0), -1.0f,
                          ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize
                          | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings

src/deps/imgui/imconfig.h

 //#define IMGUI_API __declspec( dllexport )
 //#define IMGUI_API __declspec( dllimport )
 
-//---- Don't implement default clipboard handlers for Windows (so as not to link with OpenClipboard() and others Win32 functions)
+//---- Don't implement default handlers for Windows (so as not to link with OpenClipboard() and others Win32 functions)
 //#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCS
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCS
 
 //---- Include imgui_user.inl at the end of imgui.cpp so you can include code that extends ImGui using its private data/functions.
 //#define IMGUI_INCLUDE_IMGUI_USER_INL

src/deps/imgui/imgui.h

     IMGUI_API void          Spacing();
     IMGUI_API void          Columns(int count = 1, const char* id = NULL, bool border=true);    // setup number of columns
     IMGUI_API void          NextColumn();                                                       // next column
-    IMGUI_API float         GetColumnOffset(int column_index = -1);
-    IMGUI_API void          SetColumnOffset(int column_index, float offset);
-    IMGUI_API float         GetColumnWidth(int column_index = -1);
+    IMGUI_API int           GetColumnIndex();                                                   // get current column index
+    IMGUI_API float         GetColumnOffset(int column_index = -1);                             // get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetcolumnsCount() inclusive. column 0 is usually 0.0f and not resizable unless you call this.
+    IMGUI_API void          SetColumnOffset(int column_index, float offset_x);                  // set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column.
+    IMGUI_API float         GetColumnWidth(int column_index = -1);                              // column width (== GetColumnOffset(GetColumnIndex()+1) - GetColumnOffset(GetColumnOffset())
+    IMGUI_API int           GetColumnsCount();                                                  // number of columns (what was passed to Columns())
     IMGUI_API ImVec2        GetCursorPos();                                                     // cursor position is relative to window position
     IMGUI_API float         GetCursorPosX();                                                    // "
     IMGUI_API float         GetCursorPosY();                                                    // "
     const char* (*GetClipboardTextFn)();
     void        (*SetClipboardTextFn)(const char* text);
 
-    // Optional: override memory allocations (default to posix malloc/free). MemFreeFn() may be called with a NULL pointer.
+    // Optional: override memory allocations. MemFreeFn() may be called with a NULL pointer.
+    // (default to posix malloc/free)
     void*       (*MemAllocFn)(size_t sz);
     void        (*MemFreeFn)(void* ptr);
 
     // Optional: notify OS Input Method Editor of the screen position of your cursor for text input position (e.g. when using Japanese/Chinese IME in Windows)
+    // (default to use native imm32 api on Windows)
     void        (*ImeSetInputScreenPosFn)(int x, int y);
+    void*       ImeWindowHandle;            // (Windows) Set this to your HWND to get automatic IME cursor positioning.
 
     //------------------------------------------------------------------
     // Input - Fill before calling NewFrame()
     float               FontSize;           // <user set>      // Height of characters, set during loading (don't change after loading)
     float               Scale;              // = 1.0f          // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
     ImVec2              DisplayOffset;      // = (0.0f,0.0f)   // Offset font rendering by xx pixels
-    ImWchar             FallbackChar;       // = '?'           // Replacement glyph if one isn't found.
+    ImWchar             FallbackChar;       // = '?'           // Replacement glyph if one isn't found. Only set via SetFallbackChar()
 
     // Members: Runtime data
     struct Glyph
     };
     ImFontAtlas*        ContainerAtlas;     // What we has been loaded into
     ImVector<Glyph>     Glyphs;
+    const Glyph*        FallbackGlyph;      // == FindGlyph(FontFallbackChar)
+    float               FallbackXAdvance;   //
     ImVector<float>     IndexXAdvance;      // Glyphs->XAdvance directly indexable (for CalcTextSize functions which are often bottleneck in large UI)
     ImVector<int>       IndexLookup;        // Index glyphs by Unicode code-point
-    const Glyph*        FallbackGlyph;      // == FindGlyph(FontFallbackChar)
 
     // Methods
     IMGUI_API ImFont();
     IMGUI_API void                  Clear();
     IMGUI_API void                  BuildLookupTable();
     IMGUI_API const Glyph*          FindGlyph(unsigned short c) const;
+    IMGUI_API void                  SetFallbackChar(ImWchar c);
     IMGUI_API bool                  IsLoaded() const        { return ContainerAtlas != NULL; }
 
     // 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.

src/system/SoundAL.cpp

 #include "Log.h"
 #include "system/SoundAL.h"
 
+const static float soundTravelSectors = 15.0f;
+const static float referenceDistance = 1024.0f;
+const static float maxDistance = referenceDistance * soundTravelSectors;
+
 bool SoundAL::init = false;
 bool SoundAL::enabled = true;
 float SoundAL::volume = 1.0f;
     init = true;
     setVolume(volume);
 
+    alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED);
+
     lastPosition = glm::vec3(0.0f, 0.0f, 0.0f);
     glm::vec3 at(0.0f, 0.0f, -1.0f);
     glm::vec3 up(0.0f, 1.0f, 0.0f);
 
     alSourcei(id, AL_BUFFER, buffers.at(buffer));
     alSourcef(id, AL_GAIN, volume);
+    alSourcef(id, AL_REFERENCE_DISTANCE, referenceDistance);
+    alSourcef(id, AL_MAX_DISTANCE, maxDistance);
 
     if (loop)
         alSourcei(id, AL_LOOPING, AL_TRUE);