Added sceneid to script property

Author: eduardodoria

engine/core/manager/SceneManager.cpp

@@ -12,6 +12,7 @@ using namespace Supernova;
 
 std::vector<SceneManager::SceneEntry> SceneManager::entries;
 uint32_t SceneManager::currentId = 0;
+std::map<uint32_t, Scene*> SceneManager::scenePtrs;
 
 void SceneManager::registerScene(uint32_t id, const std::string& name, std::function<void()> factory) {
     // Overwrite if the id already exists
@@ -88,4 +89,22 @@ std::string SceneManager::getCurrentSceneName() {
 void SceneManager::clearAll() {
     entries.clear();
     currentId = 0;
+    scenePtrs.clear();
+}
+
+void SceneManager::setScenePtr(uint32_t id, Scene* scene) {
+    if (scene) {
+        scenePtrs[id] = scene;
+    } else {
+        scenePtrs.erase(id);
+    }
+}
+
+Scene* SceneManager::getScenePtr(uint32_t id) {
+    auto it = scenePtrs.find(id);
+    return (it != scenePtrs.end()) ? it->second : nullptr;
+}
+
+void SceneManager::removeScenePtr(uint32_t id) {
+    scenePtrs.erase(id);
 }

engine/core/manager/SceneManager.h

@@ -9,10 +9,13 @@
 #include <string>
 #include <functional>
 #include <vector>
+#include <map>
 #include <cstdint>
 
 namespace Supernova {
 
+    class Scene;
+
     // SceneManager allows registering named scene stacks and switching between them at runtime.
     // A "scene stack" corresponds to an editor SceneProject: one main Scene plus zero or more
     // layer Scenes. The factory function is responsible for calling Engine::setScene() and
@@ -37,6 +40,7 @@ namespace Supernova {
 
         static std::vector<SceneEntry> entries;
         static uint32_t currentId;
+        static std::map<uint32_t, Scene*> scenePtrs;
 
     public:
         // Register a named scene stack.
@@ -73,6 +77,15 @@ namespace Supernova {
 
         // Remove all registered scenes. Intended for editor use when resetting state.
         static void clearAll();
+
+        // Store a scene pointer associated with a scene ID for cross-scene entity resolution.
+        static void setScenePtr(uint32_t id, Scene* scene);
+
+        // Retrieve a stored scene pointer by ID. Returns nullptr if not found.
+        static Scene* getScenePtr(uint32_t id);
+
+        // Remove a stored scene pointer.
+        static void removeScenePtr(uint32_t id);
     };
 
 } // namespace Supernova

engine/core/script/LuaBinding.cpp

@@ -8,6 +8,7 @@
 #include "System.h"
 #include "Engine.h"
 #include "Scene.h"
+#include "SceneManager.h"
 #include "component/ScriptComponent.h"
 #include "ScriptProperty.h"
 #include "object/EntityHandle.h"
@@ -569,36 +570,42 @@ void LuaBinding::initializeLuaScripts(Scene* scene) {
                 bool foundScript = false;
 
                 if (targetEntity != NULL_ENTITY) {
-                    ScriptComponent* targetScriptComp = scene->findComponent<ScriptComponent>(targetEntity);
-                    if (targetScriptComp) {
-                        if (!prop.ptrTypeName.empty()) {
-                            for (auto& targetScript : targetScriptComp->scripts) {
-                                if (targetScript.type == ScriptType::SCRIPT_LUA &&
-                                    targetScript.className == prop.ptrTypeName &&
-                                    targetScript.enabled && targetScript.instance) {
-                                    int targetRef = static_cast<int>(reinterpret_cast<intptr_t>(targetScript.instance));
-                                    lua_rawgeti(L, LUA_REGISTRYINDEX, targetRef);
-                                    foundScript = true;
-                                    break;
+                    Scene* targetScene = scene;
+                    if (prop.sceneId != 0) {
+                        targetScene = SceneManager::getScenePtr(prop.sceneId);
+                    }
+                    if (targetScene) {
+                        ScriptComponent* targetScriptComp = targetScene->findComponent<ScriptComponent>(targetEntity);
+                        if (targetScriptComp) {
+                            if (!prop.ptrTypeName.empty()) {
+                                for (auto& targetScript : targetScriptComp->scripts) {
+                                    if (targetScript.type == ScriptType::SCRIPT_LUA &&
+                                        targetScript.className == prop.ptrTypeName &&
+                                        targetScript.enabled && targetScript.instance) {
+                                        int targetRef = static_cast<int>(reinterpret_cast<intptr_t>(targetScript.instance));
+                                        lua_rawgeti(L, LUA_REGISTRYINDEX, targetRef);
+                                        foundScript = true;
+                                        break;
+                                    }
                                 }
-                            }
-                            if (!foundScript)
-                                foundScript = pushEntityHandleByType(L, scene, targetEntity, prop.ptrTypeName);
-                        } else {
-                            for (auto& targetScript : targetScriptComp->scripts) {
-                                if (targetScript.type == ScriptType::SCRIPT_LUA &&
-                                    targetScript.enabled && targetScript.instance) {
-                                    int targetRef = static_cast<int>(reinterpret_cast<intptr_t>(targetScript.instance));
-                                    lua_rawgeti(L, LUA_REGISTRYINDEX, targetRef);
-                                    foundScript = true;
-                                    break;
+                                if (!foundScript)
+                                    foundScript = pushEntityHandleByType(L, targetScene, targetEntity, prop.ptrTypeName);
+                            } else {
+                                for (auto& targetScript : targetScriptComp->scripts) {
+                                    if (targetScript.type == ScriptType::SCRIPT_LUA &&
+                                        targetScript.enabled && targetScript.instance) {
+                                        int targetRef = static_cast<int>(reinterpret_cast<intptr_t>(targetScript.instance));
+                                        lua_rawgeti(L, LUA_REGISTRYINDEX, targetRef);
+                                        foundScript = true;
+                                        break;
+                                    }
                                 }
+                                if (!foundScript)
+                                    foundScript = pushEntityHandleByType(L, targetScene, targetEntity, prop.ptrTypeName);
                             }
-                            if (!foundScript)
-                                foundScript = pushEntityHandleByType(L, scene, targetEntity, prop.ptrTypeName);
+                        } else {
+                            foundScript = pushEntityHandleByType(L, targetScene, targetEntity, prop.ptrTypeName);
                         }
-                    } else {
-                        foundScript = pushEntityHandleByType(L, scene, targetEntity, prop.ptrTypeName);
                     }
                 }
 

engine/core/script/ScriptProperty.h

@@ -62,6 +62,9 @@ namespace Supernova {
         // Optional: Store the actual type name for editor UI/debugging
         std::string ptrTypeName; // e.g., "Mesh*", "Object*", "EntityHandle*"
 
+        // For cross-scene entity references (0 = same scene)
+        uint32_t sceneId = 0;
+
         // Helper template to get typed value
         template<typename T>
         T getValue() const {