Render into textures, camera room tracking & target UI (all non-working)

include/Camera.h

     static void setUpdateViewFrustum(bool u) { updateViewFrustum = u; }
     static bool getUpdateViewFrustum() { return updateViewFrustum; }
 
+    static void setRoom(int r) { if (room != r) dirty = true; room = r; }
+    static int getRoom() { return room; }
+
+    static void setShowOverlay(bool s) { showOverlay = s; }
+    static bool getShowOverlay() { return showOverlay; }
+
     static bool boxInFrustum(BoundingBox b);
     static void displayFrustum(glm::mat4 MVP);
 
+    static void displayUI();
+
   private:
     static void calculateFrustumPlanes();
 
     static glm::mat4 projection;
     static glm::mat4 view;
     static float rotationDeltaX, rotationDeltaY;
-    static bool updateViewFrustum, dirty;
+    static bool updateViewFrustum, dirty, showOverlay;
+    static int room;
 };
 
 #endif

include/Mesh.h

          const std::vector<IndexedColoredRectangle>& coloredRectangles,
          const std::vector<IndexedColoredRectangle>& coloredTriangles);
     void prepare();
-    void display(glm::mat4 MVP);
+    void display(glm::mat4 MVP, ShaderTexture* shaderTexture = nullptr);
 
   private:
     std::vector<unsigned short> indicesBuff;

include/Render.h

     static bool getDisplayViewFrustum() { return displayViewFrustum; }
 
   private:
-    static void buildRoomList(int room);
+    static void buildRoomList(int room = -2);
 
     static RenderMode mode;
     static std::vector<Room*> roomList;

include/SkeletalModel.h

 
 #include <vector>
 
+#include "system/Shader.h"
+
 class BoneTag {
   public:
     BoneTag(int m, glm::vec3 o, glm::vec3 r, char f) : mesh(m), off(o), rot(r), flag(f) { }
-    void display(glm::mat4 MVP);
+    void display(glm::mat4 MVP, ShaderTexture* shaderTexture = nullptr);
 
     glm::vec3 getOffset() { return off; }
     glm::vec3 getRotation() { return rot; }
   public:
     SkeletalModel(int i) : id(i) { }
     ~SkeletalModel();
-    void display(glm::mat4 MVP, int aframe, int bframe);
+    void display(glm::mat4 MVP, int aframe, int bframe, ShaderTexture* shaderTexture = nullptr);
 
     int getID() { return id; }
 

include/SoundManager.h

 #include <vector>
 
 struct SoundSource {
-    float x, y, z;
+    glm::vec3 pos;
     int id, flags;
 
-    SoundSource(float _x, float _y, float _z, int i, int f)
-        : x(_x), y(_y), z(_z), id(i), flags(f) { }
+    SoundSource(glm::vec3 p, int i, int f)
+        : pos(p), id(i), flags(f) { }
 };
 
 struct SoundDetail {
     static void clear();
     static int prepareSources();
 
-    static void addSoundSource(float x, float y, float z, int id, int flags);
+    static void addSoundSource(glm::vec3 p, int id, int flags);
     static void addSoundMapEntry(int id);
     static void addSoundDetail(int sample, float volume);
     static void addSampleIndex(int index);
 
-    static int sizeSoundMap();
-
     static int getIndex(int index, float* volume = nullptr);
 
     // index --> SoundMap --> SoundDetails --> SampleIndices --> play

include/TextureManager.h

 
     static void display();
 
+    static unsigned int getTextureID(int n, TextureStorage s);
+
   private:
     static std::vector<unsigned int>& getIds(TextureStorage s);
     static std::vector<int>& getUnits(TextureStorage s);

include/system/Shader.h

     int boundSize;
 };
 
+class ShaderTexture {
+  public:
+    ShaderTexture(int w = 512, int h = 512);
+    ~ShaderTexture();
+
+    void clear();
+    void bind();
+    int getTexture() { return texture; }
+
+  private:
+    int width, height;
+    unsigned int framebuffer, depth;
+    int texture;
+};
+
 class Shader {
   public:
     Shader() : programID(-1) { }
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color, unsigned int texture,
                        TextureStorage store = TextureStorage::SYSTEM, unsigned int mode = GL_TRIANGLES,
-                       Shader& shader = textShader);
+                       ShaderTexture* target = nullptr, Shader& shader = textShader);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture, glm::mat4 MVP,
-                       TextureStorage store = TextureStorage::GAME, Shader& shader = textureShader);
+                       TextureStorage store = TextureStorage::GAME, ShaderTexture* target = nullptr,
+                       Shader& shader = textureShader);
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
                        unsigned int texture, glm::mat4 MVP,
