Merge branch 'main' of https://git.kerner.dev/yeet/TSE into DICOM_Viewer

TSE_Core/src/BehaviourScripts/Camera.cpp

@@ -1,217 +1,239 @@
-#include "Camera.hpp"
-#include "elements/Transformable.hpp"
-#include "interfaces/IRenderer.hpp"
-#include "uuid.h"
-
-TSE::Camera* TSE::Camera::mainCamera = nullptr;
-TSE::ICameraHelper* TSE::Camera::helper = nullptr;
-
-float TSE::Camera::GetRenderScale() const
-{
-    return RenderScale;
-}
-
-TSE::ProjectionType TSE::Camera::GetProjection() const
-{
-    return projection;
-}
-
-float TSE::Camera::GetNearClippingPlane() const
-{
-    return nearClippingPlane;
-}
-
-float TSE::Camera::GetFarClippingPlane() const
-{
-    return farClippingPlane;
-}
-
-float TSE::Camera::GetFov() const
-{
-    return fov;
-}
-
-const TSE::Vector2 &TSE::Camera::GetRenderTargetSize() const
-{
-    return lastRtSize;
-}
-
-TSE::Vector3 TSE::Camera::SceenPositionToGamePosition(Vector2 screenPos)
-{
-    float x = 2.0f * screenPos.x / lastRtSize.x -1.0f;
-    float y = 1.0f - 2.0f * screenPos.y / lastRtSize.y;
-    float z = -1.0f;
-    Vector4 ndc(x,y,x,1);
-
-    Matrix4x4 InversProj = Matrix4x4(*projectionMatrix);
-    InversProj.Invert();
-    Vector4 camSpace = InversProj * ndc;
-    camSpace = camSpace / camSpace.w;
-    Vector3 relativPos(camSpace);
-    relativPos.z = 0;
-    return baseObject->LocalToGlobalPosition(relativPos);
-}
-
-void TSE::Camera::SetRenderScale(float v)
-{
-    RenderScale = v; RecalculateProjMatrix();
-}
-
-void TSE::Camera::SetProjection(ProjectionType v)
-{
-    projection = v; RecalculateProjMatrix();
-}
-
-void TSE::Camera::SetNearClippingPlane(float v)
-{
-    nearClippingPlane = v; RecalculateProjMatrix();
-}
-
-void TSE::Camera::SetFarClippingPlane(float v)
-{
-    farClippingPlane = v; RecalculateProjMatrix(); 
-}
-
-void TSE::Camera::SetFov(float v)
-{
-    fov = v; RecalculateProjMatrix();
-}
-
-TSE::Camera::Camera()
-{
-}
-
-TSE::Camera::~Camera()
-{
-    delete(projectionMatrix);
-    if(mainCamera == this)
-        mainCamera = nullptr;
-}
-
-void TSE::Camera::OnResize(float width, float height, IResizable *wnd)
-{
-    lastRtSize = {width, height};
-    RecalculateProjMatrix();
-}
-
-void TSE::Camera::SetRenderTarget(IRenderTarget *target)
-{
-    if(rt != nullptr)
-        rt->RemoveResizeNotifiable(this);
-    if(target != nullptr)
-        target->AddResizeNotifiable(this);
-    rt = target;
-    if(lastRtSize != rt->GetRawIResizableSize())
-    {
-        lastRtSize = rt->GetRawIResizableSize();
-        RecalculateProjMatrix();
-    }
-}
-
-TSE::IRenderTarget *TSE::Camera::GetRenderTarget()
-{
-    return rt;
-}
-
-void TSE::Camera::RecalculateProjMatrix()
-{
-    if(projectionMatrix)
-        delete(projectionMatrix);
-
-    if(projection == ProjectionType::Orthographic)
-    {
-        float x = lastRtSize.x / RenderScale;
-        float y = lastRtSize.y / RenderScale;
-        float mx = -x;
-        float my = -y;
-        projectionMatrix = new Matrix4x4(Matrix4x4::Orthographic(mx, x, my, y, nearClippingPlane, farClippingPlane));
-    }
-    else if(projection == ProjectionType::Perspective)
-    {
-        float x = lastRtSize.x / RenderScale;
-        float y = lastRtSize.y / RenderScale;
-
-        float aspectRatio = x / y;
-
-        projectionMatrix = new Matrix4x4(Matrix4x4::Perspective(fov, aspectRatio, nearClippingPlane, farClippingPlane));
-    }
-}
-
-void TSE::Camera::OnUpdate()
-{
-    if(mainCamera == nullptr && baseObject->name != ".EditorCamera")
-    {
-        mainCamera = this;
-    }
-
-    if(rt != nullptr)
-        IRenderer::camerasToRenderWith.push_back(this);
-}
-
-void TSE::Camera::Start()
-{
-    if(mainCamera == nullptr && baseObject->name != ".EditorCamera")
-    {
-        mainCamera = this;
-    }
-}
-
-
-TSE::Matrix4x4 BuildView_Zplus_RH(const TSE::Matrix4x4& world)
-{
-    using namespace TSE;
-    // Welt-Position (w=1)
-    Vector3 pos = Vector3(world * Vector4(0,0,0,1));
-
-    // Richtungsachsen in Welt (w=0, KEINE Translation!)
-    Vector3 fwdWS = Vector3(world * Vector4(0,0,1,0)); // +Z vorwärts in Welt
-    Vector3 upWS  = Vector3(world * Vector4(0,1,0,0)); // +Y oben in Welt
-
-    // Orthonormale Basis aufbauen (X+ soll "right" sein)
-    Vector3 f = Vector3::Normalize(fwdWS);
-    Vector3 r = Vector3::Normalize(Vector3::Cross(upWS, f)); // right = up × forward  => (+1,0,0) im Identity-Fall
-    Vector3 u = Vector3::Cross(f, r);                        // re-orthonormalisiertes up
-
-    Matrix4x4 view(1.0f); // Identität als Basis
-
-    // Row-major befüllen (Zeilen = r,u,-f), letzte Spalte = -dot(row, pos) bzw. +dot(f,pos)
-    view.m[0][0] = r.x;  view.m[0][1] = r.y;  view.m[0][2] = r.z;  view.m[0][3] = -Vector3::Dot(r, pos);
-    view.m[1][0] = u.x;  view.m[1][1] = u.y;  view.m[1][2] = u.z;  view.m[1][3] = -Vector3::Dot(u, pos);
-    view.m[2][0] = -f.x; view.m[2][1] = -f.y; view.m[2][2] = -f.z; view.m[2][3] =  Vector3::Dot(f, pos);
-    view.m[3][0] = 0.0f; view.m[3][1] = 0.0f; view.m[3][2] = 0.0f; view.m[3][3] = 1.0f;
-
-    return view;
-}
-
-void TSE::Camera::PreDraw(IShader *shader)
-{
-    rt->Bind();
-    shader->SetUniform("prMatrix", projectionMatrix);
-    
-    auto worlmatrix = baseObject->GetGlobalMatrix();
-
-    viewMatrix = BuildView_Zplus_RH(worlmatrix);
-
-    shader->SetUniform("camMatrix", &viewMatrix);
-    helper->OnRenderTargetChanged(lastRtSize.x, lastRtSize.y);
-}
-
-void TSE::Camera::PostDraw()
-{
-    rt->Unbind();
-}
-
-void TSE::Camera::Bind()
-{
-    rt->Bind();
-}
-
-void TSE::Camera::Unbind()
-{
-    rt->Unbind();
-}
-
-void TSE::Camera::UpdateRenderTarget()
-{
-    rt->Update();
-}
+#include "Camera.hpp"
+#include "elements/Transformable.hpp"
+#include "interfaces/IRenderer.hpp"
+#include "uuid.h"
+
+TSE::Camera* TSE::Camera::mainCamera = nullptr;
+TSE::ICameraHelper* TSE::Camera::helper = nullptr;
+
+float TSE::Camera::GetRenderScale() const
+{
+    return RenderScale;
+}
+
+TSE::ProjectionType TSE::Camera::GetProjection() const
+{
+    return projection;
+}
+
+float TSE::Camera::GetNearClippingPlane() const
+{
+    return nearClippingPlane;
+}
+
+float TSE::Camera::GetFarClippingPlane() const
+{
+    return farClippingPlane;
+}
+
+float TSE::Camera::GetFov() const
+{
+    return fov;
+}
+
+const TSE::Vector2 &TSE::Camera::GetRenderTargetSize() const
+{
+    return lastRtSize;
+}
+
+TSE::Vector3 TSE::Camera::SceenPositionToGamePosition(Vector2 screenPos)
+{
+    float x = 2.0f * screenPos.x / lastRtSize.x -1.0f;
+    float y = 1.0f - 2.0f * screenPos.y / lastRtSize.y;
+    float z = -1.0f;
+    Vector4 ndc(x,y,x,1);
+
+    Matrix4x4 InversProj = Matrix4x4(*projectionMatrix);
+    InversProj.Invert();
+    Vector4 camSpace = InversProj * ndc;
+    camSpace = camSpace / camSpace.w;
+    Vector3 relativPos(camSpace);
+    relativPos.z = 0;
+    return baseObject->LocalToGlobalPosition(relativPos);
+}
+
+void TSE::Camera::SetRenderScale(float v)
+{
+    RenderScale = v; RecalculateProjMatrix();
+}
+
+void TSE::Camera::SetProjection(ProjectionType v)
+{
+    projection = v; RecalculateProjMatrix();
+}
+
+void TSE::Camera::SetNearClippingPlane(float v)
+{
+    nearClippingPlane = v; RecalculateProjMatrix();
+}
+
+void TSE::Camera::SetFarClippingPlane(float v)
+{
+    farClippingPlane = v; RecalculateProjMatrix(); 
+}
+
+void TSE::Camera::SetFov(float v)
+{
+    fov = v; RecalculateProjMatrix();
+}
+
+TSE::Camera::Camera()
+{
+}
+
+TSE::Camera::~Camera()
+{
+    delete(projectionMatrix);
+    if(mainCamera == this)
+        mainCamera = nullptr;
+}
+
+void TSE::Camera::OnResize(float width, float height, IResizable *wnd)
+{
+    lastRtSize = {width, height};
+    RecalculateProjMatrix();
+}
+
+void TSE::Camera::SetRenderTarget(IRenderTarget *target)
+{
+    if(rt != nullptr)
+        rt->RemoveResizeNotifiable(this);
+    if(target != nullptr)
+        target->AddResizeNotifiable(this);
+    rt = target;
+    if(lastRtSize != rt->GetRawIResizableSize())
+    {
+        lastRtSize = rt->GetRawIResizableSize();
+        RecalculateProjMatrix();
+    }
+}
+
+TSE::IRenderTarget *TSE::Camera::GetRenderTarget()
+{
+    return rt;
+}
+
+void TSE::Camera::RecalculateProjMatrix()
+{
+    if(projectionMatrix)
+        delete(projectionMatrix);
+
+    if(projection == ProjectionType::Orthographic)
+    {
+        float x = lastRtSize.x / RenderScale;
+        float y = lastRtSize.y / RenderScale;
+        float mx = -x;
+        float my = -y;
+        projectionMatrix = new Matrix4x4(Matrix4x4::Orthographic(mx, x, my, y, nearClippingPlane, farClippingPlane));
+    }
+    else if(projection == ProjectionType::Perspective)
+    {
+        float x = lastRtSize.x / RenderScale;
+        float y = lastRtSize.y / RenderScale;
+
+        float aspectRatio = x / y;
+
+        projectionMatrix = new Matrix4x4(Matrix4x4::Perspective(fov, aspectRatio, nearClippingPlane, farClippingPlane));
+    }
+}
+
+void TSE::Camera::OnUpdate()
+{
+    if(mainCamera == nullptr && baseObject->name != ".EditorCamera")
+    {
+        mainCamera = this;
+    }
+
+    if(rt != nullptr)
+        IRenderer::camerasToRenderWith.push_back(this);
+}
+
+void TSE::Camera::Start()
+{
+    if(mainCamera == nullptr && baseObject->name != ".EditorCamera")
+    {
+        mainCamera = this;
+    }
+}
+
+
+TSE::Matrix4x4 BuildView_Zplus_RH(const TSE::Matrix4x4& world)
+{
+    using namespace TSE;
+    // Welt-Position (w=1)
+    Vector3 pos = Vector3(world * Vector4(0,0,0,1));
+
+    // Richtungsachsen in Welt (w=0, KEINE Translation!)
+    Vector3 fwdWS = Vector3(world * Vector4(0,0,1,0)); // +Z vorwärts in Welt
+    Vector3 upWS  = Vector3(world * Vector4(0,1,0,0)); // +Y oben in Welt
+
+    // Orthonormale Basis aufbauen (X+ soll "right" sein)
+    Vector3 f = Vector3::Normalize(fwdWS);
+    Vector3 r = Vector3::Normalize(Vector3::Cross(upWS, f)); // right = up × forward  => (+1,0,0) im Identity-Fall
+    Vector3 u = Vector3::Cross(f, r);                        // re-orthonormalisiertes up
+
+    Matrix4x4 view(1.0f); // Identität als Basis
+
+    // Row-major befüllen (Zeilen = r,u,-f), letzte Spalte = -dot(row, pos) bzw. +dot(f,pos)
+    view.m[0][0] = r.x;  view.m[0][1] = r.y;  view.m[0][2] = r.z;  view.m[0][3] = -Vector3::Dot(r, pos);
+    view.m[1][0] = u.x;  view.m[1][1] = u.y;  view.m[1][2] = u.z;  view.m[1][3] = -Vector3::Dot(u, pos);
+    view.m[2][0] = -f.x; view.m[2][1] = -f.y; view.m[2][2] = -f.z; view.m[2][3] =  Vector3::Dot(f, pos);
+    view.m[3][0] = 0.0f; view.m[3][1] = 0.0f; view.m[3][2] = 0.0f; view.m[3][3] = 1.0f;
+
+    return view;
+}
+
+void TSE::Camera::PreDraw(IShader *shader)
+{
+    rt->Bind();
+    // shader->SetUniform("prMatrix", projectionMatrix);
+    
+    // auto worlmatrix = baseObject->GetGlobalMatrix();
+
+    // viewMatrix = BuildView_Zplus_RH(worlmatrix);
+
+    // shader->SetUniform("camMatrix", &viewMatrix);
+    // helper->OnRenderTargetChanged(lastRtSize.x, lastRtSize.y);
+
+    Vector3 pos = baseObject->GetGlobalPosition();
+    Vector3 right = baseObject->LocalToGlobalPosition(Vector3::right) - pos;
+    Vector3 up = baseObject->LocalToGlobalPosition(Vector3::up) - pos;
+    Vector3 forward = baseObject->LocalToGlobalPosition(Vector3::forward) - pos;
+    forward.Normalize();
+
+    shader->SetUniform("CamPos", &pos);
+    shader->SetUniform("CamRight", &right);
+    shader->SetUniform("CamUp", &up);
+    shader->SetUniform("CamForward", &forward);
+
+    float x = lastRtSize.x / RenderScale;
+    float y = lastRtSize.y / RenderScale;
+    float mx = -x;
+    float my = -y;
+    shader->SetUniform("OrthoLeft", mx);
+    shader->SetUniform("OrthoRight", x);
+    shader->SetUniform("OrthoBottom", my);
+    shader->SetUniform("OrthoTop", y);
+    shader->SetUniform("NearPlane", nearClippingPlane);
+    shader->SetUniform("FarPlane", farClippingPlane);
+}
+
+void TSE::Camera::PostDraw()
+{
+    rt->Unbind();
+}
+
+void TSE::Camera::Bind()
+{
+    rt->Bind();
+}
+
+void TSE::Camera::Unbind()
+{
+    rt->Unbind();
+}
+
+void TSE::Camera::UpdateRenderTarget()
+{
+    rt->Update();
+}

