*格式化

21 files changed, 231 insertions, 211 deletions

diff --git a/src/3rdparty/buildvm/buildvm.exe b/src/3rdparty/buildvm/buildvm.exe
index 8d16380..493ffc0 100644
--- a/src/3rdparty/buildvm/buildvm.exe
+++ b/src/3rdparty/buildvm/buildvm.exe
diff --git a/src/3rdparty/minilua/minilua.exe b/src/3rdparty/minilua/minilua.exe
index e383b6f..96c032d 100644
--- a/src/3rdparty/minilua/minilua.exe
+++ b/src/3rdparty/minilua/minilua.exe
diff --git a/src/lua/common/je_lua_proxy.h b/src/lua/common/je_lua_proxy.h
index 56e5fee..b476aa6 100644
--- a/src/lua/common/je_lua_proxy.h
+++ b/src/lua/common/je_lua_proxy.h
@@ -1,6 +1,8 @@
 #ifndef __JIN_COMMON_PROXY_H
 #define __JIN_COMMON_PROXY_H
 
+#include "../luax.h"
+
 #include "je_lua_shared.hpp"
 
 namespace JinEngine
@@ -11,56 +13,61 @@ namespace JinEngine
         class Proxy
         {
         public:
-            void bind(SharedBase* ref)
+            void bind(SharedBase* shared)
             {
-                if (ref == nullptr)
+                if (shared == nullptr)
                     return;
-                shared = ref;
+                reference = shared;
             }
 
             void release()
             {
-                if (shared != nullptr)
+                if (reference != nullptr)
                 {
-                    shared->release();
-                    shared = nullptr;
+                    reference->release();
+                    reference = nullptr;
                 }
             }
 
 		    void retain()
 		    {
-			    if (shared != nullptr)
-				    shared->retain();
+			    if (reference != nullptr)
+				    reference->retain();
 		    }
 
 		    void setUserdata(void* data)
 		    {
-			    if (shared != nullptr)
-				    shared->setUserdata(data);
+			    if (reference != nullptr)
+				    reference->setUserdata(data);
 		    }
 
             template<class T>
             Shared<T>& getShared()
             {
-                return *(static_cast<Shared<T>*>(shared));
+                return *(Shared<T>*) reference;
             }
 
             template<class T>
             T* getObject()
             {
-                Shared<T>& ref = getShared<T>();
-                return ref.getObject();
+                Shared<T>& shared = getShared<T>();
+                return shared.getObject();
             }
 
             const char* getObjectType()
             {
-                return shared->type;
+                return reference->type;
             }
 
-            SharedBase* shared; 
+            SharedBase* reference; 
 
         };
 
+        inline Proxy* luax_newinstance(lua_State* L, const char* type)
+        {
+            return static_cast<Proxy*>(luax_newinstance(L, type, sizeof(Proxy)));
+        }
+
     } // namespace Lua
 } // namespace JinEngine
 
diff --git a/src/lua/common/je_lua_shared.hpp b/src/lua/common/je_lua_shared.hpp
index 7ad7c1d..53f557a 100644
--- a/src/lua/common/je_lua_shared.hpp
+++ b/src/lua/common/je_lua_shared.hpp
@@ -11,46 +11,45 @@ namespace JinEngine
         public:
             void retain()
             {
-                ++(*count);
+                ++count;
             }
 
             void release()
             {
-                if (--(*count) <= 0)
+                if (--count <= 0)
                     delete this;
             }
 
             // object type string
             const char* const type;
 
-		    void setUserdata(void* data)
-		    {
-			    userdata = data;
-		    }
+            void setUserdata(void* data)
+            {
+                userdata = data;
+            }
 
-		    void* getUserdata()
-		    {
-			    return userdata;
-		    }
+            void* getUserdata()
+            {
+                return userdata;
+            }
 
         protected:
             SharedBase(void* obj, const char* t)
-                : object(obj)
+                : count(1)
+                , object(obj)
                 , type(t)
             {
-                count = new int(1);
             }
 
             SharedBase(const SharedBase&);
 
             virtual ~SharedBase()
             {
-
             }
 
             void* object;
-            int* count;       
-		    void* userdata;
+            int count;
+            void* userdata;
         };
 
         template<class T>
@@ -62,35 +61,26 @@ namespace JinEngine
             {
             }
 
-            ~Shared()
-            {
-                T* obj = static_cast<T*>(object);
-                delete obj;
-            }
-
             T* operator->()
             {
-                return static_cast<T*>(object);
+                return (T*)object;
             }
 
             T* getObject()
             {
-                return static_cast<T*>(object);
+                return (T*)object;
             }
 
-            T* operator &()
-            {
-                return static_cast<T*>(object);
-            }
+        private:
+            // Disable copy constructor.
+            Shared(const Shared<T>& shared);
 
-            T& operator *()
+            ~Shared()
             {
-                return *(static_cast<T*>(object));
+                T* obj = static_cast<T*>(object);
+                delete obj;
             }
 
-        private:
-            Shared(const Shared<T>& ref);
-
         };
 
     }
diff --git a/src/lua/modules/ai/je_lua_statemachine.cpp b/src/lua/modules/ai/je_lua_statemachine.cpp
new file mode 100644
index 0000000..f79d79a
--- /dev/null
+++ b/src/lua/modules/ai/je_lua_statemachine.cpp
@@ -0,0 +1,11 @@
+#include "libjin/jin.h"
+
+namespace JinEngine
+{
+    namespace Lua
+    {
+
+
+
+    }
+}
\ No newline at end of file
diff --git a/src/lua/modules/audio/je_lua_audio.cpp b/src/lua/modules/audio/je_lua_audio.cpp
index 88c0561..45256e1 100644
--- a/src/lua/modules/audio/je_lua_audio.cpp
+++ b/src/lua/modules/audio/je_lua_audio.cpp
@@ -97,7 +97,7 @@ namespace JinEngine
                 luax_pushnil(L);
                 return 1;
             }
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_AUDIO_SOURCE, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_AUDIO_SOURCE);
             proxy->bind(new Shared<Source>(src, JIN_AUDIO_SOURCE));
             return 1;
         }