-                       TextureStorage store = TextureStorage::GAME, Shader& shader = textureShader);
+                       TextureStorage store = TextureStorage::GAME, ShaderTexture* target = nullptr,
+                       Shader& shader = textureShader);
 
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
-                       unsigned int mode = GL_TRIANGLES, Shader& shader = colorShader);
+                       unsigned int mode = GL_TRIANGLES, ShaderTexture* target = nullptr,
+                       Shader& shader = colorShader);
     static void drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
-                       glm::mat4 MVP, unsigned int mode = GL_TRIANGLES, Shader& shader = colorShader);
+                       glm::mat4 MVP, unsigned int mode = GL_TRIANGLES, ShaderTexture* target = nullptr,
+                       Shader& shader = colorShader);
 
   private:
     int programID;

include/system/Sound.h

     static int numSources(bool atListener = false);
     static int addSource(int buffer, float volume = 1.0f, bool atListener = false, bool loop = false);
 
-    static int sourceAt(int source, float pos[3]);
-    static void listenAt(float pos[3], float orientation[6]);
+    static int sourceAt(int source, glm::vec3 pos);
+    static void listenAt(glm::vec3 pos, glm::vec3 at, glm::vec3 up);
 
     static void play(int source, bool atListener = false);
     static void stopAll();

include/system/SoundAL.h

     static int numSources(bool atListener);
     static int addSource(int buffer, float volume, bool atListener, bool loop);
 
-    static int sourceAt(int source, float pos[3]);
-    static void listenAt(float pos[3], float orientation[6]);
+    static int sourceAt(int source, glm::vec3 pos);
+    static void listenAt(glm::vec3 pos, glm::vec3 at, glm::vec3 up);
 
     static void play(int source, bool atListener);
     static void stopAll();
     static std::vector<unsigned int> sources;
     static std::vector<unsigned int> listenerSources;
 
-    static float lastPosition[3];
+    static glm::vec3 lastPosition;
 };
 
 #endif

src/Camera.cpp

 
 #include <limits>
 
+#include "imgui/imgui.h"
+
 #include "global.h"
 #include "RunTime.h"
 #include "system/Shader.h"
 float Camera::rotationDeltaY = 0.75f;
 bool Camera::updateViewFrustum = true;
 bool Camera::dirty = true;
+bool Camera::showOverlay = false;
+int Camera::room = -1;
 
 void Camera::reset() {
     pos = glm::vec3(0.0f, 0.0f, 0.0f);
     dirty = true;
     projection = glm::mat4(1.0f);
     view = glm::mat4(1.0f);
+    room = -1;
 
     setSize(Window::getSize());
 }
     return updateViewFrustum;
 }
 
+void Camera::displayUI() {
+    if (!showOverlay)
+        return;
+
+    if (ImGui::Begin("Camera Look-At Overlay", &showOverlay, ImVec2(0, 0), -1.0f,
+                     ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize
+                     | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings
+                     | ImGuiWindowFlags_AlwaysAutoResize)) {
+        // TODO
+    }
+    ImGui::End();
+}
+
 // ----------------------------------------------------------------------------
 
 class FrustumPlane {

src/Mesh.cpp

     colorsBuff.clear();
 }
 
