Split Tileset in TextureImage -> Tileset

Added Texture (by image) update in TextureImage (and tileset)
Added lolimgui first integration pass

src/Makefile.am

@@ -1,7 +1,7 @@
 
 include $(top_srcdir)/build/autotools/common.am
 
-SUBDIRS = bullet lua data . t
+SUBDIRS = bullet lua imgui data . t
 
 noinst_LIBRARIES = liblolcore.a
 
@@ -9,7 +9,8 @@ liblolcore_a_SOURCES = \
     tiler.cpp tiler.h dict.cpp dict.h \
     audio.cpp audio.h scene.cpp scene.h font.cpp font.h \
     entity.cpp entity.h ticker.cpp ticker.h lolgl.h \
-    tileset.cpp tileset.h forge.cpp forge.h video.cpp video.h \
+    textureimage.cpp textureimage.h tileset.cpp tileset.h \
+    forge.cpp forge.h video.cpp video.h \
     world.cpp world.h sample.cpp sample.h sampler.cpp sampler.h \
     profiler.cpp profiler.h text.cpp text.h emitter.cpp emitter.h \
     numeric.h utils.h messageservice.cpp messageservice.h \
@@ -25,8 +26,8 @@ liblolcore_a_SOURCES = \
     $(sdl_sources) \
     $(d3d9_sources) \
     $(android_sources)
-#liblolcore_a_CPPFLAGS = -include-pch $(srcdir)/lol/engine-internal.h.pch $(AM_CPPFLAGS) -I$(srcdir)/bullet -I$(srcdir)/lua
-liblolcore_a_CPPFLAGS = $(AM_CPPFLAGS) -I$(srcdir)/bullet -I$(srcdir)/lua
+#liblolcore_a_CPPFLAGS = -include-pch $(srcdir)/lol/engine-internal.h.pch $(AM_CPPFLAGS) -I$(srcdir)/bullet -I$(srcdir)/lua -I$(srcdir)/imgui
+liblolcore_a_CPPFLAGS = $(AM_CPPFLAGS) -I$(srcdir)/bullet -I$(srcdir)/lua -I$(srcdir)/imgui
 
 EXTRA_DIST += easymesh/easymesh-scanner.l easymesh/easymesh-parser.y
 

src/image/image.cpp

@@ -130,6 +130,15 @@ void Image::DummyFill()
     }
 }
 