diff --git a/src/lua/modules/audio/je_lua_source.cpp b/src/lua/modules/audio/je_lua_source.cpp
index 04f0528..2297fea 100644
--- a/src/lua/modules/audio/je_lua_source.cpp
+++ b/src/lua/modules/audio/je_lua_source.cpp
@@ -10,9 +10,9 @@ namespace JinEngine
     namespace Lua
     {
 
-        typedef Shared<Source>& SourceRef;
+        typedef Shared<Source>& SharedSource;
 
-        LUA_IMPLEMENT inline SourceRef checkSource(lua_State* L)
+        LUA_IMPLEMENT inline SharedSource checkSource(lua_State* L)
         {
             Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_AUDIO_SOURCE);
 		    return proxy->getShared<Source>();
@@ -20,68 +20,68 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_play(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
-            ref->play();
+		    SharedSource shared = checkSource(L);
+            shared->play();
             return 0;
         }
 
         LUA_IMPLEMENT int l_stop(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
-		    ref->stop();
+		    SharedSource shared = checkSource(L);
+		    shared->stop();
             return 0;
         }
 
         LUA_IMPLEMENT int l_pause(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
-		    ref->pause();
+		    SharedSource shared = checkSource(L);
+		    shared->pause();
             return 0;
         }
 
         LUA_IMPLEMENT int l_rewind(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
-		    ref->rewind();
+		    SharedSource shared = checkSource(L);
+		    shared->rewind();
             return 0;
         }
 
         LUA_IMPLEMENT int l_resume(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
-		    ref->resume();
+		    SharedSource shared = checkSource(L);
+		    shared->resume();
             return 0;
         }
 
         LUA_IMPLEMENT int l_isStop(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
-            bool isStop = ref->isStopped();
+		    SharedSource shared = checkSource(L);
+            bool isStop = shared->isStopped();
             luax_pushboolean(L, isStop);
             return 1;
         }
 
         LUA_IMPLEMENT int l_isPaused(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
-            bool isPaused = ref->isPaused();
+		    SharedSource shared = checkSource(L);
+            bool isPaused = shared->isPaused();
             luax_pushboolean(L, isPaused);
             return 1;
         }
 
         LUA_IMPLEMENT int l_setVolume(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
+		    SharedSource shared = checkSource(L);
             float volume = luax_checknumber(L, 2);
-		    ref->setVolume(volume);
+		    shared->setVolume(volume);
             return 0;
         }
 
         LUA_IMPLEMENT int l_setLoop(lua_State* L)
         {
-		    SourceRef ref = checkSource(L);
+		    SharedSource shared = checkSource(L);
             bool loop = luax_checkbool(L, 2);
-		    ref->setLoop(loop);
+		    shared->setLoop(loop);
             return 0;
         }
 
diff --git a/src/lua/modules/graphics/je_lua_bitmap.cpp b/src/lua/modules/graphics/je_lua_bitmap.cpp
index 8d4897b..2a35ed5 100644
--- a/src/lua/modules/graphics/je_lua_bitmap.cpp
+++ b/src/lua/modules/graphics/je_lua_bitmap.cpp
@@ -10,9 +10,9 @@ namespace JinEngine
     namespace Lua
     {
 
-        typedef Shared<Bitmap>& BitmapRef;
+        typedef Shared<Bitmap>& SharedBitmap;
 
-        LUA_IMPLEMENT inline BitmapRef checkBitmap(lua_State* L)
+        LUA_IMPLEMENT inline SharedBitmap checkBitmap(lua_State* L)
         {
             Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_GRAPHICS_BITMAP);
             return proxy->getShared<Bitmap>();
@@ -20,32 +20,32 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_gc(lua_State* L)
         {
-            BitmapRef ref = checkBitmap(L);
-            ref.release();
+            SharedBitmap shared = checkBitmap(L);
+            shared.release();
             return 0;
         }
 
         LUA_IMPLEMENT int l_getWidth(lua_State* L)
         {
-            BitmapRef ref = checkBitmap(L);
-            int w = ref->getWidth(); 
+            SharedBitmap shared = checkBitmap(L);
+            int w = shared->getWidth(); 
             luax_pushinteger(L, w);
             return 1;
         }
 
         LUA_IMPLEMENT int l_getHeight(lua_State* L)
         {
-            BitmapRef ref = checkBitmap(L);
-            int h = ref->getHeight();
+            SharedBitmap shared = checkBitmap(L);
+            int h = shared->getHeight();
             luax_pushinteger(L, h);
             return 1;
         }
 
         LUA_IMPLEMENT int l_getSize(lua_State* L)
         {
-            BitmapRef ref = checkBitmap(L);
-            int w = ref->getWidth();
-            int h = ref->getHeight();
+            SharedBitmap shared = checkBitmap(L);
+            int w = shared->getWidth();
+            int h = shared->getHeight();
             luax_pushinteger(L, w);
             luax_pushinteger(L, h);
             return 2;
@@ -53,10 +53,10 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_getPixel(lua_State* L)
         {
-            BitmapRef ref = checkBitmap(L);
+            SharedBitmap shared = checkBitmap(L);
             int x = luax_checkinteger(L, 2);
             int y = luax_checkinteger(L, 3);
-            Color col = ref->getPixel(x, y);
+            Color col = shared->getPixel(x, y);
             luax_pushinteger(L, col.r);
             luax_pushinteger(L, col.g);
             luax_pushinteger(L, col.b);
@@ -66,7 +66,7 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_setPixel(lua_State* L)
         {
-            BitmapRef ref = checkBitmap(L);
+            SharedBitmap shared = checkBitmap(L);
             int x = luax_checkinteger(L, 2);
             int y = luax_checkinteger(L, 3);
             if (!luax_istable(L, 4))
@@ -78,16 +78,16 @@ namespace JinEngine
             unsigned int g = luax_rawgetnumber(L, 4, 2);
             unsigned int b = luax_rawgetnumber(L, 4, 3);
             unsigned int a = luax_rawgetnumber(L, 4, 4);
-            ref->setPixel(Color(r, g, b, a), x, y);
+            shared->setPixel(Color(r, g, b, a), x, y);
             return 0;
         }
 
         LUA_IMPLEMENT int l_clone(lua_State* L)
         {
-            BitmapRef ref = checkBitmap(L);
-            Bitmap* bitmap = ref.getObject();
+            SharedBitmap shared = checkBitmap(L);
+            Bitmap* bitmap = shared.getObject();
             Bitmap* b = Bitmap::clone(bitmap);
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_BITMAP, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_BITMAP);
             proxy->bind(new Shared<Bitmap>(b, JIN_GRAPHICS_BITMAP));
             return 1;
         }
diff --git a/src/lua/modules/graphics/je_lua_canvas.cpp b/src/lua/modules/graphics/je_lua_canvas.cpp
index 87516b3..42570b2 100644
--- a/src/lua/modules/graphics/je_lua_canvas.cpp
+++ b/src/lua/modules/graphics/je_lua_canvas.cpp
@@ -10,9 +10,9 @@ namespace JinEngine
     namespace Lua
     {
 
-        typedef Shared<Canvas>& CanvasRef;
+        typedef Shared<Canvas>& SharedCanvas;
 
-        LUA_IMPLEMENT inline CanvasRef checkCanvas(lua_State* L)
+        LUA_IMPLEMENT inline SharedCanvas checkCanvas(lua_State* L)
         {
             Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_GRAPHICS_CANVAS);
 		    return proxy->getShared<Canvas>();
@@ -20,23 +20,23 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_getWidth(lua_State* L)
         {
-		    CanvasRef ref = checkCanvas(L);
-            luax_pushnumber(L, ref->getWidth());
+		    SharedCanvas shared = checkCanvas(L);
+            luax_pushnumber(L, shared->getWidth());
             return 1;
         }
 
         LUA_IMPLEMENT int l_getHeight(lua_State* L)
         {
-		    CanvasRef ref = checkCanvas(L);
-            luax_pushnumber(L, ref->getHeight());
+		    SharedCanvas shared = checkCanvas(L);
+            luax_pushnumber(L, shared->getHeight());
             return 1;
         }
 
         LUA_IMPLEMENT int l_getSize(lua_State* L)
         {
-		    CanvasRef ref = checkCanvas(L);
-            luax_pushnumber(L, ref->getWidth());
-            luax_pushnumber(L, ref->getHeight());
+		    SharedCanvas shared = checkCanvas(L);
+            luax_pushnumber(L, shared->getWidth());
+            luax_pushnumber(L, shared->getHeight());
             return 2;
         }
 
diff --git a/src/lua/modules/graphics/je_lua_graphics.cpp b/src/lua/modules/graphics/je_lua_graphics.cpp
index 639a542..24cdf59 100644
--- a/src/lua/modules/graphics/je_lua_graphics.cpp
+++ b/src/lua/modules/graphics/je_lua_graphics.cpp
@@ -164,7 +164,7 @@ namespace JinEngine
                     return 1;
                 }
             }
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_BITMAP, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_BITMAP);
             proxy->bind(new Shared<Bitmap>(bitmap, JIN_GRAPHICS_BITMAP));
             return 1;
         }
