5 files changed, 132 insertions, 122 deletions

diff --git a/src/lua/common/je_lua.cpp b/src/lua/common/je_lua.cpp
index a56ae4f..b09004f 100644
--- a/src/lua/common/je_lua.cpp
+++ b/src/lua/common/je_lua.cpp
@@ -18,9 +18,10 @@ namespace JinEngine
         LuaObject* luax_newinstance(lua_State* L, const char* type, SharedBase* shared)
         {
             LuaObject* luaObj = static_cast<LuaObject*>(luax_newinstance(L, type, sizeof(LuaObject)));
-            if (shared) luaObj->bind(shared);
+            luaObj->state = L;
+            luaObj->bind(shared);
+            // Add to objects_table, objects_table[shared] = luaObj
             luax_getobjectstable(L);
-            // Add to objects_table, like objects_table[shared] = luaObj
             luax_pushlightuserdata(L, shared);
             luax_pushvalue(L, -3);
             luax_settable(L, -3);
diff --git a/src/lua/common/je_lua_object.cpp b/src/lua/common/je_lua_object.cpp
index ce71283..d98099e 100644
--- a/src/lua/common/je_lua_object.cpp
+++ b/src/lua/common/je_lua_object.cpp
@@ -1,31 +1,111 @@
-#include "je_lua.h"
 #include "je_lua_object.h"
+#include "je_lua.h"
 
 namespace JinEngine
 {
     namespace Lua
     {
 
-        void LuaObject::bind(SharedBase* s)
+        void LuaObject::bind(SharedBase* obj)
         {
-            if (s == nullptr)
-                return;
-            shared = s;
-            shared->retain();
+            if (obj)
+            {
+                object = obj;
+                object->retain();
+                dependencies = new std::map<uint, SharedBase*>();
+            }
         }
 
         void LuaObject::release()
         {
-            if (shared != nullptr)
+            // Delete lua object table reference and references.
+            if (dependencies)
             {
-                shared->release();
-                shared = nullptr;
+                clearDependencies();
+                delete dependencies;
+                dependencies = nullptr;
+            }
+            // Try delete engine side object.
+            if (object)
+            {
+                object->release();
+                object = nullptr;
             }
         }
 
         const char* LuaObject::getObjectType()
         {
-            return shared->getType();
+            return object->getType();
+        }
+
+        SharedBase* LuaObject::getSharedBase()
+        {
+            return object;
+        }
+
+        void LuaObject::setDependency(uint key, SharedBase* dep)
+        {
+            removeDependency(key);
+            dependencies->insert(std::pair<uint, SharedBase*>(key, dep));
+            luax_addreference(state, object, dep);
+        }
+
+        void LuaObject::removeDependency(uint key)
+        {
+            if (!isDependOn(key))
+                return;
+            DepsMap::iterator it = dependencies->find(key);
+            SharedBase* dep = it->second;
+            luax_removereference(state, object, dep);
+            dependencies->erase(it);
+        }
+
+        void LuaObject::removeDependency(SharedBase* dependency)
+        {
+            for (DepsMap::iterator it = dependencies->begin(); it != dependencies->end();)
+            {
+                SharedBase* dep = it->second;
+                if (dep == dependency)
+                {
+                    luax_removereference(state, object, dep);
+                    dependencies->erase(it);
+                }
+                else
+                    ++it;
+            }
+        }
+
+        bool LuaObject::isDependOn(uint key)
+        {
+            return dependencies->find(key) != dependencies->end();
+        }
+
+        bool LuaObject::isDependOn(SharedBase* shared)
+        {
+            for (std::pair<uint, SharedBase*> dep : (*dependencies))
+            {
+                if (dep.second == shared)
+                    return true;
+            }
+            return false;
+        }
+
+        void LuaObject::clearDependencies()
+        {
+            luax_removereference(state, object);
+            dependencies->clear();
+        }
+
+        SharedBase* LuaObject::getDependency(uint key)
+        {
+            if (!isDependOn(key))
+                return nullptr;
+            return dependencies->find(key)->second;
+        }
+
+        int LuaObject::getDependenciesCount()
+        {
+            return dependencies->size();
         }
 
     }
diff --git a/src/lua/common/je_lua_object.h b/src/lua/common/je_lua_object.h
index bd3ddd6..1d74de9 100644
--- a/src/lua/common/je_lua_object.h
+++ b/src/lua/common/je_lua_object.h
@@ -1,6 +1,7 @@
-#ifndef __JIN_COMMON_PROXY_H__
-#define __JIN_COMMON_PROXY_H__
+#ifndef __JIN_COMMON_OBJECT_H__
+#define __JIN_COMMON_OBJECT_H__
 
+#include "libjin/jin.h"
 #include "je_lua_shared.hpp"
 
 struct lua_State;
@@ -16,21 +17,18 @@ namespace JinEngine
             ///
             /// Set lua_State and object it bind.
             ///
-            void bind(SharedBase* s);
+            void bind(SharedBase* obj);
 
             void release();
 
             const char* getObjectType();
 
+            SharedBase* getSharedBase();
+
             template<class T>
             Shared<T>& getShared()
             {
-                return *(Shared<T>*)shared;
-            }
-
-            SharedBase* getSharedBase()
-            {
-                return shared;
+                return *(Shared<T>*)object;
             }
 
             ///
@@ -43,15 +41,38 @@ namespace JinEngine
                 return shared.getObject();
             }
 
+            void setDependency(uint key, SharedBase* shared);
+
+            void removeDependency(uint key);
+
+            void removeDependency(SharedBase* dep);
+
+            bool isDependOn(uint key);
+
+            bool isDependOn(SharedBase* shared);
+
+            void clearDependencies();
+
+            SharedBase* getDependency(uint key);
+
+            int getDependenciesCount();
+
+            //////////////////////////////////////////////////////////////////////////////////////////////////////
+            // 
+            //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+            lua_State* state;
+
+            SharedBase* object;
+
+            std::map<uint, SharedBase*>* dependencies;
+
         private:
-            ///
-            /// 
-            ///
-            SharedBase* shared;
+            using DepsMap = std::map<uint, SharedBase*>;
 
         };
 
     } // namespace Lua
 } // namespace JinEngine
 