+void Image::Copy(uint8_t* pixels, ivec2 const& size, PixelFormat fmt)
+{
+    ASSERT(fmt != PixelFormat::Unknown);
+    SetFormat(fmt);
+    SetSize(size);
+    memcpy(m_data->m_pixels[(int)fmt]->data(), pixels,
+            size.x * size.y * BytesPerPixel(fmt));
+}
+
 void Image::Copy(Image const &other)
 {
     ivec2 size = other.GetSize();

src/imgui/Makefile.am

@@ -0,0 +1,13 @@
+
+include $(top_srcdir)/build/autotools/common.am
+
+noinst_LIBRARIES = libimgui.a
+
+libimgui_a_SOURCES = $(imgui_sources)
+libimgui_a_CPPFLAGS = $(AM_CPPFLAGS)
+
+imgui_sources = \
+    stb_rect_pack.h stb_textedit.h stb_truetype.h \
+    imconfig.h imgui.cpp imgui.h \
+    lolimgui.cpp lolimgui.h
+

src/imgui/lolimgui.cpp

@@ -0,0 +1,299 @@
+//
+//  imGui integration in lolengine
+//
+//  Copyright © 2009-2015 Benjamin "Touky" Huet <huet.benjamin@gmail.com>
+//
+//  This program is free software. It comes without any warranty, to
+//  the extent permitted by applicable law. You can redistribute it
+//  and/or modify it under the terms of the Do What the Fuck You Want
+//  to Public License, Version 2, as published by the WTFPL Task Force.
+//  See http://www.wtfpl.net/ for more details.
+//
+
+#if HAVE_CONFIG_H
+#   include "config.h"
+#endif
+
+#include <cstdio>
+
+#include <lol/engine.h>
+#include "loldebug.h"
+
+using namespace lol;
+
+//-----------------------------------------------------------------------------
+LolImGui::LolImGui()
+{
+    m_drawgroup = DRAWGROUP_HUD;
+}
+LolImGui::~LolImGui()
+{
+    ImGui::GetIO().Fonts->TexID = nullptr;
+    Ticker::Unref(m_font);
+    m_font = nullptr;
+}
+
+//-------------------------------------------------------------------------
+LolImGui* g_lolimgui = nullptr;
+void LolImGui::Init()
+{
+    Ticker::Ref(g_lolimgui = new LolImGui());
+
+    ImGuiIO& io = ImGui::GetIO();
+    //io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB;                 // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
+    //io.KeyMap[ImGuiKey_LeftArrow] = GLFW_KEY_LEFT;
+    //io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
+    //io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP;
+    //io.KeyMap[ImGuiKey_DownArrow] = GLFW_KEY_DOWN;
+    //io.KeyMap[ImGuiKey_Home] = GLFW_KEY_HOME;
+    //io.KeyMap[ImGuiKey_End] = GLFW_KEY_END;
+    //io.KeyMap[ImGuiKey_Delete] = GLFW_KEY_DELETE;
+    //io.KeyMap[ImGuiKey_Backspace] = GLFW_KEY_BACKSPACE;
+    //io.KeyMap[ImGuiKey_Enter] = GLFW_KEY_ENTER;
+    //io.KeyMap[ImGuiKey_Escape] = GLFW_KEY_ESCAPE;
+    //io.KeyMap[ImGuiKey_A] = GLFW_KEY_A;
+    //io.KeyMap[ImGuiKey_C] = GLFW_KEY_C;
+    //io.KeyMap[ImGuiKey_V] = GLFW_KEY_V;
+    //io.KeyMap[ImGuiKey_X] = GLFW_KEY_X;
+    //io.KeyMap[ImGuiKey_Y] = GLFW_KEY_Y;
+    //io.KeyMap[ImGuiKey_Z] = GLFW_KEY_Z;
+
+    //Func pointer
+    io.RenderDrawListsFn = LolImGui::RenderDrawLists;
+    io.SetClipboardTextFn = LolImGui::SetClipboard;
+    io.GetClipboardTextFn = LolImGui::GetClipboard;
+
+    /* nope
+#ifdef _MSC_VER
+    io.ImeWindowHandle = glfwGetWin32Window(g_Window);
+#endif
+    */
+
+    /* Callback not needed but look into these to send IO stuff
+    if (install_callbacks)
+    {
+        glfwSetMouseButtonCallback(window, ImGui_ImplGlfw_MouseButtonCallback);
+        glfwSetScrollCallback(window, ImGui_ImplGlfw_ScrollCallback);
+        glfwSetKeyCallback(window, ImGui_ImplGlFw_KeyCallback);
+        glfwSetCharCallback(window, ImGui_ImplGlfw_CharCallback);
+    }
+    */
+}
+
+/* CALLBACKS
+void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
+{
+if (action == GLFW_PRESS && button >= 0 && button < 3)
+g_MousePressed[button] = true;
+}
+
+void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
+{
+g_MouseWheel += (float)yoffset; // Use fractional mouse wheel, 1.0 unit 5 lines.
+}
+
+void ImGui_ImplGlFw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+ImGuiIO& io = ImGui::GetIO();
+if (action == GLFW_PRESS)
+io.KeysDown[key] = true;
+if (action == GLFW_RELEASE)
+io.KeysDown[key] = false;
+io.KeyCtrl = (mods & GLFW_MOD_CONTROL) != 0;
+io.KeyShift = (mods & GLFW_MOD_SHIFT) != 0;
+}
+
+void ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c)
+{
+ImGuiIO& io = ImGui::GetIO();
+if (c > 0 && c < 0x10000)
+io.AddInputCharacter((unsigned short)c);
+}
+
+*/
+
+void LolImGui::Shutdown()
+{
+    Ticker::Unref(g_lolimgui);
+
+    ImGui::Shutdown();
+}
+
+//-------------------------------------------------------------------------
+static String g_clipboard;
+void LolImGui::SetClipboard(const char* text)
+{
+    g_clipboard = text;
+}
+const char* LolImGui::GetClipboard()
+{
+    return g_clipboard.C();
+}
+
+//-------------------------------------------------------------------------
+void LolImGui::TickGame(float seconds)
+{
+    super::TickGame(seconds);
+
+    ImGuiIO& io = ImGui::GetIO();
+
+    //Init Texture
+    if (!m_font)
+    {
+        ImGuiIO& io = ImGui::GetIO();
+
+        // Build texture
+        unsigned char* pixels;
+        ivec2 size;
+        io.Fonts->GetTexDataAsAlpha8(&pixels, &size.w, &size.h);
+
+        Image* image = new Image();
+        image->Copy(pixels, size, PixelFormat::RGBA_8);
+        image->SetSize(size);
+
+        Ticker::Ref(m_font = new TextureImage("", image));
+
+        //// Create texture
+        //glGenTextures(1, &g_FontTexture);
+        //glBindTexture(GL_TEXTURE_2D, g_FontTexture);
+        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        //glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, pixels);
+
+        //// Store our identifier
+        //io.Fonts->TexID = (void *)(intptr_t)g_FontTexture;
+
+        //return true;
+    }
+    //Texture has been created
+    if (m_font && m_font->GetTexture())
+    {
+        io.Fonts->TexID = (void *)(intptr_t)m_font;
+    }
+
+    // Setup display size (every frame to accommodate for window resizing)
+    vec2 video_size = vec2(0);
+    video_size = vec2(Video::GetSize());
+    io.DisplaySize = ImVec2(video_size.w, video_size.h);
+
+    // Setup time step
+    io.DeltaTime = seconds;
+
+    // Setup inputs
+    // (we already got mouse wheel, keyboard keys & characters from glfw callbacks polled in glfwPollEvents())
+    //double mouse_x, mouse_y;
+    //glfwGetCursorPos(g_Window, &mouse_x, &mouse_y);
+    //mouse_x *= (float)display_w / w;                                                    // Convert mouse coordinates to pixels
+    //mouse_y *= (float)display_h / h;
+    //io.MousePos = ImVec2((float)mouse_x, (float)mouse_y);                               // Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
+
+    /*
+    for (int i = 0; i < 3; i++)
+    {
+        io.MouseDown[i] = g_MousePressed[i] || glfwGetMouseButton(g_Window, i) != 0;    // If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
+        g_MousePressed[i] = false;
+    }
+
+    io.MouseWheel = g_MouseWheel;
+    g_MouseWheel = 0.0f;
+    */
+
+    // Start the frame
+    ImGui::NewFrame();
+
+}
+void LolImGui::TickDraw(float seconds, Scene &scene)
+{
+    super::TickDraw(seconds, scene);
+
+    ImGui::Render();
+}
+
+
+
+
+
+//// Data
+//static GLFWwindow*  g_Window = NULL;
+//static double       g_Time = 0.0f;
+//static bool         g_MousePressed[3] = { false, false, false };
+//static float        g_MouseWheel = 0.0f;
+//static GLuint       g_FontTexture = 0;
+
+//-------------------------------------------------------------------------
+// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
+// If text or lines are blurry when integrating ImGui in your engine:
+// - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
+//-------------------------------------------------------------------------
+void LolImGui::RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count)
+{
+    if (cmd_lists_count == 0)
+        return;
+
+    /*
+    // We are using the OpenGL fixed pipeline to make the example code simpler to read!
+    // A probable faster way to render would be to collate all vertices from all cmd_lists into a single vertex buffer.
+    // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers.
+    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glEnable(GL_TEXTURE_2D);
+
+    // Setup orthographic projection matrix
+    const float width = ImGui::GetIO().DisplaySize.x;
+    const float height = ImGui::GetIO().DisplaySize.y;
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadIdentity();
+    glOrtho(0.0f, width, height, 0.0f, -1.0f, +1.0f);
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+
+    // Render command lists
+#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
+    for (int n = 0; n < cmd_lists_count; n++)
+    {
+        const ImDrawList* cmd_list = cmd_lists[n];
+        const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->vtx_buffer.front();
+        glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, pos)));
+        glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, uv)));
+        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, col)));
+
+        int vtx_offset = 0;
+        for (size_t cmd_i = 0; cmd_i < cmd_list->commands.size(); cmd_i++)
+        {
+            const ImDrawCmd* pcmd = &cmd_list->commands[cmd_i];
+            if (pcmd->user_callback)
+            {
+                pcmd->user_callback(cmd_list, pcmd);
+            }
+            else
+            {
+                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->texture_id);
+                glScissor((int)pcmd->clip_rect.x, (int)(height - pcmd->clip_rect.w), (int)(pcmd->clip_rect.z - pcmd->clip_rect.x), (int)(pcmd->clip_rect.w - pcmd->clip_rect.y));
+                glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
+            }
+            vtx_offset += pcmd->vtx_count;
+        }
+    }
+#undef OFFSETOF
+
+    // Restore modified state
+    glDisableClientState(GL_COLOR_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glPopAttrib();
+    */
+}
+

src/imgui/lolimgui.h