TSE_Core/src/BehaviourScripts/OrdererSpriteSet.cpp

@@ -1,6 +1,7 @@
 #include "OrdererSpriteSet.hpp"
 #include <algorithm>
 #include <tuple>
+#include "Debug.hpp"
 
 TSE::OrdererSpriteSetChunk::OrdererSpriteSetChunk(int _chunksize, const Vector2 &_pos, SortingOrder _order)
 {
@@ -144,6 +145,8 @@ void TSE::OrdererSpriteSet::SetSprite(Vector2 p, Vector2 Spriteindex, float heig
 {
     Vector2 chunkInnerPos = LocalToChunkPos(p);
     Vector2 chunkIndex = p - chunkInnerPos;
+    // Vector2 p2 = Vector2((int)p.x % chunkSize, (int)p.y % chunkSize);
+    // Vector2 chunkIndex = p - p2;
     if(!chunks.contains(chunkIndex))
     {
         dirty = true;
@@ -175,7 +178,9 @@ const std::vector<TSE::Vector2> *TSE::OrdererSpriteSet::GetChunkPositionsInOrder
         case TopLeft:
             std::sort(orderedChunks.begin(), orderedChunks.end(), [](const Vector2& a, const Vector2& b)
             {
-                return std::tie(a.y, a.x) > std::tie(b.y, b.x);
+                if (a.y != b.y)
+                    return a.y > b.y;
+                return a.x < b.x;
             });
             break;
         case TopRight:
@@ -189,7 +194,9 @@ const std::vector<TSE::Vector2> *TSE::OrdererSpriteSet::GetChunkPositionsInOrder
         case BottomLeft:
             std::sort(orderedChunks.begin(), orderedChunks.end(), [](const Vector2& a, const Vector2& b)
             {
-                return std::tie(a.y, a.x) < std::tie(b.y, b.x);
+                if (a.y != b.y)
+                    return a.y < b.y;
+                return a.x < b.x;
             });
             break;
         case BottomRight:
@@ -203,6 +210,14 @@ const std::vector<TSE::Vector2> *TSE::OrdererSpriteSet::GetChunkPositionsInOrder
         }
 
         dirty = false;
+        string poses = "[";
+        for(auto pos : orderedChunks)
+        {
+            poses += pos.ToString() + ",";
+        }
+        poses.erase(poses.end() - 1);
+        poses += "]";
+        TSE_LOG("orderedPositions: " + poses);
     }
     return &orderedChunks;
 }

TSE_Editor/src/EditorSubsystem.cpp

@@ -3,6 +3,9 @@
 #include "BehaviourScriptRegistry.hpp"
 #include "BehaviourScripts/AudioListener.hpp"
 #include "BehaviourScripts/AudioSource.hpp"
+#include "BehaviourScripts/TileMap.hpp"
+#include "BehaviourScripts/OrdererSpriteSet.hpp"
+#include "BehaviourScripts/PhysicsObject.hpp"
 #include "BehaviourScripts/basicEditorCamera.hpp"
 
 TSE::EDITOR::EditorSubsystem::EditorSubsystem() : sv(nullptr), editorLayer("")
@@ -26,6 +29,9 @@ TSE::EDITOR::EditorSubsystem::EditorSubsystem() : sv(nullptr), editorLayer("")
     BehaviourScriptRegistry::RegisterBehaviourScript("Camera", []() -> BehaviourScript* {return new Camera();});
     BehaviourScriptRegistry::RegisterBehaviourScript("Audio Listener", []() -> BehaviourScript* {return new AudioListener();});
     BehaviourScriptRegistry::RegisterBehaviourScript("Audio Source", []() -> BehaviourScript* {return new AudioSource();});
+    BehaviourScriptRegistry::RegisterBehaviourScript("Tile Map", []() -> BehaviourScript* {return new TileMap();});
+    BehaviourScriptRegistry::RegisterBehaviourScript("Orderer Sprite Set", []() -> BehaviourScript* {return new OrdererSpriteSet();});
+    BehaviourScriptRegistry::RegisterBehaviourScript("Physics Object", []() -> BehaviourScript* { return new PhysicsObject(BodyType::Dynamic, ColliderShape::Box, 1.0f, 0.3f, Vector3(1, 1, 0)); });
 
     #pragma region camerastuff
 
@@ -43,4 +49,4 @@ TSE::EDITOR::EditorSubsystem::EditorSubsystem() : sv(nullptr), editorLayer("")
     editorLayer.SetNonVisual(true);
 
     #pragma endregion
-}
+}