-void Mesh::display(glm::mat4 MVP) {
+void Mesh::display(glm::mat4 MVP, ShaderTexture* shaderTexture) {
     if (indicesBuff.size() > 0) {
         unsigned int indexStart = 0;
         unsigned int indexPos = 1;
             std::vector<unsigned short> ind(indicesBuff.begin() + indexStart,
                                             indicesBuff.begin() + indexPos);
             indices.bufferData(ind);
-            Shader::drawGL(vertices, uvs, indices, texture, MVP);
+            Shader::drawGL(vertices, uvs, indices, texture, MVP, TextureStorage::GAME, shaderTexture);
 
             if (indexPos < indicesBuff.size()) {
                 indexStart = indexPos;
     }
 
     if (indicesColor.getSize() > 0)
-        Shader::drawGL(verticesColor, colors, indicesColor, MVP);
+        Shader::drawGL(verticesColor, colors, indicesColor, MVP, GL_TRIANGLES, shaderTexture);
 }
 

src/Render.cpp

     }
 
     if (Camera::update()) {
-        clearRoomList();
-        buildRoomList(-2); // TODO cache room
+        int r = Camera::getRoom();
+        if (r < 0) {
+            clearRoomList();
+            buildRoomList();
+        } else {
+            buildRoomList(r);
+        }
     }
 
     glm::mat4 projection = Camera::getProjectionMatrix();
             item = 2;
         else if (mode == RenderMode::Solid)
             item = 3;
-        if (ImGui::Combo("Render Mode", &item, modeStrings, modeStringCount)) {
+        if (ImGui::Combo("Render Mode##render", &item, modeStrings, modeStringCount)) {
             if (item == 0)
                 mode = RenderMode::LoadScreen;
             else if (item == 1)
         }
         ImGui::SameLine();
         ImGui::Checkbox("Show Frustum##render", &displayViewFrustum);
+        ImGui::SameLine();
+        bool showOverlay = Camera::getShowOverlay();
+        if (ImGui::Checkbox("Overlay", &showOverlay)) {
+            Camera::setShowOverlay(showOverlay);
+        }
+        if (ImGui::Button("Reset Room ID")) {
+            Camera::setRoom(-1);
+        }
 
         ImGui::Separator();
         ImGui::Text("Bounding Boxes:");
 
         ImGui::Separator();
         ImGui::Text("Renderable Objects:");
+        ImGui::Text("Room: ");
+        ImGui::SameLine();
         bool showRoomGeometry = Room::getShowRoomGeometry();
-        if (ImGui::Checkbox("Room Geometry##render", &showRoomGeometry)) {
+        if (ImGui::Checkbox("Geometry##renderroom", &showRoomGeometry)) {
             Room::setShowRoomGeometry(showRoomGeometry);
         }
         ImGui::SameLine();
         bool showRoomModels = Room::getShowRoomModels();
-        if (ImGui::Checkbox("Room Models##render", &showRoomModels)) {
+        if (ImGui::Checkbox("Models##renderroom", &showRoomModels)) {
             Room::setShowRoomModels(showRoomModels);
         }
         ImGui::SameLine();
         bool showRoomSprites = Room::getShowRoomSprites();
-        if (ImGui::Checkbox("Room Sprites##render", &showRoomSprites)) {
+        if (ImGui::Checkbox("Sprites##renderroom", &showRoomSprites)) {
             Room::setShowRoomSprites(showRoomSprites);
         }
 
+        ImGui::Text("Entity: ");
+        ImGui::SameLine();
         bool showEntitySprites = Entity::getShowEntitySprites();
-        if (ImGui::Checkbox("Entity Sprites##render", &showEntitySprites)) {
+        if (ImGui::Checkbox("Sprites##renderentity", &showEntitySprites)) {
             Entity::setShowEntitySprites(showEntitySprites);
         }
         ImGui::SameLine();
         bool showEntityMeshes = Entity::getShowEntityMeshes();
-        if (ImGui::Checkbox("Entity Meshes##render", &showEntityMeshes)) {
+        if (ImGui::Checkbox("Meshes##renderentity", &showEntityMeshes)) {
             Entity::setShowEntityMeshes(showEntityMeshes);
         }
         ImGui::SameLine();
         bool showEntityModels = Entity::getShowEntityModels();
-        if (ImGui::Checkbox("Entity Models##render", &showEntityModels)) {
+        if (ImGui::Checkbox("Models##renderentity", &showEntityModels)) {
             Entity::setShowEntityModels(showEntityModels);
         }
 

src/RunTime.cpp

         ImGui::Text("Frames per Second: %luFPS", fps);
         int size = history.size() - 1;
         if (size > 0) {
-            static bool scroll = true;
+            static bool scroll = false;
             if (scroll) {
                 int start = 0;
                 if (size > 10)

src/SkeletalModel.cpp

 
 #include <glm/gtc/matrix_transform.hpp>
 
-void BoneTag::display(glm::mat4 MVP) {
-    getWorld().getMesh(mesh).display(MVP);
+void BoneTag::display(glm::mat4 MVP, ShaderTexture* shaderTexture) {
+    getWorld().getMesh(mesh).display(MVP, shaderTexture);
 }
 
 // ----------------------------------------------------------------------------
 #include <bitset>
 #endif
 
-void SkeletalModel::display(glm::mat4 MVP, int aframe, int bframe) {
+void SkeletalModel::display(glm::mat4 MVP, int aframe, int bframe, ShaderTexture* shaderTexture) {
     assertLessThan(aframe, size());
     assertLessThan(bframe, get(aframe).size());
 
         glm::mat4 rotate = rotZ * rotX * rotY;
 
         glm::mat4 mod = translate * rotate;
-        tag.display(stack.get() * mod);
+        tag.display(stack.get() * mod, shaderTexture);
 #ifdef DEBUG_MODELS
         Log::get(LOG_DEBUG) << "  --> get (" << cnt << ")" << Log::endl;
 #endif

src/SoundManager.cpp

         int index = getIndex(soundSources.at(i).id, &vol);
         int ret = Sound::addSource(index, vol, false, true);
         assertEqual(ret, i);
-        float pos[3] = { soundSources.at(i).x, soundSources.at(i).y, soundSources.at(i).z };
+        glm::vec3 pos = soundSources.at(i).pos;
         ret = Sound::sourceAt(i, pos);
         assertEqual(ret, 0);
         Sound::play(i, false);
     return 0;
 }
 
-void SoundManager::addSoundSource(float x, float y, float z, int id, int flags) {
-    soundSources.emplace_back(x, y, z, id, flags);
+void SoundManager::addSoundSource(glm::vec3 p, int id, int flags) {
+    soundSources.emplace_back(p, id, flags);
 }
 
 void SoundManager::addSoundMapEntry(int id) {
     sampleIndices.push_back(index);
 }
 
-int SoundManager::sizeSoundMap() {
-    return soundMap.size();
-}
-
 int SoundManager::getIndex(int index, float* volume) {
     if (index <= -1)
         return -1;
 }
 
 void SoundManager::display() {
-    if (ImGui::CollapsingHeader("Sound Map Player")) {
+    if (ImGui::CollapsingHeader("Sound Player")) {
         if (!Sound::getEnabled()) {
             ImGui::Text("Please enable Sound first!");
             if (ImGui::Button("Enable Sound!")) {
                 Sound::setEnabled(true);
             }
+            return;
         } else if (Sound::numBuffers() == 0) {
-            ImGui::Text("Please load a level!");
-        } else {
-            static int index = 0;
-            ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
-            ImGui::SliderInt("##soundslide", &index, 0, sizeSoundMap() - 1);
-            ImGui::PopItemWidth();
-            ImGui::SameLine();
-            if (ImGui::Button("+##soundplus", ImVec2(0, 0), true)) {
-                if (index < (sizeSoundMap() - 1))
-                    index++;
-                else
-                    index = 0;
-            }
-            ImGui::SameLine();
-            if (ImGui::Button("-##soundminus", ImVec2(0, 0), true)) {
-                if (index > 0)
-                    index--;
-                else
-                    index = sizeSoundMap() - 1;
-            }
-            ImGui::SameLine();
-            if (ImGui::Button("Play##soundplay")) {
-                playSound(index);
-            }
+            ImGui::Text("No Sounds currently loaded!");
+            return;
+        }
 
-            ImGui::Text("Index: %d", getIndex(index));
+        static int index = 0;
+        ImGui::Text("Map");
+        ImGui::SameLine();
+        ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
+        ImGui::SliderInt("##soundslide", &index, 0, soundMap.size() - 1);
+        ImGui::PopItemWidth();
+        ImGui::SameLine();
+        if (ImGui::Button("+##soundplus", ImVec2(0, 0), true)) {
+            if (index < (soundMap.size() - 1))
+                index++;
+            else
+                index = 0;
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("-##soundminus", ImVec2(0, 0), true)) {
+            if (index > 0)
+                index--;
+            else
+                index = soundMap.size() - 1;
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Play##soundplay")) {
+            playSound(index);
         }
+        ImGui::SameLine();
+        ImGui::Text("%d", getIndex(index));
     }
 }
 

src/TextureManager.cpp

         getIds(s).push_back(id);
     }
 
-    if (image == nullptr)
-        return slot;
-
     unsigned int glcMode;
     switch (mode) {
         case ColorMode::BGR:
             break;
 
         case ColorMode::ARGB:
-            argb2rgba32(image, width, height);
+            if (image != nullptr)
+                argb2rgba32(image, width, height);
             glcMode = GL_RGBA;
             break;
 
     }
 }
 
+unsigned int TextureManager::getTextureID(int n, TextureStorage s) {
+    assertLessThan(n, getIds(s).size());
+    return getIds(s).at(n);
+}
+
 void TextureManager::addTile(TextureTile* t) {
     tiles.push_back(t);
 }

src/UI.cpp

 #include "Camera.h"
 #include "Console.h"
 #include "Game.h"
+#include "Log.h"
 #include "Menu.h"
 #include "Render.h"
 #include "RunTime.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
+#include "World.h"
 #include "system/Window.h"
 #include "utils/time.h"
 #include "UI.h"
 
+#include <glm/gtc/matrix_transform.hpp>
+
 Shader UI::imguiShader;
 bool UI::visible = false;
 unsigned int UI::fontTex;
 
 void UI::display() {
     if (RunTime::getShowFPS()) {
-        if (ImGui::Begin("Debug Overlay", nullptr, ImVec2(0, 0), 0.3f,
+        if (ImGui::Begin("Debug Overlay", nullptr, ImVec2(0, 0), -1.0f,
                          ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize
                          | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings
                          | ImGuiWindowFlags_AlwaysAutoResize)) {
             ImGui::Text("%d FPS", RunTime::getFPS());
             ImGui::Text("X: %.1f (%.2f)", Camera::getPosition().x, Camera::getRotation().x);
             ImGui::Text("Y: %.2f (%.2f)", Camera::getPosition().y, Camera::getRotation().y);
-            ImGui::Text("Z: %.2f", Camera::getPosition().z);
+            ImGui::Text("Z: %.2f (%d)", Camera::getPosition().z, Camera::getRoom());
 
             auto window = ImGui::GetWindowSize();
             auto screen = Window::getSize();
         ImGui::End();
     }
 
+    if (Game::isLoaded())
+        Camera::displayUI();
+
     Console::display();
 
     if (!visible) {
                 showStyleWindow = !showStyleWindow;
             }
         }
+
+        if (ImGui::CollapsingHeader("ShaderTexture Test")) {
+            static ShaderTexture* st = nullptr;
+            static int index = 0;
+            ImGui::SliderInt("SkeletalModel", &index, 0, getWorld().sizeSkeletalModel() - 1);
+
+            static glm::mat4 MVP(1.0f);
+            static bool dirty = true, redraw = false;
+            static float zoom = 1.0f;
+            static float pos[3];
+            static float rot[3];
+
+            if (ImGui::SliderFloat3("Position", pos, -100.0f, 100.0f)) {
+                dirty = true;
+            }
+            if (ImGui::SliderFloat3("Rotation", rot, -6.0f, 6.0f)) {
+                dirty = true;
+            }
+            if (ImGui::SliderFloat("Zoom", &zoom, -1.0f, 2.0f)) {
+                dirty = true;
+            }
+
+            if (dirty) {
+                static glm::mat4 projection = glm::perspective(45.0f, 1.0f, 0.1f, 2000.0f);
+
+                glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(zoom, zoom, zoom));
+                glm::mat4 rotateX = glm::rotate(glm::mat4(1.0f), rot[0], glm::vec3(1.0f, 0.0f, 0.0f));
+                glm::mat4 rotateY = glm::rotate(glm::mat4(1.0f), rot[1], glm::vec3(0.0f, 1.0f, 0.0f));
+                glm::mat4 rotateZ = glm::rotate(glm::mat4(1.0f), rot[2], glm::vec3(0.0f, 0.0f, 1.0f));
+                glm::mat4 rotate = rotateZ * rotateY * rotateX;
+                glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(pos[0], pos[1], pos[2]));
+                glm::mat4 view = glm::inverse(scale * rotate * translate);
+                MVP = projection * view;
+
+                redraw = true;
+                dirty = false;
+            }
+
+            if ((index >= 0) && (index < getWorld().sizeSkeletalModel())) {
+                auto& sm = getWorld().getSkeletalModel(index);
+                if ((sm.size() > 0) && (sm.get(0).size() > 0)) {
+                    if (ImGui::Button("(Re)Create ShaderTexture...")) {
+                        if (st != nullptr) {
+                            delete st;
+                            st = nullptr;
+                        }
+                        if (st == nullptr) {
+                            st = new ShaderTexture();
+                            redraw = true;
+                        }
+                    }
+                    if ((st != nullptr) && redraw) {
+                        st->clear();
+                        sm.display(MVP, 0, 0, st);
+                        redraw = false;
+                        Log::get(LOG_DEBUG) << "Rendered new ShaderTexture!" << Log::endl;
+                    }
+                } else {
+                    ImGui::Text("Selected SkeletalModel has no animation/frame!");
+                }
+            } else {
+                ImGui::Text("No SkeletalModels loaded!");
+            }
+
+            if (st != nullptr) {
+                auto bm = TextureManager::getBufferManager(st->getTexture(), TextureStorage::SYSTEM);
+                ImGui::Image(bm, ImVec2(ImGui::GetColumnWidth() * 2 / 3,
+                                        ImGui::GetColumnWidth() * 2 / 3));
+            }
+        }
     }
     ImGui::End();
 

src/loader/LoaderTR2.cpp

         // Unknown, 0x40, 0x80 or 0xC0
         uint16_t flags = file.readU16();
 
-        SoundManager::addSoundSource(x, y, z, soundID, flags);
+        SoundManager::addSoundSource(glm::vec3(x, y, z), soundID, flags);
     }
 
     if (numSoundSources > 0)

src/system/Shader.cpp

 
 // ----------------------------------------------------------------------------
 
+static int loadBufferSlot(unsigned char* image = nullptr,
+                          unsigned int width = 256, unsigned int height = 256,
+                          ColorMode mode = ColorMode::RGBA, unsigned int bpp = 32,
+                          TextureStorage s = TextureStorage::GAME,
+                          int slot = -1, bool filter = true);
+
+ShaderTexture::ShaderTexture(int w, int h) : width(w), height(h) {
+    glGenFramebuffers(1, &framebuffer);
+    bind();
+
+    texture = TextureManager::loadBufferSlot(nullptr, width, height, ColorMode::RGBA,
+              32, TextureStorage::SYSTEM, -1, false);
+
+    glGenRenderbuffers(1, &depth);
+    glBindRenderbuffer(GL_RENDERBUFFER, depth);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth);
+
+    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                         TextureManager::getTextureID(texture, TextureStorage::SYSTEM), 0);
+
+    GLenum drawBuffer = GL_COLOR_ATTACHMENT0;
+    glDrawBuffers(1, &drawBuffer);
+
+    assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
+}
+
+ShaderTexture::~ShaderTexture() {
+    glDeleteRenderbuffers(1, &depth);
+    glDeleteFramebuffers(1,  &framebuffer);
+
+    //! \TODO free texture slot
+}
+
+void ShaderTexture::clear() {
+    bind();
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void ShaderTexture::bind() {
+    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
+    glViewport(0, 0, width, height);
+}
+
+// ----------------------------------------------------------------------------
+
 Shader::~Shader() {
     if (programID >= 0)
         glDeleteProgram(programID);
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, glm::vec4 color,
                     unsigned int texture, TextureStorage store, unsigned int mode,
-                    Shader& shader) {
+                    ShaderTexture* target, Shader& shader) {
     assert(vertices.getSize() == uvs.getSize());
     if (mode == GL_TRIANGLES) {
         assert((vertices.getSize() % 3) == 0);
     }
 
+    if (target == nullptr) {
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glViewport(0, 0, Window::getSize().x, Window::getSize().y);
+    } else {
+        target->bind();
+    }
+
     shader.use();
     shader.loadUniform(0, Window::getSize());
     shader.loadUniform(1, texture, store);
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, unsigned int texture,
-                    glm::mat4 MVP, TextureStorage store, Shader& shader) {
+                    glm::mat4 MVP, TextureStorage store, ShaderTexture* target,
+                    Shader& shader) {
     assert(vertices.getSize() == uvs.getSize());
     assert((vertices.getSize() % 3) == 0);
 
+    if (target == nullptr) {
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glViewport(0, 0, Window::getSize().x, Window::getSize().y);
+    } else {
+        target->bind();
+    }
+
     shader.use();
     shader.loadUniform(0, MVP);
     shader.loadUniform(1, texture, store);
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& uvs, ShaderBuffer& indices,
                     unsigned int texture, glm::mat4 MVP, TextureStorage store,
-                    Shader& shader) {
+                    ShaderTexture* target, Shader& shader) {
     assert(vertices.getSize() == uvs.getSize());
     assert((indices.getSize() % 3) == 0);
 
+    if (target == nullptr) {
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glViewport(0, 0, Window::getSize().x, Window::getSize().y);
+    } else {
+        target->bind();
+    }
+
     shader.use();
     shader.loadUniform(0, MVP);
     shader.loadUniform(1, texture, store);
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
-                    unsigned int mode, Shader& shader) {
+                    unsigned int mode, ShaderTexture* target, Shader& shader) {
     assert(vertices.getSize() == colors.getSize());
     if (mode == GL_TRIANGLES) {
         assert((vertices.getSize() % 3) == 0);
     }
 
+    if (target == nullptr) {
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glViewport(0, 0, Window::getSize().x, Window::getSize().y);
+    } else {
+        target->bind();
+    }
+
     shader.use();
     shader.loadUniform(0, MVP);
     vertices.bindBuffer(0, 3);
 }
 
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
-                    glm::mat4 MVP, unsigned int mode, Shader& shader) {
+                    glm::mat4 MVP, unsigned int mode, ShaderTexture* target, Shader& shader) {
     assert(vertices.getSize() == colors.getSize());
     if (mode == GL_TRIANGLES) {
         assert((indices.getSize() % 3) == 0);
     }
 
+    if (target == nullptr) {
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glViewport(0, 0, Window::getSize().x, Window::getSize().y);
+    } else {
+        target->bind();
+    }
+
     shader.use();
     shader.loadUniform(0, MVP);
     vertices.bindBuffer(0, 3);
 
 in vec2 UV;
 
-out vec4 color;
+layout(location = 0) out vec4 color;
 
 uniform sampler2D textureSampler;
 uniform vec4 colorVar;
 
 in vec2 UV;
 
-out vec4 color;
+layout(location = 0) out vec4 color;
 
 uniform sampler2D textureSampler;
 
 layout(location = 0) in vec3 vertexPosition_modelspace;
 layout(location = 1) in vec3 vertexColor;
 
-out vec3 Color;
+out vec3 color;
 
 uniform mat4 MVP;
 
                           vertexPosition_modelspace.z,
                           1);
     gl_Position = vec4(-pos.x, pos.yzw);
-    Color = vertexColor;
+    color = vertexColor;
 }
 )!?!";
 
 const char* Shader::colorShaderFragment = R"!?!(
 #version 330 core
 
-in vec3 Color;
+in vec3 color;
 
-out vec4 color;
+layout(location = 0) out vec4 color_out;
 
 void main() {
-    color = vec4(Color, 1);
+    color_out = vec4(color, 1);
 }
 )!?!";
 

src/system/Sound.cpp

 #endif
 }
 
-int Sound::sourceAt(int source, float pos[3]) {
+int Sound::sourceAt(int source, glm::vec3 pos) {
 #ifdef USING_AL
     return SoundAL::sourceAt(source, pos);
 #else
 #endif
 }
 
-void Sound::listenAt(float pos[3], float orientation[6]) {
+void Sound::listenAt(glm::vec3 pos, glm::vec3 at, glm::vec3 up) {
 #ifdef USING_AL
-    SoundAL::listenAt(pos, orientation);
+    SoundAL::listenAt(pos, at, up);
 #endif
 }
 

src/system/SoundAL.cpp

 std::vector<unsigned int> SoundAL::buffers;
 std::vector<unsigned int> SoundAL::sources;
 std::vector<unsigned int> SoundAL::listenerSources;
-float SoundAL::lastPosition[3] = { 0.0f, 0.0f, 0.0f };
+glm::vec3 SoundAL::lastPosition(0.0f, 0.0f, 0.0f);
 
 int SoundAL::initialize() {
     if (init)
 
     init = true;
     setVolume(volume);
+
+    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);
+    listenAt(lastPosition, at, up);
+
     return 0;
 }
 
         Log::get(LOG_ERROR) << "SoundAL: Error while deleting buffers!" << Log::endl;
     }
 
-    for (int i = 0; i < 3; i++)
-        lastPosition[i] = 0.0f;
-
-    float orientation[6] = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f };
-    listenAt(lastPosition, orientation);
+    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);
+    listenAt(lastPosition, at, up);
 }
 
 int SoundAL::numBuffers() {
         alSourcei(id, AL_LOOPING, AL_TRUE);
 
     if (atListener) {
-        alSourcefv(id, AL_POSITION, lastPosition);
+        alSourcefv(id, AL_POSITION, &lastPosition[0]);
         listenerSources.push_back(id);
         return listenerSources.size() - 1;
     } else {
     }
 }
 
-int SoundAL::sourceAt(int source, float pos[3]) {
+int SoundAL::sourceAt(int source, glm::vec3 pos) {
     if (!init)
         return -1;
 
-    if ((source < 0) || (source >= sources.size()) || (pos == nullptr)) {
+    if ((source < 0) || (source >= sources.size())) {
         Log::get(LOG_ERROR) << "SoundAL: Can't position non-existing source!" << Log::endl;
         return -2;
     }
 
-    alSourcefv(sources.at(source), AL_POSITION, pos);
+    alSourcefv(sources.at(source), AL_POSITION, &pos[0]);
 
     return 0;
 }
 
-void SoundAL::listenAt(float pos[3], float orientation[6]) {
-    if ((!init) || (pos == nullptr) || (orientation == nullptr))
+void SoundAL::listenAt(glm::vec3 pos, glm::vec3 at, glm::vec3 up) {
+    if (!init)
         return;
 
-    alListenerfv(AL_POSITION, pos);
+    float orientation[6] = { at.x, at.y, at.z, up.x, up.y, up.z };
+    alListenerfv(AL_POSITION, &pos[0]);
     alListenerfv(AL_ORIENTATION, orientation);
 
     for (auto& s : listenerSources) {
-        alSourcefv(s, AL_POSITION, pos);
+        alSourcefv(s, AL_POSITION, &pos[0]);
     }
 
-    for (int i = 0; i < 3; i++)
-        lastPosition[i] = pos[i];
+    lastPosition = pos;
 }
 
 void SoundAL::play(int source, bool atListener) {