@@ -0,0 +1,64 @@
+//
+//  imGui integration in lolengine
+//
+//  Copyright © 2009-2015 Benjamin "Touky" Huet <huet.benjamin@gmail.com>
+//
+//  This program is free software. It comes without any warranty, to
+//  the extent permitted by applicable law. You can redistribute it
+//  and/or modify it under the terms of the Do What the Fuck You Want
+//  to Public License, Version 2, as published by the WTFPL Task Force.
+//  See http://www.wtfpl.net/ for more details.
+//
+
+#pragma once
+
+#include "imgui.h"
+
+namespace lol
+{
+
+//LolImGui --------------------------------------------------------------------
+class LolImGui : public Entity
+{
+    typedef Entity super;
+
+    //-------------------------------------------------------------------------
+    LolImGui();
+    ~LolImGui();
+    char const *GetName() { return "<LolImGui>"; }
+
+    //-------------------------------------------------------------------------
+    static void Init();
+    static void Shutdown();
+
+    //-------------------------------------------------------------------------
+    static void SetClipboard(const char* text);
+    static const char* GetClipboard();
+
+protected:
+    virtual void TickGame(float seconds);
+    virtual void TickDraw(float seconds, Scene &scene);
+
+    static void RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count);
+
+    TextureImage* m_font = nullptr;
+};
+
+//bool        ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks);
+//void        ImGui_ImplGlfw_Shutdown();
+//void        ImGui_ImplGlfw_NewFrame();
+//
+//// Use if you want to reset your rendering device without losing ImGui state.
+//void        ImGui_ImplGlfw_InvalidateDeviceObjects();
+//bool        ImGui_ImplGlfw_CreateDeviceObjects();
+//
+//// GLFW callbacks (installed by default if you enable 'install_callbacks' during initialization)
+//// Provided here if you want to chain callbacks.
+//// You can also handle inputs yourself and use those as a reference.
+//void        ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
+//void        ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
+//void        ImGui_ImplGlFw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
+//void        ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c);
+
+
+} /* namespace lol */

src/imgui/lolimgui.vcxproj

@@ -62,14 +62,21 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="imgui.cpp" />
+    <ClCompile Include="lolimgui.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="imgui.h" />
     <ClInclude Include="imconfig.h" />
+    <ClInclude Include="lolimgui.h" />
     <ClInclude Include="stb_rect_pack.h" />
     <ClInclude Include="stb_textedit.h" />
     <ClInclude Include="stb_truetype.h" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="Makefile.am">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+    </None>
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
     <Import Project="$(SolutionDir)\msbuild\lolfx.targets" />

src/lol/extras.h

@@ -42,9 +42,11 @@
 #include <lol/../sample.h>
 #include <lol/../sprite.h>
 #include <lol/../text.h>
+#include <lol/../textureimage.h>
 #include <lol/../tileset.h>
 #include <lol/../lolua/baselua.h>
 #include <lol/../world.h>
+#include <lol/../imgui/lolimgui.h>
 
 // Other objects
 #include <lol/../dict.h>

src/lol/image/image.h

@@ -72,6 +72,7 @@ public:
     ~Image();
 
     void DummyFill();
+    void Copy(uint8_t* pixels, ivec2 const& size, PixelFormat fmt);
     void Copy(Image const &other);
     bool Load(char const *path);
     bool Save(char const *path);

src/lol/math/vector.h