TSE_Editor/src/UI/ElementDrawer.cpp

@@ -208,6 +208,10 @@ namespace TSE::EDITOR
             {
                 Draw((TileMap*)element, debug);
             }
+            else if (name == "Orderer Sprite Set")
+            {
+                Draw((OrdererSpriteSet*)element, debug);
+            }
             else
             {
                 element->CustomDraw(debug);
@@ -915,6 +919,30 @@ namespace TSE::EDITOR
             ImGui::TextDisabled(("Chunk Count: " + std::to_string(element->GetChunkCount())).c_str());
         }
     }
+    void ElementDrawer::Draw(OrdererSpriteSet *element, const bool &debug)
+    {
+        int orderIndex = static_cast<int>(element->order);
+        const char* orderItems[] = { "TopRight", "TopLeft", "BottomRight", "BottomLeft" };
+        if (ImGui::Combo("Order", &orderIndex, orderItems, IM_ARRAYSIZE(orderItems)))
+        {
+            element->order = static_cast<SortingOrder>(orderIndex);
+            for (auto& [_, chunk] : element->chunks)
+            {
+                chunk.SetOrdering(element->order);
+            }
+            element->DirtyAll();
+        }
+
+        ImGui::BeginDisabled();
+        ImGui::DragInt("Chunk Size", &element->chunkSize, 1.0f);
+        ImGui::EndDisabled();
+
+        if (debug)
+        {
+            ImGui::Separator();
+            ImGui::TextDisabled(("Chunk Count: " + std::to_string(element->GetChunkCount())).c_str());
+        }
+    }
     void ElementDrawer::DrawAudioClipCompact(AudioClip *element, const bool &debug, const std::string &label)
     {
         float item_spacing = ImGui::GetStyle().ItemSpacing.x;

TSE_Editor/src/UI/ElementDrawer.hpp

@@ -14,6 +14,7 @@
 #include "BehaviourScripts/AudioListener.hpp"
 #include "BehaviourScripts/AudioSource.hpp"
 #include "BehaviourScripts/TileMap.hpp"
+#include "BehaviourScripts/OrdererSpriteSet.hpp"
 
 namespace TSE::EDITOR
 {
@@ -81,6 +82,7 @@ namespace TSE::EDITOR
         static void Draw(Camera* element, const bool& debug);
         static void Draw(ParticleSystem* element, const bool& debug);
         static void Draw(TileMap* element, const bool& debug);
+        static void Draw(OrdererSpriteSet* element, const bool& debug);
 
         static void DrawAudioClipCompact(AudioClip* element, const bool& debug, const std::string& label);
         static void DrawAudioClipNormal(AudioClip* element, const bool& debug, const std::string& label);

TSE_OpenGlImpl/src/TextureHelperOpenGL.cpp

@@ -1,165 +1,165 @@
-#include "GL/gl3w.h"
-#include "GL/gl.h"
-#include "TextureHelperOpenGL.hpp"
-
-void TSE::OpenGL::TextureHelperOpenGL::Bind(const Texture *tex)
-{
-    glBindTexture(GL_TEXTURE_2D, tex->GetTextureId());
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::UnBind(const Texture *tex)
-{
-    glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::Apply(Texture *tex)
-{
-    glBindTexture(GL_TEXTURE_2D, tex->GetTextureId());
-        if(tex->Chanels() == 1)
-        {
-            if (tex->bpp() == 8)
-                glTexImage2D(GL_TEXTURE_2D, 0,GL_R8, tex->Width(), tex->Height(), 0, GL_RED, GL_UNSIGNED_BYTE, tex->GetImagePtr());
-            if (tex->bpp() == 16)
-                glTexImage2D(GL_TEXTURE_2D, 0, GL_R16I, tex->Width(), tex->Height(), 0, GL_RED, GL_SHORT, tex->GetImagePtr());
-        }
-        if(tex->Chanels() == 3)
-        {
-            if(tex->bpp() == 24)
-                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, tex->Width(), tex->Height(), 0, GL_BGR, GL_UNSIGNED_BYTE, tex->GetImagePtr());
-        }
-        else if(tex->Chanels() == 4)
-        {
-            if(tex->bpp() == 32)
-                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, tex->Width(), tex->Height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, tex->GetImagePtr());
-            if (tex->bpp() == 8) //need to decode it with bitwise operations in shader
-                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA2, tex->Width(), tex->Height(), 0, GL_RED, GL_UNSIGNED_BYTE, tex->GetImagePtr());
-        }
-
-        glGenerateMipmap(GL_TEXTURE_2D);
-
-        glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::Regist(Texture *tex)
-{
-    uint TextureID;
-
-    glGenTextures(1, &TextureID);
-    glBindTexture(GL_TEXTURE_2D, TextureID);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    
-    tex->SetTextureId(TextureID);
-
-    tex->Apply();
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::PlatromDestroy(Texture *tex)
-{
-    uint id = tex->GetTextureId();
-    glDeleteTextures(1, &id);
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::Bind3D(const VolumeTexture3D *tex)
-{
-    glBindTexture(GL_TEXTURE_3D, tex->GetTextureId());
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::UnBind3D(const VolumeTexture3D *tex)
-{
-    glBindTexture(GL_TEXTURE_3D, 0);
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::Apply3D(VolumeTexture3D *tex)
-{
-    glBindTexture(GL_TEXTURE_3D, tex->GetTextureId());
-    ushort internal,input,size;
-
-    if(tex->Chanels() == 1)
-    {
-        if (tex->bpp() == 8)
-        {
-            internal = GL_R8;
-            input = GL_RED;
-            size = GL_UNSIGNED_BYTE;
-        }
-        if (tex->bpp() == 16)
-        {
-            internal = GL_R16I;
-            input = GL_RED;
-            size = GL_SHORT;
-        }
-    }
-    if(tex->Chanels() == 3)
-    {
-        if(tex->bpp() == 24)
-        {
-            internal = GL_RGB;
-            input = GL_BGR;
-            size = GL_UNSIGNED_BYTE;
-        }
-    }
-    else if(tex->Chanels() == 4)
-    {
-        if(tex->bpp() == 32)
-        {
-            internal = GL_RGBA;
-            input = GL_BGRA;
-            size = GL_UNSIGNED_BYTE;
-        }
-        if (tex->bpp() == 8) //need to decode it with bitwise operations in shader
-        {
-            internal = GL_RGBA2;
-            input = GL_RED;
-            size = GL_UNSIGNED_BYTE;
-        }
-    }
-    
-    glTexImage3D(GL_TEXTURE_3D, 0, internal, tex->Width(), tex->Height(), tex->Depth(), 0, input, size, nullptr);
-
-    for (int z = 0; z < tex->Depth(); ++z)
-    {
-        glTexSubImage3D(
-            GL_TEXTURE_3D,
-            0,
-            0,
-            0,
-            z,
-            tex->Width(),
-            tex->Height(),
-            1,
-            input,
-            size,
-            tex->GetImagePtr(z)
-        );
-    }
-
-    glGenerateMipmap(GL_TEXTURE_3D);
-
-    glBindTexture(GL_TEXTURE_3D, 0);
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::Regist3D(VolumeTexture3D *tex)
-{
-    uint TextureID;
-
-    glGenTextures(1, &TextureID);
-    glBindTexture(GL_TEXTURE_3D, TextureID);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-    
-    tex->SetTextureId(TextureID);
-
-    tex->Apply();
-}
-
-void TSE::OpenGL::TextureHelperOpenGL::PlatromDestroy3D(VolumeTexture3D *tex)
-{
-    uint id = tex->GetTextureId();
-    glDeleteTextures(1, &id);
-}
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "TextureHelperOpenGL.hpp"
+
+void TSE::OpenGL::TextureHelperOpenGL::Bind(const Texture *tex)
+{
+    glBindTexture(GL_TEXTURE_2D, tex->GetTextureId());
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::UnBind(const Texture *tex)
+{
+    glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::Apply(Texture *tex)
+{
+    glBindTexture(GL_TEXTURE_2D, tex->GetTextureId());
+        if(tex->Chanels() == 1)
+        {
+            if (tex->bpp() == 8)
+                glTexImage2D(GL_TEXTURE_2D, 0,GL_R8, tex->Width(), tex->Height(), 0, GL_RED, GL_UNSIGNED_BYTE, tex->GetImagePtr());
+            if (tex->bpp() == 16)
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_R16I, tex->Width(), tex->Height(), 0, GL_RED, GL_SHORT, tex->GetImagePtr());
+        }
+        if(tex->Chanels() == 3)
+        {
+            if(tex->bpp() == 24)
+                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, tex->Width(), tex->Height(), 0, GL_BGR, GL_UNSIGNED_BYTE, tex->GetImagePtr());
+        }
+        else if(tex->Chanels() == 4)
+        {
+            if(tex->bpp() == 32)
+                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, tex->Width(), tex->Height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, tex->GetImagePtr());
+            if (tex->bpp() == 8) //need to decode it with bitwise operations in shader
+                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA2, tex->Width(), tex->Height(), 0, GL_RED, GL_UNSIGNED_BYTE, tex->GetImagePtr());
+        }
+
+        glGenerateMipmap(GL_TEXTURE_2D);
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::Regist(Texture *tex)
+{
+    uint TextureID;
+
+    glGenTextures(1, &TextureID);
+    glBindTexture(GL_TEXTURE_2D, TextureID);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    
+    tex->SetTextureId(TextureID);
+
+    tex->Apply();
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::PlatromDestroy(Texture *tex)
+{
+    uint id = tex->GetTextureId();
+    glDeleteTextures(1, &id);
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::Bind3D(const VolumeTexture3D *tex)
+{
+    glBindTexture(GL_TEXTURE_3D, tex->GetTextureId());
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::UnBind3D(const VolumeTexture3D *tex)
+{
+    glBindTexture(GL_TEXTURE_3D, 0);
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::Apply3D(VolumeTexture3D *tex)
+{
+    glBindTexture(GL_TEXTURE_3D, tex->GetTextureId());
+    ushort internal,input,size;
+
+    if(tex->Chanels() == 1)
+    {
+        if (tex->bpp() == 8)
+        {
+            internal = GL_R8;
+            input = GL_RED;
+            size = GL_UNSIGNED_BYTE;
+        }
+        if (tex->bpp() == 16)
+        {
+            internal = GL_R16I;
+            input = GL_RED;
+            size = GL_SHORT;
+        }
+    }
+    if(tex->Chanels() == 3)
+    {
+        if(tex->bpp() == 24)
+        {
+            internal = GL_RGB;
+            input = GL_BGR;
+            size = GL_UNSIGNED_BYTE;
+        }
+    }
+    else if(tex->Chanels() == 4)
+    {
+        if(tex->bpp() == 32)
+        {
+            internal = GL_R16;
+            input = GL_BGRA;
+            size = GL_UNSIGNED_BYTE;
+        }
+        if (tex->bpp() == 8) //need to decode it with bitwise operations in shader
+        {
+            internal = GL_RGBA2;
+            input = GL_RED;
+            size = GL_UNSIGNED_BYTE;
+        }
+    }
+    
+    glTexImage3D(GL_TEXTURE_3D, 0, internal, tex->Width(), tex->Height(), tex->Depth(), 0, input, size, nullptr);
+
+    for (int z = 0; z < tex->Depth(); ++z)
+    {
+        glTexSubImage3D(
+            GL_TEXTURE_3D,
+            0,
+            0,
+            0,
+            z,
+            tex->Width(),
+            tex->Height(),
+            1,
+            input,
+            size,
+            tex->GetImagePtr(z)
+        );
+    }
+
+    //glGenerateMipmap(GL_TEXTURE_3D);
+
+    glBindTexture(GL_TEXTURE_3D, 0);
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::Regist3D(VolumeTexture3D *tex)
+{
+    uint TextureID;
+
+    glGenTextures(1, &TextureID);
+    glBindTexture(GL_TEXTURE_3D, TextureID);
+    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+    
+    tex->SetTextureId(TextureID);
+
+    tex->Apply();
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::PlatromDestroy3D(VolumeTexture3D *tex)
+{
+    uint id = tex->GetTextureId();
+    glDeleteTextures(1, &id);
+}