@@ -185,7 +185,7 @@ namespace JinEngine
                 const char* path = luax_checkstring(L, 1);
                 texture = Texture::createTexture(path);
             }
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_TEXTURE, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_TEXTURE);
             proxy->bind(new Shared<Texture>(texture, JIN_GRAPHICS_TEXTURE));
             return 1;
         }
@@ -200,7 +200,7 @@ namespace JinEngine
                 luax_pushnil(L);
                 return 1;
             }
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_SHADER, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_SHADER);
             proxy->bind(new Shared<Shader>(jsl, JIN_GRAPHICS_SHADER));
             return 1;
         }
@@ -224,7 +224,7 @@ namespace JinEngine
                 luax_pushnil(L);
                 return 1;
             }
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_SHADER, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_SHADER);
             proxy->bind(new Shared<Shader>(jsl, JIN_GRAPHICS_SHADER));
             return 1;
         }
@@ -233,7 +233,7 @@ namespace JinEngine
         {
             int w = luax_checknumber(L, 1);
             int h = luax_checknumber(L, 2);
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_CANVAS, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_CANVAS);
             Canvas* cvs = Canvas::createCanvas(w, h);
             proxy->bind(new Shared<Canvas>(cvs, JIN_GRAPHICS_CANVAS));
             return 1;
@@ -462,8 +462,8 @@ namespace JinEngine
                 return 0; 
             }
             Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_GRAPHICS_CANVAS);
-		    Shared<Canvas>& ref = proxy->getShared<Canvas>();
-            Canvas::bind(ref.getObject());
+		    Shared<Canvas>& shared = proxy->getShared<Canvas>();
+            Canvas::bind(shared.getObject());
             return 0;
         }
 
@@ -496,10 +496,18 @@ namespace JinEngine
         LUA_IMPLEMENT int l_setBlend(lua_State* L)
         {
 
-            return 0;
+            return 0; 
         }
 