-#endif // __JIN_COMMON_PROXY_H__
\ No newline at end of file
+#endif // __JIN_COMMON_OBJECT_H__
\ No newline at end of file
diff --git a/src/lua/common/je_lua_shared.cpp b/src/lua/common/je_lua_shared.cpp
index 076f176..91a5105 100644
--- a/src/lua/common/je_lua_shared.cpp
+++ b/src/lua/common/je_lua_shared.cpp
@@ -6,17 +6,15 @@ namespace JinEngine
     namespace Lua
     {
 
-        SharedBase::SharedBase(lua_State* L, void* obj, const char* t)
+        SharedBase::SharedBase(void* obj, const char* t)
             : mCount(0)
             , mObject(obj)
-            , mL(L)
             , mType(t)
         {
         }
 
         SharedBase::~SharedBase()
         {
-            clearDependencies();
         }
 
         void SharedBase::retain()
@@ -28,83 +26,15 @@ namespace JinEngine
         {
             if (--mCount <= 0)
             {
-                luax_removereference(mL, this);
-                luax_removeobject(mL, this);
                 delete this;
             }
         }
 
-        void SharedBase::setDependency(int key, SharedBase* dep)
-        {
-            removeDependency(key);
-            mDependencies.insert(std::pair<int, SharedBase*>(key, dep));
-            luax_addreference(mL, this, dep);
-        }
-
-        void SharedBase::removeDependency(int key)
-        {
-            if (!isDependOn(key))
-                return;
-            DepsMap::iterator it = mDependencies.find(key);
-            SharedBase* dep = it->second;
-            luax_removereference(mL, this, dep);
-            mDependencies.erase(it);
-        }
-
-        void SharedBase::removeDependency(SharedBase* dependency)
-        {
-            for (DepsMap::iterator it = mDependencies.begin(); it != mDependencies.end();)
-            {
-                SharedBase* dep = it->second;
-                if (dep == dependency)
-                {
-                    luax_removereference(mL, this, dep);
-                    mDependencies.erase(it);
-                }
-                else
-                    ++it;
-            }
-        }
-
-        bool SharedBase::isDependOn(int key)
-        {
-            return mDependencies.find(key) != mDependencies.end();
-        }
-
-        bool SharedBase::isDependOn(SharedBase* shared)
-        {
-            for (std::pair<int, SharedBase*> dep : mDependencies)
-            {
-                if (dep.second == shared)
-                    return true;
-            }
-            return false;
-        }
-
-        void SharedBase::clearDependencies()
-        {
-            for (std::pair<int, SharedBase*> dep : mDependencies)
-                luax_removereference(mL, this);
-            mDependencies.clear();
-        }
-
-        SharedBase* SharedBase::getDependency(int key)
-        {
-            if (!isDependOn(key))
-                return nullptr;
-            return mDependencies.find(key)->second;
-        }
-
         bool SharedBase::isType(const char* t)
         {
             return strcmp(mType, t) == 0;
         }
 
-        int SharedBase::getDependenciesCount()
-        {
-            return mDependencies.size();
-        }
-
         const char* SharedBase::getType()
         {
             return mType;
diff --git a/src/lua/common/je_lua_shared.hpp b/src/lua/common/je_lua_shared.hpp
index 0a05e1a..ad65be0 100644
--- a/src/lua/common/je_lua_shared.hpp
+++ b/src/lua/common/je_lua_shared.hpp
@@ -5,8 +5,6 @@
 #include <vector>
 #include <functional>
 
-struct lua_State;
-
 namespace JinEngine
 {
     namespace Lua
@@ -22,39 +20,19 @@ namespace JinEngine
 
             void release();
 
-            void setDependency(int key, SharedBase* shared);
-
-            void removeDependency(int key);
-
-            void removeDependency(SharedBase* dep);
-
-            bool isDependOn(int key);
-
-            bool isDependOn(SharedBase* shared);
-
-            void clearDependencies();
-
-            SharedBase* getDependency(int key);
-
             bool isType(const char* t);
 
-            int getDependenciesCount();
-
             const char* getType();
 
         protected:
-            SharedBase(lua_State* L, void* obj, const char* t);
+            SharedBase(void* obj, const char* t);
 
             SharedBase(const SharedBase&);
 
             virtual ~SharedBase();
 
-            using DepsMap = std::map<int, SharedBase*>;
-
-            lua_State* mL;
             void* mObject;
             int mCount;
-            DepsMap mDependencies;
             const char* mType;
 
         };
@@ -63,8 +41,8 @@ namespace JinEngine
         class Shared : public SharedBase
         {
         public:
-            Shared(lua_State* L, T* obj, const char* type)
-                : SharedBase(L, obj, type)
+            Shared(T* obj, const char* type)
+                : SharedBase(obj, type)
             {
             }