@@ -277,42 +277,43 @@ struct vec_t<T,2>
 
     union
     {
-        struct { T x, y; };
-        struct { T r, g; };
-        struct { T s, t; };
-        struct { T r, t; };
+        struct { T x, y; }; /* axis */
+        struct { T r, g; }; /* red, green */
+        struct { T s, t; }; 
+        struct { T r, t; }; /* radius, theta */
+        struct { T w, h; }; /* width, height */
 
 #if !_DOXYGEN_SKIP_ME
-        vec_t<T, 2, 9000> const xx, rr, ss/**/;
-        vec_t<T, 2, 9001> _____ xy, rg, st, rt;
-        vec_t<T, 2, 9010> _____ yx, gr, ts, tr;
-        vec_t<T, 2, 9011> const yy, gg, tt/**/;
-
-        vec_t<T, 3, 90000> const xxx, rrr, sss /**/;
-        vec_t<T, 3, 90001> const xxy, rrg, sst, rrt;
-        vec_t<T, 3, 90010> const xyx, rgr, sts, rtr;
-        vec_t<T, 3, 90011> const xyy, rgg, stt, rtt;
-        vec_t<T, 3, 90100> const yxx, grr, tss, trr;
-        vec_t<T, 3, 90101> const yxy, grg, tst, trt;
-        vec_t<T, 3, 90110> const yyx, ggr, tts, ttr;
-        vec_t<T, 3, 90111> const yyy, ggg, ttt /**/;
-
-        vec_t<T, 4, 900000> const xxxx, rrrr, ssss  /**/;
-        vec_t<T, 4, 900001> const xxxy, rrrg, ssst, rrrt;
-        vec_t<T, 4, 900010> const xxyx, rrgr, ssts, rrtr;
-        vec_t<T, 4, 900011> const xxyy, rrgg, sstt, rrtt;
-        vec_t<T, 4, 900100> const xyxx, rgrr, stss, rtrr;
-        vec_t<T, 4, 900101> const xyxy, rgrg, stst, rtrt;
-        vec_t<T, 4, 900110> const xyyx, rggr, stts, rttr;
-        vec_t<T, 4, 900111> const xyyy, rggg, sttt, rttt;
-        vec_t<T, 4, 901000> const yxxx, grrr, tsss, trrr;
-        vec_t<T, 4, 901001> const yxxy, grrg, tsst, trrt;
-        vec_t<T, 4, 901010> const yxyx, grgr, tsts, trtr;
-        vec_t<T, 4, 901011> const yxyy, grgg, tstt, trtt;
-        vec_t<T, 4, 901100> const yyxx, ggrr, ttss, ttrr;
-        vec_t<T, 4, 901101> const yyxy, ggrg, ttst, ttrt;
-        vec_t<T, 4, 901110> const yyyx, gggr, ttts, tttr;
-        vec_t<T, 4, 901111> const yyyy, gggg, tttt  /**/;
+        vec_t<T, 2, 9000> const xx, rr, ss/**/, ww;
+        vec_t<T, 2, 9001> _____ xy, rg, st, rt, wh;
+        vec_t<T, 2, 9010> _____ yx, gr, ts, tr, hw;
+        vec_t<T, 2, 9011> const yy, gg, tt/**/, hh;
+
+        vec_t<T, 3, 90000> const xxx, rrr, sss /**/, www;
+        vec_t<T, 3, 90001> const xxy, rrg, sst, rrt, wwh;
+        vec_t<T, 3, 90010> const xyx, rgr, sts, rtr, whw;
+        vec_t<T, 3, 90011> const xyy, rgg, stt, rtt, whh;
+        vec_t<T, 3, 90100> const yxx, grr, tss, trr, hww;
+        vec_t<T, 3, 90101> const yxy, grg, tst, trt, hwh;
+        vec_t<T, 3, 90110> const yyx, ggr, tts, ttr, hhw;
+        vec_t<T, 3, 90111> const yyy, ggg, ttt /**/, hhh;
+
+        vec_t<T, 4, 900000> const xxxx, rrrr, ssss  /**/, wwww;
+        vec_t<T, 4, 900001> const xxxy, rrrg, ssst, rrrt, wwwh;
+        vec_t<T, 4, 900010> const xxyx, rrgr, ssts, rrtr, wwhw;
+        vec_t<T, 4, 900011> const xxyy, rrgg, sstt, rrtt, wwhh;
+        vec_t<T, 4, 900100> const xyxx, rgrr, stss, rtrr, whww;
+        vec_t<T, 4, 900101> const xyxy, rgrg, stst, rtrt, whwh;
+        vec_t<T, 4, 900110> const xyyx, rggr, stts, rttr, whhw;
+        vec_t<T, 4, 900111> const xyyy, rggg, sttt, rttt, whhh;
+        vec_t<T, 4, 901000> const yxxx, grrr, tsss, trrr, hwww;
+        vec_t<T, 4, 901001> const yxxy, grrg, tsst, trrt, hwwh;
+        vec_t<T, 4, 901010> const yxyx, grgr, tsts, trtr, hwhw;
+        vec_t<T, 4, 901011> const yxyy, grgg, tstt, trtt, hwhh;
+        vec_t<T, 4, 901100> const yyxx, ggrr, ttss, ttrr, hhww;
+        vec_t<T, 4, 901101> const yyxy, ggrg, ttst, ttrt, hhwh;
+        vec_t<T, 4, 901110> const yyyx, gggr, ttts, tttr, hhhw;
+        vec_t<T, 4, 901111> const yyyy, gggg, tttt  /**/, hhhh;
 #endif
 
         T m_data[count];
@@ -434,49 +435,50 @@ struct vec_t<T,3>
 
     union
     {
-        struct { T x, y, z; };
-        struct { T r, g, b; };
+        struct { T x, y, z; }; /* axis */
+        struct { T r, g, b; }; /* red, green, blue */
         struct { T s, t, p; };
-        struct { T r, t, p; };
+        struct { T r, t, p; }; /* radius, theta, phi */
+        struct { T w, h, d; }; /* width, height, depth */
 
 #if !_DOXYGEN_SKIP_ME
-        vec_t<T, 2, 9000> const xx, rr, ss/**/;
-        vec_t<T, 2, 9001> _____ xy, rg, st, rt;
-        vec_t<T, 2, 9002> _____ xz, rb, sp, rp;
-        vec_t<T, 2, 9010> _____ yx, gr, ts, tr;
-        vec_t<T, 2, 9011> const yy, gg, tt/**/;
-        vec_t<T, 2, 9012> _____ yz, gb, tp/**/;
-        vec_t<T, 2, 9020> _____ zx, br, ps, pr;
-        vec_t<T, 2, 9021> _____ zy, bg, pt/**/;
-        vec_t<T, 2, 9022> const zz, bb, pp/**/;
-
-        vec_t<T, 3, 90000> const xxx, rrr, sss /**/;
-        vec_t<T, 3, 90001> const xxy, rrg, sst, rrt;
-        vec_t<T, 3, 90002> const xxz, rrb, ssp, rrp;
-        vec_t<T, 3, 90010> const xyx, rgr, sts, rtr;
-        vec_t<T, 3, 90011> const xyy, rgg, stt, rtt;
-        vec_t<T, 3, 90012> _____ xyz, rgb, stp, rtp;
-        vec_t<T, 3, 90020> const xzx, rbr, sps, rpr;
-        vec_t<T, 3, 90021> _____ xzy, rbg, spt, rpt;
-        vec_t<T, 3, 90022> const xzz, rbb, spp, rpp;
-        vec_t<T, 3, 90100> const yxx, grr, tss, trr;
-        vec_t<T, 3, 90101> const yxy, grg, tst, trt;
-        vec_t<T, 3, 90102> _____ yxz, grb, tsp, trp;
-        vec_t<T, 3, 90110> const yyx, ggr, tts, ttr;
-        vec_t<T, 3, 90111> const yyy, ggg, ttt /**/;
-        vec_t<T, 3, 90112> const yyz, ggb, ttp /**/;
-        vec_t<T, 3, 90120> _____ yzx, gbr, tps, tpr;
-        vec_t<T, 3, 90121> const yzy, gbg, tpt /**/;
-        vec_t<T, 3, 90122> const yzz, gbb, tpp /**/;
-        vec_t<T, 3, 90200> const zxx, brr, pss, prr;
-        vec_t<T, 3, 90201> _____ zxy, brg, pst, prt;
-        vec_t<T, 3, 90202> const zxz, brb, psp, prp;
-        vec_t<T, 3, 90210> _____ zyx, bgr, pts, ptr;
-        vec_t<T, 3, 90211> const zyy, bgg, ptt /**/;
-        vec_t<T, 3, 90212> const zyz, bgb, ptp /**/;
-        vec_t<T, 3, 90220> const zzx, bbr, pps, ppr;
-        vec_t<T, 3, 90221> const zzy, bbg, ppt /**/;
-        vec_t<T, 3, 90222> const zzz, bbb, ppp /**/;
+        vec_t<T, 2, 9000> const xx, rr, ss/**/, ww;
+        vec_t<T, 2, 9001> _____ xy, rg, st, rt, wh;
+        vec_t<T, 2, 9002> _____ xz, rb, sp, rp, wd;
+        vec_t<T, 2, 9010> _____ yx, gr, ts, tr, hw;
+        vec_t<T, 2, 9011> const yy, gg, tt/**/, hh;
+        vec_t<T, 2, 9012> _____ yz, gb, tp/**/, hd;
+        vec_t<T, 2, 9020> _____ zx, br, ps, pr, dw;
+        vec_t<T, 2, 9021> _____ zy, bg, pt/**/, dh;
+        vec_t<T, 2, 9022> const zz, bb, pp/**/, dd;
+
+        vec_t<T, 3, 90000> const xxx, rrr, sss /**/, www;
+        vec_t<T, 3, 90001> const xxy, rrg, sst, rrt, wwh;
+        vec_t<T, 3, 90002> const xxz, rrb, ssp, rrp, wwd;
+        vec_t<T, 3, 90010> const xyx, rgr, sts, rtr, whw;
+        vec_t<T, 3, 90011> const xyy, rgg, stt, rtt, whh;
+        vec_t<T, 3, 90012> _____ xyz, rgb, stp, rtp, whd;
+        vec_t<T, 3, 90020> const xzx, rbr, sps, rpr, wdw;
+        vec_t<T, 3, 90021> _____ xzy, rbg, spt, rpt, wdh;
+        vec_t<T, 3, 90022> const xzz, rbb, spp, rpp, wdd;
+        vec_t<T, 3, 90100> const yxx, grr, tss, trr, hww;
+        vec_t<T, 3, 90101> const yxy, grg, tst, trt, hwh;
+        vec_t<T, 3, 90102> _____ yxz, grb, tsp, trp, hwd;
+        vec_t<T, 3, 90110> const yyx, ggr, tts, ttr, hhw;
+        vec_t<T, 3, 90111> const yyy, ggg, ttt /**/, hhh;
+        vec_t<T, 3, 90112> const yyz, ggb, ttp /**/, hhd;
+        vec_t<T, 3, 90120> _____ yzx, gbr, tps, tpr, hdw;
+        vec_t<T, 3, 90121> const yzy, gbg, tpt /**/, hdh;
+        vec_t<T, 3, 90122> const yzz, gbb, tpp /**/, hdd;
+        vec_t<T, 3, 90200> const zxx, brr, pss, prr, dww;
+        vec_t<T, 3, 90201> _____ zxy, brg, pst, prt, dwh;
+        vec_t<T, 3, 90202> const zxz, brb, psp, prp, dwd;
+        vec_t<T, 3, 90210> _____ zyx, bgr, pts, ptr, dhw;
+        vec_t<T, 3, 90211> const zyy, bgg, ptt /**/, dhh;
+        vec_t<T, 3, 90212> const zyz, bgb, ptp /**/, dhd;
+        vec_t<T, 3, 90220> const zzx, bbr, pps, ppr, ddw;
+        vec_t<T, 3, 90221> const zzy, bbg, ppt /**/, ddh;
+        vec_t<T, 3, 90222> const zzz, bbb, ppp /**/, ddd;
 
         vec_t<T,4,900000> const xxxx, rrrr, ssss;
         vec_t<T,4,900001> const xxxy, rrrg, ssst;
@@ -654,8 +656,8 @@ struct vec_t<T,4>
 
     union
     {
-        struct { T x, y, z, w; };
-        struct { T r, g, b, a; };
+        struct { T x, y, z, w; }; /* axis */
+        struct { T r, g, b, a; }; /* red, green, blue, alpha */
         struct { T s, t, p, q; };
 
 #if !_DOXYGEN_SKIP_ME

src/lolcore.vcxproj

@@ -225,6 +225,7 @@
     <ClCompile Include="sys\threadtypes.cpp" />
     <ClCompile Include="sys\timer.cpp" />
     <ClCompile Include="text.cpp" />
+    <ClCompile Include="textureimage.cpp" />
     <ClCompile Include="ticker.cpp" />
     <ClCompile Include="tiler.cpp" />
     <ClCompile Include="tileset.cpp" />
@@ -381,6 +382,8 @@
     <ClInclude Include="sprite.h" />
     <ClInclude Include="sys\threadbase.h" />
     <ClInclude Include="text.h" />
+    <ClInclude Include="textureimage-private.h" />
+    <ClInclude Include="textureimage.h" />
     <ClInclude Include="ticker.h" />
     <ClInclude Include="tiler.h" />
     <ClInclude Include="tileset.h" />
@@ -406,7 +409,9 @@
     <LolFxCompile Include="gradient.lolfx" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="Makefile.am" />
+    <None Include="Makefile.am">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="bullet\lolbullet.vcxproj">

src/lolcore.vcxproj.filters

@@ -91,6 +91,12 @@
     <Filter Include="lolua">
       <UniqueIdentifier>{25cc0513-ad71-4fbe-bd24-acc88aa66833}</UniqueIdentifier>
     </Filter>
+    <Filter Include="tileset">
+      <UniqueIdentifier>{7fb4105d-4f17-4824-8d40-948553fdcde1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="entities">
+      <UniqueIdentifier>{3bd5fe6f-c9cd-45f3-98a9-958d86d415e8}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="image\crop.cpp">
@@ -210,9 +216,6 @@
     <ClCompile Include="emitter.cpp">
       <Filter>...</Filter>
     </ClCompile>
-    <ClCompile Include="entity.cpp">
-      <Filter>...</Filter>
-    </ClCompile>
     <ClCompile Include="font.cpp">
       <Filter>...</Filter>
     </ClCompile>
@@ -249,21 +252,12 @@
     <ClCompile Include="text.cpp">
       <Filter>...</Filter>
     </ClCompile>
-    <ClCompile Include="tiler.cpp">
-      <Filter>...</Filter>
-    </ClCompile>
-    <ClCompile Include="tileset.cpp">
-      <Filter>...</Filter>
-    </ClCompile>
     <ClCompile Include="video.cpp">
       <Filter>...</Filter>
     </ClCompile>
     <ClCompile Include="world.cpp">
       <Filter>...</Filter>
     </ClCompile>
-    <ClCompile Include="worldentity.cpp">
-      <Filter>...</Filter>
-    </ClCompile>
     <ClCompile Include="gpu\framebuffer.cpp">
       <Filter>gpu</Filter>
     </ClCompile>
@@ -415,6 +409,21 @@
     <ClCompile Include="sys\threadtypes.cpp">
       <Filter>sys</Filter>
     </ClCompile>
+    <ClCompile Include="tiler.cpp">
+      <Filter>tileset</Filter>
+    </ClCompile>
+    <ClCompile Include="tileset.cpp">
+      <Filter>tileset</Filter>
+    </ClCompile>
+    <ClCompile Include="worldentity.cpp">
+      <Filter>entities</Filter>
+    </ClCompile>
+    <ClCompile Include="entity.cpp">
+      <Filter>entities</Filter>
+    </ClCompile>
+    <ClCompile Include="textureimage.cpp">
+      <Filter>tileset</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="debug\fps.h">
@@ -537,9 +546,6 @@
     <ClInclude Include="emitter.h">
       <Filter>...</Filter>
     </ClInclude>
-    <ClInclude Include="entity.h">
-      <Filter>...</Filter>
-    </ClInclude>
     <ClInclude Include="font.h">
       <Filter>...</Filter>
     </ClInclude>
@@ -588,15 +594,6 @@
     <ClInclude Include="ticker.h">
       <Filter>...</Filter>
     </ClInclude>
-    <ClInclude Include="worldentity.h">
-      <Filter>...</Filter>
-    </ClInclude>
-    <ClInclude Include="tiler.h">
-      <Filter>...</Filter>
-    </ClInclude>
-    <ClInclude Include="tileset.h">
-      <Filter>...</Filter>
-    </ClInclude>
     <ClInclude Include="video.h">
       <Filter>...</Filter>
     </ClInclude>
@@ -775,6 +772,24 @@
     <ClInclude Include="lol\sys\threadtypes.h">
       <Filter>lol\sys</Filter>
     </ClInclude>
+    <ClInclude Include="tiler.h">
+      <Filter>tileset</Filter>
+    </ClInclude>
+    <ClInclude Include="tileset.h">
+      <Filter>tileset</Filter>
+    </ClInclude>
+    <ClInclude Include="worldentity.h">
+      <Filter>entities</Filter>
+    </ClInclude>
+    <ClInclude Include="entity.h">
+      <Filter>entities</Filter>
+    </ClInclude>
+    <ClInclude Include="textureimage.h">
+      <Filter>tileset</Filter>
+    </ClInclude>
+    <ClInclude Include="textureimage-private.h">
+      <Filter>tileset</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <LolFxCompile Include="gpu\emptymaterial.lolfx">
@@ -795,9 +810,6 @@
     <LolFxCompile Include="gpu\line.lolfx">
       <Filter>...</Filter>
     </LolFxCompile>
-    <LolFxCompile Include="gpu\tile.lolfx">
-      <Filter>...</Filter>
-    </LolFxCompile>
     <LolFxCompile Include="easymesh\shiny_SK.lolfx">
       <Filter>easymesh</Filter>
     </LolFxCompile>
@@ -819,6 +831,9 @@
     <LolFxCompile Include="gpu\palette.lolfx">
       <Filter>...</Filter>
     </LolFxCompile>
+    <LolFxCompile Include="gpu\tile.lolfx">
+      <Filter>tileset</Filter>
+    </LolFxCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="Makefile.am" />

src/lolua/baselua.h

@@ -322,6 +322,7 @@ protected:
     }
 };
 //-----------------------------------------------------------------------------
+/* TODO: FIX THAT TOUKY !!
 template<typename T>
 class VarPtrLight
 {
@@ -337,7 +338,7 @@ protected:
         m_value = obj ? *obj : nullptr;
     }
 };
-
+*/
 //-----------------------------------------------------------------------------
 template<typename T>
 class Var

src/lua/lollua.vcxproj

@@ -123,6 +123,11 @@
     <ClInclude Include="lvm.h" />
     <ClInclude Include="lzio.h" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="Makefile.am">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+    </None>
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
     <Import Project="$(SolutionDir)\msbuild\lolfx.targets" />

src/textureimage-private.h

@@ -0,0 +1,39 @@
+//
+// Lol Engine
+//
+// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>
+//   This program is free software; you can redistribute it and/or
+//   modify it under the terms of the Do What The Fuck You Want To
+//   Public License, Version 2, as published by Sam Hocevar. See
+//   http://www.wtfpl.net/ for more details.
+//
+
+#pragma once
+
+//
+// The TileSet class
+// -----------------
+// A TileSet is a collection of tiles stored in a texture. Texture uploading
+// and freeing is done in the render tick method. When the refcount drops to
+// zero, the texture is freed.
+//
+
+namespace lol
+{
+
+class TextureImageData
+{
+    friend class TextureImage;
+
+    //T'was protected .... should it be ?
+public:
+    String m_name;
+
+    /* Pixels, then texture coordinates */
+    ivec2 m_image_size, m_texture_size;
+
+    Image *m_image = nullptr;
+    Texture *m_texture = nullptr;
+};
+
+} /* namespace lol */

src/textureimage.cpp

@@ -0,0 +1,186 @@
+//
+// Lol Engine
+//
+// Copyright: (c) 2010-2014 Sam Hocevar <sam@hocevar.net>
+//   This program is free software; you can redistribute it and/or
+//   modify it under the terms of the Do What The Fuck You Want To
+//   Public License, Version 2, as published by Sam Hocevar. See
+//   http://www.wtfpl.net/ for more details.
+//
+
+#include <lol/engine-internal.h>
+
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+
+#if defined(_WIN32) && !defined(_XBOX)
+#   define WIN32_LEAN_AND_MEAN
+#   include <windows.h>
+#   if defined USE_D3D9
+#       define FAR
+#       define NEAR
+#       include <d3d9.h>
+#   endif
+#endif
+
+#include "textureimage-private.h"
+
+namespace lol
+{
+
+/*
+ * TileSet implementation class
+ */
+
+TextureImageData* TextureImage::GetNewData()
+{
+    return new TextureImageData();
+}
+
+/*
+ * Public TextureImage class
+ */
+
+TextureImage::TextureImage(char const *path)
+    : m_data(GetNewData())
+{
+    Init(path);
+}
+
+TextureImage::TextureImage(char const *path, Image* image)
+    : m_data(GetNewData())
+{
+    Init(path, image);
+}
+
+TextureImage::~TextureImage()
+{
+    delete m_data;
+}
+
+void TextureImage::Init(char const *path)
+{
+    Init(path, new Image(path));
+}
+
+void TextureImage::Init(char const *path, Image* image)
+{
+    m_data->m_name = String("<textureimage> ") + path;
+
+    m_data->m_texture = nullptr;
+    m_data->m_image = image;
+    m_data->m_image_size = m_data->m_image->GetSize();
+    m_data->m_texture_size = ivec2(PotUp(m_data->m_image_size.x),
+                                   PotUp(m_data->m_image_size.y));
+
+    m_drawgroup = DRAWGROUP_BEFORE;
+}
+
+void TextureImage::TickDraw(float seconds, Scene &scene)
+{
+    super::TickDraw(seconds, scene);
+
+    if (IsDestroying())
+    {
+        if (m_data->m_image)
+        {
+            delete m_data->m_image;
+            m_data->m_image = nullptr;
+        }
+        else
+        {
+            delete m_data->m_texture;
+            m_data->m_texture = nullptr;
+        }
+    }
+    else if (m_data->m_image)
+    {
+        //Update texture is needed
+        if (m_data->m_texture)
+        {
+            delete m_data->m_texture;
+            m_data->m_texture = nullptr;
+        }
+
+        PixelFormat format = m_data->m_image->GetFormat();
+        int planes = BytesPerPixel(format);
+
+        int w = m_data->m_texture_size.x;
+        int h = m_data->m_texture_size.y;
+
+        uint8_t *pixels = (uint8_t *)m_data->m_image->Lock();
+        bool resized = false;
+        if (w != m_data->m_image_size.x || h != m_data->m_image_size.y)
+        {
+            uint8_t *tmp = new uint8_t[planes * w * h];
+            for (int line = 0; line < m_data->m_image_size.y; line++)
+                memcpy(tmp + planes * w * line,
+                       pixels + planes * m_data->m_image_size.x * line,
+                       planes * m_data->m_image_size.x);
+            pixels = tmp;
+            resized = false;
+        }
+
+        m_data->m_texture = new Texture(ivec2(w, h), format);
+        m_data->m_texture->SetData(pixels);
+
+        if (resized)
+            delete[] pixels;
+        delete m_data->m_image;
+        m_data->m_image = nullptr;
+    }
+}
+
+//-----------------------------------------------------------------------------
+char const *TextureImage::GetName()
+{
+    return m_data->m_name.C();
+}
+
+void TextureImage::UpdateTexture(Image* image)
+{
+    m_data->m_image = image;
+    m_data->m_image_size = m_data->m_image->GetSize();
+    m_data->m_texture_size = ivec2(PotUp(m_data->m_image_size.x),
+                                    PotUp(m_data->m_image_size.y));
+}
+
+Texture * TextureImage::GetTexture()
+{
+    return m_data->m_texture;
+}
+
+Texture const * TextureImage::GetTexture() const
+{
+    return m_data->m_texture;
+}
+
+Image * TextureImage::GetImage()
+{
+    return m_data->m_image;
+}
+
+Image const * TextureImage::GetImage() const
+{
+    return m_data->m_image;
+}
+
+ivec2 TextureImage::GetTextureSize() const
+{
+    return m_data->m_texture_size;
+}
+
+void TextureImage::Bind()
+{
+    if (!m_data->m_image && m_data->m_texture)
+        m_data->m_texture->Bind();
+}
+
+void TextureImage::Unbind()
+{
+    ;
+}
+
+} /* namespace lol */
+

src/textureimage.h

@@ -0,0 +1,69 @@
+//
+// Lol Engine
+//
+// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>
+//   This program is free software; you can redistribute it and/or
+//   modify it under the terms of the Do What The Fuck You Want To
+//   Public License, Version 2, as published by Sam Hocevar. See
+//   http://www.wtfpl.net/ for more details.
+//
+
+#pragma once
+
+//
+// The TileSet class
+// -----------------
+// A TileSet is a collection of tiles stored in a texture. Texture uploading
+// and freeing is done in the render tick method. When the refcount drops to
+// zero, the texture is freed.
+//
+
+#include <lol/image/image.h>
+#include <lol/gpu/texture.h>
+
+#include <stdint.h>
+
+#include "entity.h"
+
+namespace lol
+{
+
+class TextureImageData;
+
+class TextureImage : public Entity
+{
+    typedef Entity super;
+protected:
+    virtual TextureImageData* GetNewData();
+
+public:
+    TextureImage(char const *path);
+    TextureImage(char const *path, Image* image);
+    virtual ~TextureImage();
+
+protected:
+    void Init(char const *path);
+    virtual void Init(char const *path, Image* image);
+
+protected:
+    virtual void TickDraw(float seconds, Scene &scene);
+
+public:
+    /* Inherited from Entity */
+    virtual char const *GetName();
+
+    void UpdateTexture(Image* image);
+    Texture * GetTexture();
+    Texture const * GetTexture() const;
+    Image * GetImage();
+    Image const * GetImage() const;
+    ivec2 GetTextureSize() const;
+    void Bind();
+    void Unbind();
+
+protected:
+    TextureImageData* m_data = nullptr;
+};
+
+} /* namespace lol */
+

src/tileset.cpp

@@ -24,6 +24,8 @@
 #   endif
 #endif
 
+#include "textureimage-private.h"
+
 namespace lol
 {
 
@@ -31,30 +33,38 @@ namespace lol
  * TileSet implementation class
  */
 
-class TileSetData
+class TileSetData : public TextureImageData
 {
     friend class TileSet;
 
-private:
-    String m_name;
-
+protected:
     /* Pixels, then texture coordinates */
     array<ibox2, box2> m_tiles;
-    ivec2 m_tile_size, m_image_size, m_texture_size;
-
-    Image *m_image;
-    Texture *m_texture;
+    ivec2 m_tile_size;
 };
 
+TextureImageData* TileSet::GetNewData()
+{
+    return new TileSetData();
+}
+
+TileSetData* TileSet::GetData()
+{
+    return (TileSetData*)m_data;
+}
+
+TileSetData const* TileSet::GetData() const
+{
+    return (TileSetData const*)m_data;
+}
+
 /*
  * Public TileSet class
  */
 
 TileSet::TileSet(char const *path)
-  : m_data(new TileSetData())
+    : TextureImage(path)
 {
-    Init(path);
-
     array<ivec2, ivec2> tiles;
     if (m_data->m_image->RetrieveTiles(tiles))
         for (ptrdiff_t i = 0; i < tiles.Count(); i++)
@@ -62,10 +72,8 @@ TileSet::TileSet(char const *path)
 }
 
 TileSet::TileSet(char const *path, Image* image)
-  : m_data(new TileSetData())
+    : TextureImage(path, image)
 {
-    Init(path, image);
-
     array<ivec2, ivec2> tiles;
     if (m_data->m_image->RetrieveTiles(tiles))
         for (ptrdiff_t i = 0; i < tiles.Count(); i++)
@@ -73,10 +81,8 @@ TileSet::TileSet(char const *path, Image* image)
 }
 
 TileSet::TileSet(char const *path, ivec2 size, ivec2 count)
-  : m_data(new TileSetData())
+    : TileSet(path)
 {
-    Init(path);
-
     /* If count is valid, fix size; otherwise, fix count. */
     if (count.x > 0 && count.y > 0)
     {
@@ -95,18 +101,11 @@ TileSet::TileSet(char const *path, ivec2 size, ivec2 count)
         AddTile(ibox2(size * ivec2(i, j),
                       size * ivec2(i + 1, j + 1)));
     }
-
-    array<ivec2, ivec2> tiles;
-    if (m_data->m_image->RetrieveTiles(tiles))
-        for (ptrdiff_t i = 0; i < tiles.Count(); i++)
-            AddTile(ibox2(tiles[i].m1, tiles[i].m1 + tiles[i].m2));
 }
 
 TileSet::TileSet(char const *path, Image* image, ivec2 size, ivec2 count)
-  : m_data(new TileSetData())
+    : TileSet(path, image)
 {
-    Init(path, image);
-
     /* If count is valid, fix size; otherwise, fix count. */
     if (count.x > 0 && count.y > 0)
     {
@@ -125,38 +124,33 @@ TileSet::TileSet(char const *path, Image* image, ivec2 size, ivec2 count)
         AddTile(ibox2(size * ivec2(i, j),
                       size * ivec2(i + 1, j + 1)));
     }
-
-    array<ivec2, ivec2> tiles;
-    if (m_data->m_image->RetrieveTiles(tiles))
-        for (ptrdiff_t i = 0; i < tiles.Count(); i++)
-            AddTile(ibox2(tiles[i].m1, tiles[i].m1 + tiles[i].m2));
 }
 
-void TileSet::Init(char const *path)
+TileSet::~TileSet()
 {
-    Init(path, new Image(path));
 }
 
 void TileSet::Init(char const *path, Image* image)
 {
-    m_data->m_name = String("<tileset> ") + path;
+    super::Init(path, image);
 
-    m_palette = nullptr;
-    m_data->m_texture = 0;
-    m_data->m_image = image;
-    m_data->m_image_size = m_data->m_image->GetSize();
-    m_data->m_texture_size = ivec2(PotUp(m_data->m_image_size.x),
-                                   PotUp(m_data->m_image_size.y));
+    m_data->m_name = String("<tileset> ") + path;
+}
 
-    m_drawgroup = DRAWGROUP_BEFORE;
+//Inherited from Entity -------------------------------------------------------
+char const *TileSet::GetName()
+{
+    return m_data->m_name.C();
 }
 
+//New methods -----------------------------------------------------------------
 ptrdiff_t TileSet::AddTile(ibox2 rect)
 {
-    m_data->m_tiles.Push(rect,
-                         box2((vec2)rect.A / (vec2)m_data->m_texture_size,
-                              (vec2)rect.B / (vec2)m_data->m_texture_size));
-    return m_data->m_tiles.Count() - 1;
+    TileSetData* data = GetData();
+    data->m_tiles.Push(rect,
+                        box2((vec2)rect.A / (vec2)m_data->m_texture_size,
+                            (vec2)rect.B / (vec2)m_data->m_texture_size));
+    return data->m_tiles.Count() - 1;
 }
 
 void TileSet::AddTile(ivec2 count)
@@ -171,100 +165,18 @@ void TileSet::AddTile(ivec2 count)
     }
 }
 
-TileSet::~TileSet()
-{
-    delete m_data;
-}
-
-void TileSet::TickDraw(float seconds, Scene &scene)
-{
-    Entity::TickDraw(seconds, scene);
-
-    if (IsDestroying())
-    {
-        if (m_data->m_image)
-        {
-            delete m_data->m_image;
-            m_data->m_image = nullptr;
-        }
-        else
-        {
-            delete m_data->m_texture;
-            m_data->m_texture = nullptr;
-        }
-    }
-    else if (m_data->m_image)
-    {
-        PixelFormat format = m_data->m_image->GetFormat();
-        int planes = BytesPerPixel(format);
-
-        int w = m_data->m_texture_size.x;
-        int h = m_data->m_texture_size.y;
-
-        uint8_t *pixels = (uint8_t *)m_data->m_image->Lock();
-        bool resized = false;
-        if (w != m_data->m_image_size.x || h != m_data->m_image_size.y)
-        {
-            uint8_t *tmp = new uint8_t[planes * w * h];
-            for (int line = 0; line < m_data->m_image_size.y; line++)
-                memcpy(tmp + planes * w * line,
-                       pixels + planes * m_data->m_image_size.x * line,
-                       planes * m_data->m_image_size.x);
-            pixels = tmp;
-            resized = false;
-        }
-
-        m_data->m_texture = new Texture(ivec2(w, h), format);
-        m_data->m_texture->SetData(pixels);
-
-        if (resized)
-            delete[] pixels;
-        delete m_data->m_image;
-        m_data->m_image = nullptr;
-    }
-}
-
-char const *TileSet::GetName()
-{
-    return m_data->m_name.C();
-}
-
 ptrdiff_t TileSet::GetTileCount() const
 {
-    return m_data->m_tiles.Count();
+    return GetData()->m_tiles.Count();
 }
 
 ivec2 TileSet::GetTileSize(ptrdiff_t tileid) const
 {
-    ibox2 const &box = m_data->m_tiles[tileid].m1;
+    ibox2 const &box = GetData()->m_tiles[tileid].m1;
     return box.B - box.A;
 }
 
-ivec2 TileSet::GetTextureSize() const
-{
-    return m_data->m_texture_size;
-}
-
-Texture * TileSet::GetTexture()
-{
-    return m_data->m_texture;
-}
-
-Texture const * TileSet::GetTexture() const
-{
-    return m_data->m_texture;
-}
-
-Image * TileSet::GetImage()
-{
-    return m_data->m_image;
-}
-
-Image const * TileSet::GetImage() const
-{
-    return m_data->m_image;
-}
-
+//Palette ---------------------------------------------------------------------
 void TileSet::SetPalette(TileSet* palette)
 {
     m_palette = palette;
@@ -280,22 +192,12 @@ TileSet const* TileSet::GetPalette() const
     return m_palette;
 }
 
-void TileSet::Bind()
-{
-    if (!m_data->m_image && m_data->m_texture)
-        m_data->m_texture->Bind();
-}
-
-void TileSet::Unbind()
-{
-    ;
-}
-
 void TileSet::BlitTile(uint32_t id, vec3 pos, int o, vec2 scale, float angle,
                        vec3 *vertex, vec2 *texture)
 {
-    ibox2 pixels = m_data->m_tiles[id].m1;
-    box2 texels = m_data->m_tiles[id].m2;
+    TileSetData* data = GetData();
+    ibox2 pixels = data->m_tiles[id].m1;
+    box2 texels = data->m_tiles[id].m2;
     float dtx = texels.B.x - texels.A.x;
     float dty = texels.B.y - texels.A.y;
     float tx = texels.A.x;

src/tileset.h

@@ -18,59 +18,60 @@
 // zero, the texture is freed.
 //
 
+/*
 #include <lol/image/image.h>
 #include <lol/gpu/texture.h>
 
 #include <stdint.h>
 
 #include "entity.h"
+*/
+#include "textureimage.h"
 
 namespace lol
 {
 
+class TextureImageData;
 class TileSetData;
 
-class TileSet : public Entity
+class TileSet : public TextureImage
 {
+    typedef TextureImage super;
+protected:
+    virtual TextureImageData* GetNewData();
+    TileSetData* GetData();
+    TileSetData const* GetData() const;
+
 public:
     TileSet(char const *path);
     TileSet(char const *path, Image* image);
-    virtual ~TileSet();
 
     /* Old style: path to PNG file */
     TileSet(char const *path, ivec2 size, ivec2 count);
     TileSet(char const *path, Image* image, ivec2 size, ivec2 count);
+    
+    virtual ~TileSet();
 
-    /* Inherited from Entity */
-    virtual char const *GetName();
 protected:
-    virtual void TickDraw(float seconds, Scene &scene);
+    virtual void Init(char const *path, Image* image);
 
 public:
+    /* Inherited from Entity */
+    virtual char const *GetName();
+
     /* New methods */
     ptrdiff_t AddTile(ibox2 rect);
     void AddTile(ivec2 count);
     ptrdiff_t GetTileCount() const;
     ivec2 GetTileSize(ptrdiff_t tileid) const;
 
-    Texture * GetTexture();
-    Texture const * GetTexture() const;
-    Image * GetImage();
-    Image const * GetImage() const;
     void SetPalette(TileSet* palette);
     TileSet* GetPalette();
     TileSet const * GetPalette() const;
-    ivec2 GetTextureSize() const;
-    void Bind();
-    void Unbind();
     void BlitTile(uint32_t id, vec3 pos, int o, vec2 scale, float angle,
                   vec3 *vertex, vec2 *texture);
 
-private:
-    void Init(char const *path);
-    void Init(char const *path, Image* image);
-
-    TileSetData*    m_data;
+protected:
     TileSet*        m_palette;
 };