-#define IntToRenderMode(I) static_cast<RenderMode>(I)
+        LUA_IMPLEMENT RenderMode strtomode(const char* str)
+        {
+            std::string s = std::string(str);
+            if (s == "fill") 
+                return RenderMode::FILL;
+            else if (s == "line") 
+                return RenderMode::LINE;
+            else return RenderMode::NONE;
+        }
 
         LUA_IMPLEMENT int l_point(lua_State* L)
         {
@@ -523,7 +531,8 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_rect(lua_State* L)
         {
-            RenderMode mode = IntToRenderMode(luax_checkinteger(L, 1));
+            const char* modestr = luax_checkstring(L, 1);
+            RenderMode mode = strtomode(modestr);
             if (mode != RenderMode::NONE)
             {
                 int x = luax_checknumber(L, 2);
@@ -543,7 +552,8 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_circle(lua_State* L)
         {
-            RenderMode mode = IntToRenderMode(luax_checkinteger(L, 1));
+            const char* modestr = luax_checkstring(L, 1);
+            RenderMode mode = strtomode(modestr);
             if (mode != RenderMode::NONE)
             {
                 int x = luax_checknumber(L, 2);
@@ -562,7 +572,8 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_triangle(lua_State* L)
         {
-            RenderMode mode = IntToRenderMode(luax_checkinteger(L, 1));
+            const char* modestr = luax_checkstring(L, 1);
+            RenderMode mode = strtomode(modestr);
             if (mode != RenderMode::NONE)
             {
                 int x = luax_checknumber(L, 2);
@@ -587,8 +598,9 @@ namespace JinEngine
     
         LUA_IMPLEMENT int l_polygon(lua_State* L)
         {
-            RenderMode mode = IntToRenderMode(luax_checkinteger(L, 1));
-            int n = luax_checknumber(L, 2);
+            const char* modestr = luax_checkstring(L, 1);
+            int n = luax_checknumber(L, 2); 
+            RenderMode mode = strtomode(modestr); 
             if (mode != RenderMode::NONE)
             {
                 if (!luax_istable(L, 3))
@@ -621,7 +633,7 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_newTTFData(lua_State* L)
         {
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_TTFDATA, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_TTFDATA);
             TTFData* fd = nullptr;
             {
                 const char* path = luax_checkstring(L, 1);
@@ -659,7 +671,7 @@ namespace JinEngine
 		    unsigned length;
 		    const char* data = luax_checklstring(L, 1, &length);
 		    Text* text = new Text(encode, data, length);
-		    Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_TEXT, sizeof(Proxy));
+		    Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_TEXT);
 		    proxy->bind(new Shared<Text>(text, JIN_GRAPHICS_TEXT));
 		    return 1;
 	    }
@@ -711,7 +723,7 @@ namespace JinEngine
                 // Delete temporary text.
                 delete text;
             }
-		    Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_TEXTUREFONT, sizeof(Proxy));
+		    Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_TEXTUREFONT);
 		    proxy->bind(new Shared<TextureFont>(textureFont, JIN_GRAPHICS_TEXTUREFONT));
 		    return 1;
 	    }
@@ -798,7 +810,7 @@ namespace JinEngine
     
         LUA_EXPORT int luaopen_graphics(lua_State* L)
         {
-            // Register types.
+            // register types
             luaopen_Bitmap(L);
             luaopen_Texture(L);
             luaopen_Canvas(L);
@@ -809,7 +821,7 @@ namespace JinEngine
             luaopen_Page(L);
             luaopen_JSL(L);
 
-            // Load whole lib.
+            // load whole lib 
             luax_newlib(L, f);
         
             return 1;
diff --git a/src/lua/modules/graphics/je_lua_page.cpp b/src/lua/modules/graphics/je_lua_page.cpp
index f3c2517..29e3ff8 100644
--- a/src/lua/modules/graphics/je_lua_page.cpp
+++ b/src/lua/modules/graphics/je_lua_page.cpp
@@ -14,7 +14,7 @@ namespace JinEngine
     namespace Lua
     {
 
-        typedef Shared<Font>& FontRef;
+        typedef Shared<Font>& SharedFont;
 
         Page* getPage(lua_State* L)
         {
diff --git a/src/lua/modules/graphics/je_lua_shader.cpp b/src/lua/modules/graphics/je_lua_shader.cpp
index e2e1413..9913bc3 100644
--- a/src/lua/modules/graphics/je_lua_shader.cpp
+++ b/src/lua/modules/graphics/je_lua_shader.cpp
@@ -24,36 +24,36 @@ namespace JinEngine
         */
         LUA_IMPLEMENT int l_sendNumber(lua_State* L)
         {
-            ShaderRef ref = checkShader(L);
+            ShaderRef shared = checkShader(L);
             const char* variable = luax_checkstring(L, 2);
             float number = luax_checknumber(L, 3);
-            ref->sendFloat(variable, number);
+            shared->sendFloat(variable, number);
             return 0;
         }
 
         LUA_IMPLEMENT int l_sendTexture(lua_State* L)
         {
-            ShaderRef ref = checkShader(L);
+            ShaderRef shared = checkShader(L);
             const char* variable = luax_checkstring(L, 2);
             Proxy* proxy = (Proxy*)luax_checktype(L, 3, JIN_GRAPHICS_TEXTURE);
             Shared<Texture>& tex = proxy->getShared<Texture>();
-            ref->sendTexture(variable, tex.getObject());
+            shared->sendTexture(variable, tex.getObject());
             return 0;
         }
 
         LUA_IMPLEMENT int l_sendCanvas(lua_State* L)
         {
-            ShaderRef ref = checkShader(L);
+            ShaderRef shared = checkShader(L);
             const char* variable = luax_checkstring(L, 2);
             Proxy* proxy = (Proxy*)luax_checktype(L, 3, JIN_GRAPHICS_CANVAS);
             Shared<Canvas>& canvas = proxy->getShared<Canvas>();
-            ref->sendCanvas(variable, canvas.getObject());
+            shared->sendCanvas(variable, canvas.getObject());
             return 0;
         }
 
         LUA_IMPLEMENT int l_sendVec2(lua_State* L)
         {
-            ShaderRef ref = checkShader(L);
+            ShaderRef shared = checkShader(L);
             const char* variable = luax_checkstring(L, 2);
             if (!luax_istable(L, 3))
             {
@@ -62,13 +62,13 @@ namespace JinEngine
             }
             float x = luax_rawgetnumber(L, 3, 1);
             float y = luax_rawgetnumber(L, 3, 2);
-            ref->sendVec2(variable, x, y);
+            shared->sendVec2(variable, x, y);
             return 0;
         }
 
         LUA_IMPLEMENT int l_sendVec3(lua_State* L)
         {
-            ShaderRef ref = checkShader(L);
+            ShaderRef shared = checkShader(L);
             const char* variable = luax_checkstring(L, 2);
             if (!luax_istable(L, 3))
             {
@@ -78,13 +78,13 @@ namespace JinEngine
             float x = luax_rawgetnumber(L, 3, 1);
             float y = luax_rawgetnumber(L, 3, 2);
             float z = luax_rawgetnumber(L, 3, 3);
-            ref->sendVec3(variable, x, y, z);
+            shared->sendVec3(variable, x, y, z);
             return 0;
         }
 
         LUA_IMPLEMENT int l_sendVec4(lua_State* L)
         {
-            ShaderRef ref = checkShader(L);
+            ShaderRef shared = checkShader(L);
             const char* variable = luax_checkstring(L, 2);
             if (!luax_istable(L, 3))
             {
@@ -95,7 +95,7 @@ namespace JinEngine
             float y = luax_rawgetnumber(L, 3, 2);
             float z = luax_rawgetnumber(L, 3, 3);
             float w = luax_rawgetnumber(L, 3, 4);
-            ref->sendVec4(variable, x, y, z, w);
+            shared->sendVec4(variable, x, y, z, w);
             return 0;
         }
 
diff --git a/src/lua/modules/graphics/je_lua_texture.cpp b/src/lua/modules/graphics/je_lua_texture.cpp
index a643dae..5236438 100644
--- a/src/lua/modules/graphics/je_lua_texture.cpp
+++ b/src/lua/modules/graphics/je_lua_texture.cpp
@@ -10,9 +10,9 @@ namespace JinEngine
     namespace Lua
     {
 
-	    typedef Shared<Texture>& TextureRef;
+	    typedef Shared<Texture>& SharedTexture;
 
-        LUA_IMPLEMENT inline TextureRef checkTexture(lua_State* L)
+        LUA_IMPLEMENT inline SharedTexture checkTexture(lua_State* L)
         {
             Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_GRAPHICS_TEXTURE);
 		    return proxy->getShared<Texture>();
@@ -20,23 +20,23 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_getWidth(lua_State* L)
         {
-		    TextureRef ref = checkTexture(L);
-            luax_pushnumber(L, ref->getWidth()); 
+		    SharedTexture shared = checkTexture(L);
+            luax_pushnumber(L, shared->getWidth()); 
             return 1; 
         }
 
         LUA_IMPLEMENT int l_getHeight(lua_State *L)
         {
-		    TextureRef ref = checkTexture(L);
-            luax_pushnumber(L, ref->getHeight());
+		    SharedTexture shared = checkTexture(L);
+            luax_pushnumber(L, shared->getHeight());
             return 1;
         }
 
         LUA_IMPLEMENT int l_getSize(lua_State* L)
         {
-		    TextureRef ref = checkTexture(L);
-            luax_pushnumber(L, ref->getWidth());
-            luax_pushnumber(L, ref->getHeight());
+		    SharedTexture shared = checkTexture(L);
+            luax_pushnumber(L, shared->getWidth());
+            luax_pushnumber(L, shared->getHeight());
             return 2;
         }
 
diff --git a/src/lua/modules/graphics/je_lua_texture_font.cpp b/src/lua/modules/graphics/je_lua_texture_font.cpp
index 58011a7..dbaa997 100644
--- a/src/lua/modules/graphics/je_lua_texture_font.cpp
+++ b/src/lua/modules/graphics/je_lua_texture_font.cpp
@@ -39,7 +39,7 @@ namespace JinEngine
 			    Text* text = p2->getObject<Text>();
 			    page = tf->typeset(*text, lineheight, spacing);
 		    }
-		    Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_PAGE, sizeof(Proxy));
+		    Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_PAGE);
 		    Shared<Page>* refPage = new Shared<Page>(page, JIN_GRAPHICS_PAGE);
 		    {
 			    /* retain related ttf */
diff --git a/src/lua/modules/graphics/je_lua_ttf.cpp b/src/lua/modules/graphics/je_lua_ttf.cpp
index 4c56ae1..3e6050b 100644
--- a/src/lua/modules/graphics/je_lua_ttf.cpp
+++ b/src/lua/modules/graphics/je_lua_ttf.cpp
@@ -45,7 +45,7 @@ namespace JinEngine
 			    Text* text = p2->getObject<Text>();
 			    page = ttf->typeset(*text, lineheight, spacing);
 		    }
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_PAGE, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_PAGE);
 		    Shared<Page>* refPage = new Shared<Page>(page, JIN_GRAPHICS_PAGE);
 		    {
 			    /* retain related ttf */
diff --git a/src/lua/modules/graphics/je_lua_ttf_data.cpp b/src/lua/modules/graphics/je_lua_ttf_data.cpp
index d076ab8..e46fca6 100644
--- a/src/lua/modules/graphics/je_lua_ttf_data.cpp
+++ b/src/lua/modules/graphics/je_lua_ttf_data.cpp
@@ -17,7 +17,7 @@ namespace JinEngine
             int fontsize = luax_checkinteger(L, 2);
             Shared<TTFData>& refFontData = p->getShared<TTFData>();
 		    TTFData* fontData = refFontData.getObject();
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_GRAPHICS_TTF, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_GRAPHICS_TTF);
 		    TTF* font = fontData->createTTF(fontsize);
 		    Shared<TTF>* refTTF = new Shared<TTF>(font, JIN_GRAPHICS_TTF);
 		    {
diff --git a/src/lua/modules/net/je_lua_buffer.cpp b/src/lua/modules/net/je_lua_buffer.cpp
index 4c6880a..974c935 100644
--- a/src/lua/modules/net/je_lua_buffer.cpp
+++ b/src/lua/modules/net/je_lua_buffer.cpp
@@ -11,9 +11,9 @@ namespace JinEngine
         namespace Net
         {
 
-	        typedef Shared<Buffer>& BufferRef;
+	        typedef Shared<Buffer>& SharedBuffer;
 
-            static inline BufferRef checkNetBuffer(lua_State* L)
+            static inline SharedBuffer checkNetBuffer(lua_State* L)
             {
                 Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_NETWORK_BUFFER);
 		        return proxy->getShared<Buffer>();
@@ -22,13 +22,13 @@ namespace JinEngine
             // net.Buffer:append(value) -> value_length
             LUA_IMPLEMENT int l_append(lua_State* L)
             {
-		        BufferRef ref = checkNetBuffer(L);
+		        SharedBuffer shared = checkNetBuffer(L);
                 const int vp = 2;
                 if (luax_isintegerstrict(L, vp))
                 {
                     int n = luax_checkinteger(L, vp);
                     int size = sizeof(n);
-                    ref->append(&n, size);
+                    shared->append(&n, size);
                     luax_pushinteger(L, size);
                     return 1;
                 } 
@@ -36,7 +36,7 @@ namespace JinEngine
                 {
                     float n = luax_checknumber(L, vp);
                     int size = sizeof(n);
-			        ref->append(&n, size);
+			        shared->append(&n, size);
                     luax_pushinteger(L, size);
                     return 1;
                 }
@@ -44,7 +44,7 @@ namespace JinEngine
                 {
                     bool n = luax_checkbool(L, vp);
                     int size = sizeof(n);
-			        ref->append(&n, size);
+			        shared->append(&n, size);
                     luax_pushinteger(L, size);
                     return 1;
                 }
@@ -52,7 +52,7 @@ namespace JinEngine
                 {
                     const char* str = luax_checkstring(L, vp);
                     int size = strlen(str) + 1;
-			        ref->append(str, size);
+			        shared->append(str, size);
                     luax_pushinteger(L, size);
                     return 1;
                 }
@@ -66,10 +66,10 @@ namespace JinEngine
             // net.Buffer:grabString(offset) -> string, length
             LUA_IMPLEMENT int l_grabString(lua_State* L)
             {
-		        BufferRef ref = checkNetBuffer(L);
+		        SharedBuffer shared = checkNetBuffer(L);
                 int offset = luax_checkinteger(L, 2);
                 unsigned int len;
-                char* data = ref->grabString(&len, offset);
+                char* data = shared->grabString(&len, offset);
                 Array<char> str;
                 str.bind(data, len);
                 luax_pushstring(L, &str);
@@ -80,10 +80,10 @@ namespace JinEngine
             // net.Buffer:grabInteger(offset) -> integer, length
             LUA_IMPLEMENT int l_grabInteger(lua_State* L)
             {
-		        BufferRef ref = checkNetBuffer(L);
+		        SharedBuffer shared = checkNetBuffer(L);
                 int offset = luax_checkinteger(L, 2);
                 int len;
-                int integer = ref->grabInteger(&len, offset);
+                int integer = shared->grabInteger(&len, offset);
                 luax_pushinteger(L, integer);
                 luax_pushinteger(L, len);
                 return 2;
@@ -91,10 +91,10 @@ namespace JinEngine
 
             LUA_IMPLEMENT int l_grabFloat(lua_State* L)
             {
-		        BufferRef ref = checkNetBuffer(L);
+		        SharedBuffer shared = checkNetBuffer(L);
                 int offset = luax_checkinteger(L, 2);
                 int len;
-                float floatv = ref->grabFloat(&len, offset);
+                float floatv = shared->grabFloat(&len, offset);
                 luax_pushnumber(L, floatv);
                 luax_pushinteger(L, len);
                 return 2;
@@ -102,10 +102,10 @@ namespace JinEngine
 
             LUA_IMPLEMENT int l_grabBoolean(lua_State* L)
             {
-		        BufferRef ref = checkNetBuffer(L);
+		        SharedBuffer shared = checkNetBuffer(L);
                 int offset = luax_checkinteger(L, 2);
                 int len;
-                bool boolean = ref->grabBoolean(&len, offset);
+                bool boolean = shared->grabBoolean(&len, offset);
                 luax_pushboolean(L, boolean);
                 luax_pushinteger(L, len);
                 return 2;
diff --git a/src/lua/modules/net/je_lua_net.cpp b/src/lua/modules/net/je_lua_net.cpp
index cd454d5..58ece43 100644
--- a/src/lua/modules/net/je_lua_net.cpp
+++ b/src/lua/modules/net/je_lua_net.cpp
@@ -48,7 +48,7 @@ namespace Lua
             }
         }
         Socket* socket = new Socket(info);
-        Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_NETWORK_SOCKET, sizeof(Proxy));
+        Proxy* proxy = luax_newinstance(L, JIN_NETWORK_SOCKET);
         proxy->bind(new Shared<Socket>(socket, JIN_NETWORK_SOCKET));
         return 1;
     }
@@ -56,7 +56,7 @@ namespace Lua
     LUA_IMPLEMENT int l_Buffer(lua_State* L)
     {
         int size = luax_checkinteger(L, 1);
-        Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_NETWORK_BUFFER, sizeof(Proxy));
+        Proxy* proxy = luax_newinstance(L, JIN_NETWORK_BUFFER);
         Net::Buffer* buffer = new Net::Buffer(size);
         proxy->bind(new Shared<Buffer>(buffer, JIN_NETWORK_BUFFER));
         return 1;
diff --git a/src/lua/modules/net/je_lua_socket.cpp b/src/lua/modules/net/je_lua_socket.cpp
index 0b59199..4072921 100644
--- a/src/lua/modules/net/je_lua_socket.cpp
+++ b/src/lua/modules/net/je_lua_socket.cpp
@@ -12,11 +12,11 @@ namespace JinEngine
     namespace Lua
     {
 
-	    typedef Shared<Socket>& SocketRef;
+	    typedef Shared<Socket>& SharedSocket;
 
         const int BUFFER_SIZE = 1024;
 
-        LUA_IMPLEMENT inline SocketRef checkSocket(lua_State* L, int pos = 1)
+        LUA_IMPLEMENT inline SharedSocket checkSocket(lua_State* L, int pos = 1)
         {
             Proxy* proxy = (Proxy*)luax_checktype(L, pos, JIN_NETWORK_SOCKET);
 		    return proxy->getShared<Socket>();
@@ -31,9 +31,9 @@ namespace JinEngine
         // return net.Socket
         LUA_IMPLEMENT int l_accept(lua_State* L) 
         {
-		    SocketRef socket = checkSocket(L);
+		    SharedSocket socket = checkSocket(L);
             Socket* client = socket->accept();
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_NETWORK_SOCKET, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_NETWORK_SOCKET);
             proxy->bind(new Shared<Socket>(client, JIN_NETWORK_SOCKET));
             return 1;
         }
@@ -41,10 +41,10 @@ namespace JinEngine
         // return net.Buffer
         LUA_IMPLEMENT int l_receive(lua_State* L) 
         {
-		    SocketRef socket = checkSocket(L);
+		    SharedSocket socket = checkSocket(L);
             char buffer[BUFFER_SIZE] = {0};
             int size = socket->receive(buffer, BUFFER_SIZE);
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_NETWORK_BUFFER, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_NETWORK_BUFFER);
             Net::Buffer* netBuffer = new Net::Buffer(buffer, size);
             proxy->bind(new Shared<Buffer>(netBuffer, JIN_NETWORK_BUFFER));
             return 1;
@@ -53,13 +53,13 @@ namespace JinEngine
         // Socket:receiveFrom(address, port)
         LUA_IMPLEMENT int l_receiveFrom(lua_State* L) 
         {
-		    SocketRef socket = checkSocket(L);
+		    SharedSocket socket = checkSocket(L);
             int address = luax_checkinteger(L, 2);
             int port = luax_checkinteger(L, 3);
             char buffer[BUFFER_SIZE];
             int size = socket->receiveFrom(buffer, BUFFER_SIZE, address, port);
             Net::Buffer* netBuffer = new Net::Buffer(buffer, size);
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_NETWORK_BUFFER, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_NETWORK_BUFFER);
             proxy->bind(new Shared<Buffer>(netBuffer, JIN_NETWORK_BUFFER));
             return 1;
         }
@@ -67,9 +67,9 @@ namespace JinEngine
         // Socket:send(net.Buffer) -> data_length
         LUA_IMPLEMENT int l_send(lua_State* L) 
         {
-		    SocketRef socket = checkSocket(L);
-		    Shared<Buffer>& ref = checkNetBuffer(L, 2);
-            int len = socket->send(ref->buffer, ref->size);
+		    SharedSocket socket = checkSocket(L);
+		    Shared<Buffer>& shared = checkNetBuffer(L, 2);
+            int len = socket->send(shared->buffer, shared->size);
             luax_pushinteger(L, len);
             return 1;
         }
@@ -77,7 +77,7 @@ namespace JinEngine
         // Socket:sendTo(address, port, net.Buffer)
         LUA_IMPLEMENT int l_sendTo(lua_State* L) 
         {
-		    SocketRef socket = checkSocket(L);
+		    SharedSocket socket = checkSocket(L);
             int address = luax_checkinteger(L, 2);
             int port = luax_checkinteger(L, 3);
 		    Shared<Buffer>& buffer = checkNetBuffer(L, 4);
@@ -87,14 +87,14 @@ namespace JinEngine
     
         LUA_IMPLEMENT int l_close(lua_State* L) 
         {
-		    SocketRef socket = checkSocket(L);
+		    SharedSocket socket = checkSocket(L);
             socket->close();
             return 0;
         }
 
         LUA_IMPLEMENT int l_configBlocking(lua_State* L) 
         {
-		    SocketRef socket = checkSocket(L);
+		    SharedSocket socket = checkSocket(L);
             bool blocking = luax_checkbool(L, 2);
             socket->configureBlocking(blocking);
             return 0;
diff --git a/src/lua/modules/thread/je_lua_thread.cpp b/src/lua/modules/thread/je_lua_thread.cpp
index ab03561..dfe45e5 100644
--- a/src/lua/modules/thread/je_lua_thread.cpp
+++ b/src/lua/modules/thread/je_lua_thread.cpp
@@ -10,11 +10,11 @@ namespace JinEngine
     namespace Lua
     {
 
-	    typedef Shared<Thread>& ThreadRef;
+	    typedef Shared<Thread>& SharedThread;
 
         int luaopen_thread(lua_State* L);
 
-        static inline ThreadRef checkThread(lua_State* L)
+        static inline SharedThread checkThread(lua_State* L)
         {
             Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_THREAD_THREAD);
 		    return proxy->getShared<Thread>();
@@ -22,16 +22,16 @@ namespace JinEngine
 
         LUA_IMPLEMENT int threadRunner(void* t)
         {
-		    ThreadRef ref = *(Shared<Thread>*)t;
+		    SharedThread shared = *(Shared<Thread>*)t;
             lua_State* L = lua_open();
             luax_openlibs(L);
             luaopen_jin(L);
             luax_getglobal(L, MODULE_NAME);
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_THREAD_THREAD, sizeof(Proxy));
-            ref.retain();
-            proxy->bind(&ref);
+            Proxy* proxy = luax_newinstance(L, JIN_THREAD_THREAD);
+            shared.retain();
+            proxy->bind(&shared);
             luax_setfield(L, -2, "_curThread");
-            luax_dostring(L, ref->code.c_str());
+            luax_dostring(L, shared->code.c_str());
             luax_close(L);
             return 0;
         }
@@ -45,66 +45,66 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_start(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
-            bool result = ref->start(&ref);
+		    SharedThread shared = checkThread(L);
+            bool result = shared->start(&shared);
             luax_pushboolean(L, result);
             return 1;
         }
 
         LUA_IMPLEMENT int l_wait(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
-            ref->wait();
+		    SharedThread shared = checkThread(L);
+            shared->wait();
             return 0;
         }
 
         LUA_IMPLEMENT int l_send(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
             const int vp = 3;
             if (luax_isnumberstrict(L, vp))
             {
                 float real = luax_checknumber(L, vp);
-                ref->send(slot, real);
+                shared->send(slot, real);
             }
             else if (luax_isbooleanstrict(L, vp))
             {
                 bool bol = luax_checkbool(L, vp);
-			    ref->send(slot, bol);
+			    shared->send(slot, bol);
             }
             else if (luax_isstringstrict(L, vp))
             {
                 const char* str = luax_checkstring(L, vp);
-			    ref->send(slot, str);
+			    shared->send(slot, str);
             }
             else if (luax_isuserdata(L, vp))
             {
                 void* p = luax_touserdata(L, vp);
-			    ref->send(slot, p);
+			    shared->send(slot, p);
             }
             else if (luax_islightuserdata(L, vp))
             {
                 void* p = luax_tolightuserdata(L, vp);
-			    ref->send(slot, p);
+			    shared->send(slot, p);
             }
             return 0;
         }
 
         LUA_IMPLEMENT int l_receive(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
-            bool result = ref->receive(slot);
+            bool result = shared->receive(slot);
             luax_pushboolean(L, result);
             return 1;
         }
 
         LUA_IMPLEMENT int l_fetch(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
-            Thread::Variant v = ref->fetch(slot);
+            Thread::Variant v = shared->fetch(slot);
             switch (v.type)
             {
             case Thread::Variant::INTERGER:
@@ -125,9 +125,9 @@ namespace JinEngine
 
             case Thread::Variant::POINTER:
                 Proxy* p = (Proxy*)v.pointer;
-                Proxy* proxy = (Proxy*)luax_newinstance(L, p->getObjectType(), sizeof(Proxy));
-                p->shared->retain();
-                proxy->bind(p->shared);
+                Proxy* proxy = luax_newinstance(L, p->getObjectType());
+                p->reference->retain();
+                proxy->bind(p->reference);
                 break;
 
             }
@@ -136,9 +136,9 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_demand(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
-            Thread::Variant v = ref->demand(slot);
+            Thread::Variant v = shared->demand(slot);
             switch (v.type)
             {
             case Thread::Variant::INTERGER:
@@ -160,9 +160,9 @@ namespace JinEngine
             case Thread::Variant::POINTER:
                 Proxy* p = (Proxy*)v.pointer;
                 const char* objType = p->getObjectType();
-                Proxy* proxy = (Proxy*)luax_newinstance(L, objType, sizeof(Proxy));
-                p->retain();
-                proxy->bind(p->shared);
+                Proxy* proxy = luax_newinstance(L, objType);
+                p->reference->retain();
+                proxy->bind(p->reference);
                 break;
 
             }
@@ -171,24 +171,24 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_remove(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
-            ref->remove(slot);
+            shared->remove(slot);
             return 0;
         }
 
         LUA_IMPLEMENT int l_getName(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
-            const char* name = ref->getName();
+		    SharedThread shared = checkThread(L);
+            const char* name = shared->getName();
             luax_pushstring(L, name);
             return 1;
         }
 
         LUA_IMPLEMENT int l_isRunning(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
-            bool running = ref->isRunning();
+		    SharedThread shared = checkThread(L);
+            bool running = shared->isRunning();
             luax_pushboolean(L, running);
             return 1;
         }
@@ -218,7 +218,7 @@ namespace JinEngine
         {
             const char* name = luax_checkstring(L, 1);
             const char* code = luax_checkstring(L, 2);
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_THREAD_THREAD, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_THREAD_THREAD);
             Thread* thread = new Thread(name, code, threadRunner);
             proxy->bind(new Shared<Thread>(thread, JIN_THREAD_THREAD));
             return 1;
diff --git a/src/lua/modules/time/je_lua_timer.cpp b/src/lua/modules/time/je_lua_timer.cpp
index c28aafe..e57c666 100644
--- a/src/lua/modules/time/je_lua_timer.cpp
+++ b/src/lua/modules/time/je_lua_timer.cpp
@@ -6,7 +6,7 @@ namespace JinEngine
 {
     namespace Lua
     {
-
+/*
         typedef Shared<Timer>& TimerRef;
 
         LUA_IMPLEMENT inline TimerRef checkTimer(lua_State* L)
@@ -14,13 +14,13 @@ namespace JinEngine
             Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_TIME_TIMER);
             return proxy->getShared<Timer>();
         }
-
+*/
         LUA_IMPLEMENT int l_every(lua_State* L)
         {
-            //TimerRef ref = checkTimer(L);
-            //Timer* timer = ref.getObject();
+            //TimerRef shared = checkTimer(L);
+            //Timer* timer = shared.getObject();
             //int n = luax_checkinteger(L, 1);
-            //int ref = luax_ref(L, 2);
+            //int shared = luax_ref(L, 2);
             //timer->every(n, [](void* data)->void {
             //
             //}, );