lumino 0.9.0 → 0.10.0

data/ext/LuminoRubyRuntimeManager.cpp

@@ -1,20 +1,19 @@
 #if 1
 #include "LuminoRubyRuntimeManager.h"
 
-extern "C" LN_FLAT_API LnResult LnEngine_Finalize();
-extern "C" LN_FLAT_API void LnRuntime_RunAppInternal(LnHandle app);
+extern "C" LN_FLAT_API void LNRuntime_RunAppInternal(LNHandle app);
 
 //==============================================================================
 // 
 
-static VALUE Wrap_LnRuntime_RunAppInternal(VALUE self, VALUE app)
+static VALUE Wrap_LNRuntime_RunAppInternal(VALUE self, VALUE app)
 {
-    LnHandle handle = LuminoRubyRuntimeManager::instance->getHandle(app);
-    LnRuntime_RunAppInternal(handle);
+    LNHandle handle = LuminoRubyRuntimeManager::instance->getHandle(app);
+    LNRuntime_RunAppInternal(handle);
     return Qnil;
 }
 
-VALUE Wrap_LnRuntime_RegisterType(VALUE self, VALUE type)
+VALUE Wrap_LNRuntime_RegisterType(VALUE self, VALUE type)
 {
     std::string className;
     {
@@ -31,25 +30,25 @@ VALUE Wrap_LnRuntime_RegisterType(VALUE self, VALUE type)
     LNRB_LOG_D("Usesr type registering. (class: %s, superclass: %s)", className.c_str(), superclassName.c_str());
 
     int typeInfoId;
-    LnTypeInfo_AcquireA(className.c_str(), &typeInfoId);
+    LNTypeInfo_AcquireA(className.c_str(), &typeInfoId);
 
     int baseTypeInfoId;
-    LnTypeInfo_AcquireA(superclassName.c_str(), &baseTypeInfoId);
+    LNTypeInfo_AcquireA(superclassName.c_str(), &baseTypeInfoId);
 
-    LnTypeInfo_SetBaseClass(typeInfoId, baseTypeInfoId);
-    LnTypeInfo_SetCreateInstanceCallback(typeInfoId, &LuminoRubyRuntimeManager::handleCreateInstanceCallback);
+    LNTypeInfo_SetBaseClass(typeInfoId, baseTypeInfoId);
+    LNTypeInfo_SetCreateInstanceCallback(typeInfoId, &LuminoRubyRuntimeManager::handleCreateInstanceCallback);
 
     // ユーザー定義型として、あとでインスタンス生成時に型情報を関連付けるときに高速に検索できるように覚えておく
     LuminoRubyRuntimeManager::instance->m_userDefinedClassTypeIdMap[className] = typeInfoId;
 
     int managedTypeInfoId = LuminoRubyRuntimeManager::instance->registerTypeInfo(type, nullptr);
-    LnTypeInfo_SetManagedTypeInfoId(typeInfoId, managedTypeInfoId);
+    LNTypeInfo_SetManagedTypeInfoId(typeInfoId, managedTypeInfoId);
     
     LNRB_LOG_D("Usesr type registerd. (typeInfoId: %d, baseTypeInfoId: %d, managedTypeInfoId: %d)", typeInfoId, baseTypeInfoId, managedTypeInfoId);
     return Qnil;
 }
 
-static VALUE Wrap_LnRuntime_inherited(VALUE self, VALUE type)
+static VALUE Wrap_LNRuntime_inherited(VALUE self, VALUE type)
 {
     VALUE v  = rb_funcall(type, rb_intern("name"), 0, 0);
     std::string name2 = StringValuePtr(v);
@@ -59,10 +58,10 @@ static VALUE Wrap_LnRuntime_inherited(VALUE self, VALUE type)
     LNRB_LOG_D("Usesr type registering from 'self.inherited.' (%s)", name.c_str());
 
     int typeInfoId = 0;
-    LnTypeInfo_FindA(name.c_str(), &typeInfoId);
+    LNTypeInfo_FindA(name.c_str(), &typeInfoId);
 
     if (typeInfoId == 0) {
-        Wrap_LnRuntime_RegisterType(self, type);
+        Wrap_LNRuntime_RegisterType(self, type);
     }
 
     LNRB_LOG_D("Usesr type registerd from 'self.inherited.' (%d)", typeInfoId);
@@ -73,7 +72,7 @@ static VALUE Wrap_LnRuntime_inherited(VALUE self, VALUE type)
 // LuminoRubyRuntimeManager
 
 LuminoRubyRuntimeManager* LuminoRubyRuntimeManager::instance = nullptr;
-LnLogLevel LuminoRubyRuntimeManager::s_logLevel = LN_LOG_LEVEL_INFO;
+LNLogLevel LuminoRubyRuntimeManager::s_logLevel = LN_LOG_LEVEL_INFO;
 
 LuminoRubyRuntimeManager* LuminoRubyRuntimeManager::getInstance(VALUE managerInstance)
 {
@@ -90,23 +89,24 @@ void LuminoRubyRuntimeManager::init()
     {
         VALUE LUMINO_LOG_LEVEL = rb_eval_string_protect("$LUMINO_LOG_LEVEL", NULL);
         if (LUMINO_LOG_LEVEL != Qnil) {
-            s_logLevel = (LnLogLevel)FIX2INT(LUMINO_LOG_LEVEL);
-            LnLog_SetLevel(s_logLevel);
+            s_logLevel = (LNLogLevel)FIX2INT(LUMINO_LOG_LEVEL);
+            LNLog_SetLevel(s_logLevel);
+            LNEngineSettings_SetDebugMode(LN_TRUE);
         }
         
         VALUE LUMINO_ENGINE_RESOURCES_DIR = rb_eval_string_protect("$LUMINO_ENGINE_RESOURCES_DIR", NULL);
         if (LUMINO_ENGINE_RESOURCES_DIR != Qnil) {
             const char* path = StringValuePtr(LUMINO_ENGINE_RESOURCES_DIR);
             printf("path: %s\n", path);
-            LnInternalEngineSettings_SetEngineResourcesPathA(path);
+            LNInternalEngineSettings_SetEngineResourcesPathA(path);
         }
 
-        LnRuntimeSettings settings;
+        LNRuntimeSettings settings;
         settings.runtimeFinalizedCallback = handleRuntimeFinalized;
         settings.referenceCountTrackerCallback = handleReferenceChangedStatic;
         settings.runtimeGetTypeInfoIdCallback = nullptr;
 
-        LnRuntime_Initialize(&settings);
+        LNRuntime_Initialize(&settings);
     }
 
     // Define core functions.
@@ -140,12 +140,12 @@ void LuminoRubyRuntimeManager::init()
         m_eventSignalClass = rb_eval_string("Lumino::EventSignal");
 
         m_objectClass = rb_define_class_under(m_luminoModule, "Object", rb_cObject);
-        rb_define_singleton_method(m_objectClass, "inherited", reinterpret_cast<VALUE(__cdecl *)(...)>(Wrap_LnRuntime_inherited), 1);
+        rb_define_singleton_method(m_objectClass, "inherited", reinterpret_cast<VALUE(__cdecl *)(...)>(Wrap_LNRuntime_inherited), 1);
 
         VALUE class_Application = rb_define_class_under(m_luminoModule, "Application", m_objectClass);
-        rb_define_singleton_method(class_Application, "run_app_internal", reinterpret_cast<VALUE(__cdecl *)(...)>(Wrap_LnRuntime_RunAppInternal), 1);
+        rb_define_singleton_method(class_Application, "run_app_internal", reinterpret_cast<VALUE(__cdecl *)(...)>(Wrap_LNRuntime_RunAppInternal), 1);
         
-        rb_define_module_function(m_luminoModule, "register_type", reinterpret_cast<VALUE(__cdecl *)(...)>(Wrap_LnRuntime_RegisterType), 1);
+        rb_define_module_function(m_luminoModule, "register_type", reinterpret_cast<VALUE(__cdecl *)(...)>(Wrap_LNRuntime_RegisterType), 1);
     }
 
     m_typeInfoList.push_back({});   // [0] is dummy
@@ -158,18 +158,18 @@ void LuminoRubyRuntimeManager::init()
     m_runtimeAliving = true;
 }
 
-VALUE LuminoRubyRuntimeManager::wrapObjectForGetting(LnHandle handle, bool retain)
+VALUE LuminoRubyRuntimeManager::wrapObjectForGetting(LNHandle handle, bool retain)
 {
     if (handle == LN_NULL_HANDLE) return Qnil;
 
-    int objectIndex = (int)LnRuntime_GetManagedObjectId(handle);
-    int typeinfoIndex = (int)LnRuntime_GetManagedTypeInfoId(handle);
+    int objectIndex = (int)LNRuntime_GetManagedObjectId(handle);
+    int typeinfoIndex = (int)LNRuntime_GetManagedTypeInfoId(handle);
 
     if (objectIndex <= 0) {
         LNRB_LOG_D("New Ruby object from WrapObjectForGetting (typeinfoIndex:%d)", typeinfoIndex);
         VALUE obj = m_typeInfoList[typeinfoIndex].factory(m_typeInfoList[typeinfoIndex].klass, handle);
         if (retain) {
-            LnObject_Retain(handle);
+            LNObject_Retain(handle);
         }
         registerWrapperObject(obj, true);
         return obj;
@@ -179,7 +179,7 @@ VALUE LuminoRubyRuntimeManager::wrapObjectForGetting(LnHandle handle, bool retai
     }
 }
 
-LnHandle LuminoRubyRuntimeManager::getHandle(VALUE value) const
+LNHandle LuminoRubyRuntimeManager::getHandle(VALUE value) const
 {
     if (value == Qnil) {
         return LN_NULL_HANDLE;
@@ -206,9 +206,9 @@ int LuminoRubyRuntimeManager::registerTypeInfo(VALUE klass, ObjectFactoryFunc fa
 
 void LuminoRubyRuntimeManager::registerWrapperObject(VALUE obj, bool forNativeGetting)
 {
-    LnHandle handle = getHandle(obj);
+    LNHandle handle = getHandle(obj);
 
-    int64_t id = LnRuntime_GetManagedObjectId(handle);
+    int64_t id = LNRuntime_GetManagedObjectId(handle);
     if (id > 0) {
         // 登録済み
         LNRB_LOG_D("registerWrapperObject: [Registerd] ManagedObjectId: %d\n", id);
@@ -233,7 +233,7 @@ void LuminoRubyRuntimeManager::registerWrapperObject(VALUE obj, bool forNativeGe
         m_objectList[index].strongRef = obj;
     }
     
-    LnRuntime_SetManagedObjectId(handle, index);
+    LNRuntime_SetManagedObjectId(handle, index);
     LNRB_LOG_D("registerWrapperObject (handle:%u, ManagedObjectId:%d)\n", handle, index);
 
     // ユーザー定義型の型情報をオブジェクトにセットする
@@ -245,19 +245,19 @@ void LuminoRubyRuntimeManager::registerWrapperObject(VALUE obj, bool forNativeGe
         // ユーザー定義型に限定する (Engine 内部型は登録する必要なし)
         auto itr = m_userDefinedClassTypeIdMap.find(name);
         if (itr != m_userDefinedClassTypeIdMap.end()) {
-            LnObject_SetTypeInfoId(handle, itr->second);
-            LNRB_LOG_D("LnObject_SetTypeInfoId (handle:%u, itr->second:%d)\n", handle, itr->second);
+            LNObject_SetTypeInfoId(handle, itr->second);
+            LNRB_LOG_D("LNObject_SetTypeInfoId (handle:%u, itr->second:%d)\n", handle, itr->second);
         }
     }
 
 }
 
-void LuminoRubyRuntimeManager::unregisterWrapperObject(LnHandle handle)
+void LuminoRubyRuntimeManager::unregisterWrapperObject(LNHandle handle)
 {
-    LNRB_LOG_D("LuminoRubyRuntimeManager::unregisterWrapperObject: LnHandle=%u\n", handle);
+    LNRB_LOG_D("LuminoRubyRuntimeManager::unregisterWrapperObject: LNHandle=%u\n", handle);
     if (m_runtimeAliving) {
-        LnObject_Release(handle);
-        int index = (int)LnRuntime_GetManagedObjectId(handle);
+        LNObject_Release(handle);
+        int index = (int)LNRuntime_GetManagedObjectId(handle);
         m_objectList[index].weakRef = Qnil;
         m_objectList[index].strongRef = Qnil;
         m_objectListIndexStack.push(index);
@@ -295,14 +295,14 @@ void LuminoRubyRuntimeManager::gc_mark(LuminoRubyRuntimeManager* obj)
     }
 }
 
-void LuminoRubyRuntimeManager::handleReferenceChangedStatic(LnHandle handle, int method, int count)
+void LuminoRubyRuntimeManager::handleReferenceChangedStatic(LNHandle handle, int method, int count)
 {
     instance->handleReferenceChanged(handle, method, count);
 }
 
-void LuminoRubyRuntimeManager::handleReferenceChanged(LnHandle handle, int method, int count)
+void LuminoRubyRuntimeManager::handleReferenceChanged(LNHandle handle, int method, int count)
 {
-    int objectIndex = (int)LnRuntime_GetManagedObjectId(handle);
+    int objectIndex = (int)LNRuntime_GetManagedObjectId(handle);
 
     if (method == LNI_REFERENCE_RETAINED) {
         if (count >= 2) {
@@ -324,13 +324,13 @@ void LuminoRubyRuntimeManager::handleRuntimeFinalized()
     LNRB_LOG_D("Runtime finalized.");
 }
 
-void LuminoRubyRuntimeManager::handleCreateInstanceCallback(int typeInfoId, LnHandle* outHandle)
+void LuminoRubyRuntimeManager::handleCreateInstanceCallback(int typeInfoId, LNHandle* outHandle)
 {
     LNRB_LOG_D("start: handleCreateInstanceCallback");
     auto* manager = LuminoRubyRuntimeManager::instance;
 
     int managedTypeInfoId = -1;
-    LnTypeInfo_GetManagedTypeInfoId(typeInfoId, &managedTypeInfoId);
+    LNTypeInfo_GetManagedTypeInfoId(typeInfoId, &managedTypeInfoId);
 
     
     printf("managedTypeInfoId: %d\n", managedTypeInfoId);
@@ -355,7 +355,7 @@ void LuminoRubyRuntimeManager::handleCreateInstanceCallback(int typeInfoId, LnHa
 
 void LuminoRubyRuntimeManager::dumpInfo() const
 {
-    LnRuntime_DumpInfo();
+    LNRuntime_DumpInfo();
     
     std::cout << std::endl;
     std::cout << "Ruby alive objects" << std::endl;

data/ext/LuminoRubyRuntimeManager.h

@@ -6,11 +6,13 @@
 #include <stack>
 #include <unordered_map>
 #include "FlatCommon.h"
+#include "FlatC.generated.h"
 
-#define LNRB_LOG_D(...) LnLog_PrintA(LN_LOG_LEVEL_DEBUG, "RubyRuntime", __VA_ARGS__)
-#define LNRB_LOG_I(...) LnLog_WriteA(LN_LOG_LEVEL_INFO, "RubyRuntime", __VA_ARGS__)
+extern "C" LN_FLAT_API void LNLog_PrintA(LNLogLevel level, const char* tag, const char* format, ...);
+#define LNRB_LOG_D(...) LNLog_PrintA(LN_LOG_LEVEL_DEBUG, "RubyRuntime", __VA_ARGS__)
+#define LNRB_LOG_I(...) LNLog_PrintA(LN_LOG_LEVEL_INFO, "RubyRuntime", __VA_ARGS__)
 
-typedef VALUE(*ObjectFactoryFunc)(VALUE klass, LnHandle handle);
+typedef VALUE(*ObjectFactoryFunc)(VALUE klass, LNHandle handle);
 
 struct TypeInfo
 {
@@ -20,7 +22,7 @@ struct TypeInfo
 
 struct Wrap_RubyObject
 {
-    LnHandle handle;
+    LNHandle handle;
     Wrap_RubyObject() : handle(0) {}
 };
 
@@ -33,25 +35,25 @@ public:
     static const int InitialListSize = 512;
 
     static LuminoRubyRuntimeManager* instance;
-    static LnLogLevel s_logLevel;
+    static LNLogLevel s_logLevel;
 
     void init();
     VALUE luminoModule() const { return m_luminoModule; }
     VALUE eventSignalClass() const { return m_eventSignalClass; }
-    VALUE wrapObjectForGetting(LnHandle handle, bool retain = true);
-    LnHandle getHandle(VALUE value) const;
+    VALUE wrapObjectForGetting(LNHandle handle, bool retain = true);
+    LNHandle getHandle(VALUE value) const;
     int registerTypeInfo(VALUE klass, ObjectFactoryFunc factory);
     void registerWrapperObject(VALUE obj, bool forNativeGetting);
-    void unregisterWrapperObject(LnHandle handle);
+    void unregisterWrapperObject(LNHandle handle);
 
     // for generator interface
     static LuminoRubyRuntimeManager* getInstance(VALUE managerInstance);
     static void gc_mark(LuminoRubyRuntimeManager* obj);
-    static void handleReferenceChangedStatic(LnHandle handle, int method, int count);
-    void handleReferenceChanged(LnHandle handle, int method, int count);
+    static void handleReferenceChangedStatic(LNHandle handle, int method, int count);
+    void handleReferenceChanged(LNHandle handle, int method, int count);
 
     static void handleRuntimeFinalized();
-    static void handleCreateInstanceCallback(int typeInfoId, LnHandle* outHandle);
+    static void handleCreateInstanceCallback(int typeInfoId, LNHandle* outHandle);
 
     void dumpInfo() const;
 
@@ -82,11 +84,11 @@ public:
     static std::string makeTypeInfoName(VALUE klass);
 };
 
-inline VALUE LNRB_HANDLE_WRAP_TO_VALUE(LnHandle handle) { return LuminoRubyRuntimeManager::instance->wrapObjectForGetting(handle); }
-inline VALUE LNRB_HANDLE_WRAP_TO_VALUE(LnHandle handle, VALUE& accessorCache) { return LuminoRubyRuntimeManager::instance->wrapObjectForGetting(handle); }
-inline VALUE LNRB_HANDLE_WRAP_TO_VALUE(LnHandle handle, std::vector<VALUE>& accessorCache, int index) { return LuminoRubyRuntimeManager::instance->wrapObjectForGetting(handle); }
-inline void LNRB_SAFE_UNREGISTER_WRAPPER_OBJECT(LnHandle handle) { if ( LuminoRubyRuntimeManager::instance) LuminoRubyRuntimeManager::instance->unregisterWrapperObject(handle); }
+inline VALUE LNRB_HANDLE_WRAP_TO_VALUE(LNHandle handle) { return LuminoRubyRuntimeManager::instance->wrapObjectForGetting(handle); }
+inline VALUE LNRB_HANDLE_WRAP_TO_VALUE(LNHandle handle, VALUE& accessorCache) { return LuminoRubyRuntimeManager::instance->wrapObjectForGetting(handle); }
+inline VALUE LNRB_HANDLE_WRAP_TO_VALUE(LNHandle handle, std::vector<VALUE>& accessorCache, int index) { return LuminoRubyRuntimeManager::instance->wrapObjectForGetting(handle); }
+inline void LNRB_SAFE_UNREGISTER_WRAPPER_OBJECT(LNHandle handle) { if ( LuminoRubyRuntimeManager::instance) LuminoRubyRuntimeManager::instance->unregisterWrapperObject(handle); }
 
-inline VALUE LNRB_HANDLE_WRAP_TO_VALUE_NO_RETAIN(LnHandle handle) { return LuminoRubyRuntimeManager::instance->wrapObjectForGetting(handle, false); }
+inline VALUE LNRB_HANDLE_WRAP_TO_VALUE_NO_RETAIN(LNHandle handle) { return LuminoRubyRuntimeManager::instance->wrapObjectForGetting(handle, false); }
 
 

data/lib/lumino/version.rb

@@ -1,3 +1,3 @@
 module Lumino
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: lumino
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - lriki
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-09 00:00:00.000000000 Z
+date: 2021-02-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.1.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.1.4
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -191,7 +163,7 @@ homepage: https://github.com/LuminoEngine/Lumino
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - ext
@@ -208,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Real-time graphics application framework.
 test_files: []