chore: code code tidy and style tweaks

imgui.ini

@@ -26,8 +26,8 @@ Size=227,63
 Collapsed=0
 
 [Window][##TOAST1]
-Pos=1035,564
-Size=225,63
+Pos=956,564
+Size=304,63
 Collapsed=0
 
 [Window][##TOAST2]

scripts/game.as

@@ -2,15 +2,15 @@
 // This demonstrates creating entities with various components and managing rendering
 
 // Resource IDs
-uint g_toonShader = 0;
-uint g_outlineShader = 0;
-uint g_cubeModel = 0;
-uint g_sphereModel = 0;
-uint g_defaultMaterial = 0;
+uint toonShader = 0;
+uint outlineShader = 0;
+uint cubeModel = 0;
+uint sphereModel = 0;
+uint defaultMaterial = 0;
 
 // Scene entities
-uint g_camera = 0;
-uint g_light = 0;
+uint camera = 0;
+uint light = 0;
 
 // Store entity IDs for manipulation
 array<uint> entities;
@@ -23,45 +23,45 @@ void Init() {
     Toast::Success("ECS Script initialized successfully!");
     
     // === Load shaders ===
-    g_toonShader = Shader::Load("shaders/toon.vs", "shaders/toon.fs");
-    g_outlineShader = Shader::Load("shaders/outline.vs", "shaders/outline.fs");
+    toonShader = Shader::Load("shaders/toon.vs", "shaders/toon.fs");
+    outlineShader = Shader::Load("shaders/outline.vs", "shaders/outline.fs");
     
-    if (g_toonShader == 0 || g_outlineShader == 0) {
+    if (toonShader == 0 || outlineShader == 0) {
         Toast::Error("Failed to load shaders!");
         return;
     }
     
     // === Load models ===
-    g_cubeModel = Model::LoadCube(1.0, 1.0, 1.0);
-    g_sphereModel = Model::LoadSphere(0.5, 16, 16);
+    cubeModel = Model::LoadCube(1.0, 1.0, 1.0);
+    sphereModel = Model::LoadSphere(0.5, 16, 16);
     
     // === Create default material ===
-    g_defaultMaterial = Material::Create(g_toonShader, 255, 255, 255, 255);
+    defaultMaterial = Material::Create(toonShader, 255, 255, 255, 255);
     
     // === Set up camera ===
-    g_camera = ECS::CreateEntity();
-    ECS::AddCamera3D(g_camera, 
-        5.0, 5.0, 5.0,  // position
-        0.0, 0.0, 0.0,   // target
-        45.0);           // fovy
-    ECS::AddTag(g_camera, "MainCamera");
+    camera = ECS::CreateEntity();
+    ECS::AddCamera3D(camera, 
+        5.0, 5.0, 5.0, // position
+        0.0, 0.0, 0.0, // target
+        45.0); // fovy
+    ECS::AddTag(camera, "MainCamera");
     
     // === Set up light ===
-    g_light = ECS::CreateEntity();
-    ECS::AddLight(g_light, 0.5, 0.7, 0.3, 1.0); // direction + intensity
-    ECS::AddTag(g_light, "MainLight");
+    light = ECS::CreateEntity();
+    ECS::AddLight(light, 0.5, 0.7, 0.3, 1.0); // direction + intensity
+    ECS::AddTag(light, "MainLight");
     
     // === Create player entity at origin with outline ===
     player = ECS::CreateEntity();
     ECS::AddTransform(player, 0.0f, 0.0f, 0.0f);
-    ECS::AddSprite(player, g_sphereModel, 0xFF0000FF, 0.0f);  // Red sphere
+    ECS::AddSprite(player, sphereModel, 0xFF0000FF, 0.0f); // Red sphere
     
     // Create material for player
-    uint playerMat = Material::Create(g_toonShader, 255, 0, 0, 255);
+    uint playerMat = Material::Create(toonShader, 255, 0, 0, 255);
     ECS::AddMaterial(player, playerMat);
     
     // Add outline pass (order=0) and main pass (order=1)
-    ECS::AddRenderPass(player, 0, false, true, g_outlineShader);
+    ECS::AddRenderPass(player, 0, false, true, outlineShader);
     
     ECS::AddTag(player, "Player");
     Log(LOG_INFO, "Created player entity: " + player);
@@ -69,10 +69,10 @@ void Init() {
     // === Create a spinning cube ===
     spinningCube = ECS::CreateEntity();
     ECS::AddTransform(spinningCube, 2.0f, 0.0f, 0.0f);
-    ECS::AddSprite(spinningCube, g_cubeModel, 0x00FF00FF, 0.0f);  // Green cube
-    ECS::AddVelocity(spinningCube, 0.0f, 0.0f, 0.0f, 2.0f);  // Angular velocity
+    ECS::AddSprite(spinningCube, cubeModel, 0x00FF00FF, 0.0f); // Green cube
+    ECS::AddVelocity(spinningCube, 0.0f, 0.0f, 0.0f, 2.0f); // Angular velocity
     
-    uint greenMat = Material::Create(g_toonShader, 0, 255, 0, 255);
+    uint greenMat = Material::Create(toonShader, 0, 255, 0, 255);
     ECS::AddMaterial(spinningCube, greenMat);
     ECS::AddRenderPass(spinningCube, 1, true, true, 0); // Main pass
     
@@ -83,7 +83,7 @@ void Init() {
     for (int i = 0; i < 5; i++) {
         uint entity = ECS::CreateEntity();
         
-        float angle = (float(i) / 5.0f) * 6.28318f;  // 2*PI
+        float angle = (float(i) / 5.0f) * 6.28318f; // 2*PI
         float radius = 3.0f;
         float x = Math::Cos(angle) * radius;
         float z = Math::Sin(angle) * radius;
@@ -93,15 +93,11 @@ void Init() {
         // Different colors for each
         uint color = 0;
         uint8 r = 255, g = 255, b = 255;
-        if (i == 0) { color = 0xFFFF00FF; r = 255; g = 255; b = 0; }      // Yellow
-        else if (i == 1) { color = 0xFF00FFFF; r = 255; g = 0; b = 255; } // Magenta
-        else if (i == 2) { color = 0x00FFFFFF; r = 0; g = 255; b = 255; } // Cyan
-        else if (i == 3) { color = 0xFFA500FF; r = 255; g = 165; b = 0; } // Orange
-        else { color = 0xFF69B4FF; r = 255; g = 105; b = 180; }           // Pink
+        if (i == 0) { color = 0xFFFF00FF; r = 255; g = 255; b = 0; } // Yellow else if (i == 1) { color = 0xFF00FFFF; r = 255; g = 0; b = 255; } // Magenta else if (i == 2) { color = 0x00FFFFFF; r = 0; g = 255; b = 255; } // Cyan else if (i == 3) { color = 0xFFA500FF; r = 255; g = 165; b = 0; } // Orange else { color = 0xFF69B4FF; r = 255; g = 105; b = 180; } // Pink
         
-        ECS::AddSprite(entity, g_sphereModel, color, 0.0f);
+        ECS::AddSprite(entity, sphereModel, color, 0.0f);
         
-        uint mat = Material::Create(g_toonShader, r, g, b, 255);
+        uint mat = Material::Create(toonShader, r, g, b, 255);
         ECS::AddMaterial(entity, mat);
         ECS::AddRenderPass(entity, 1, true, true, 0);
         
@@ -112,10 +108,10 @@ void Init() {
     // === Create a moving entity ===
     uint mover = ECS::CreateEntity();
     ECS::AddTransform(mover, -3.0f, 0.5f, 0.0f);
-    ECS::AddSprite(mover, g_cubeModel, 0xFFFFFFFF, 0.0f);  // White cube
-    ECS::AddVelocity(mover, 1.0f, 0.0f, 0.5f, 0.0f);  // Moving velocity
+    ECS::AddSprite(mover, cubeModel, 0xFFFFFFFF, 0.0f); // White cube
+    ECS::AddVelocity(mover, 1.0f, 0.0f, 0.5f, 0.0f); // Moving velocity
     
-    ECS::AddMaterial(mover, g_defaultMaterial);
+    ECS::AddMaterial(mover, defaultMaterial);
     ECS::AddRenderPass(mover, 1, true, true, 0);
     
     ECS::AddTag(mover, "Mover");
@@ -132,12 +128,12 @@ void Update(float dt) {
     time += dt;
     
     // Update camera to orbit around the scene
-    if (ECS::HasCamera3D(g_camera)) {
+    if (ECS::HasCamera3D(camera)) {
         float angle = time * 0.3;
         float radius = 7.0;
         float x = Math::Cos(angle) * radius;
         float z = Math::Sin(angle) * radius;
-        ECS::SetCameraPosition(g_camera, x, 5.0, z);
+        ECS::SetCameraPosition(camera, x, 5.0, z);
     }
     
     // Update player position - simple back and forth motion
@@ -153,7 +149,7 @@ void Update(float dt) {
         float radius = 3.0f;
         float x = Math::Cos(angle) * radius;
         float z = Math::Sin(angle) * radius;
-        float y = Math::Sin(time * 2.0f + float(i)) * 0.5f;  // Bobbing motion
+        float y = Math::Sin(time * 2.0f + float(i)) * 0.5f; // Bobbing motion
         
         ECS::SetPosition(entity, x, y, z);
         ECS::SetRotation(entity, time + float(i));

src/Application.cpp

@@ -277,14 +277,6 @@ void Application::RenderScene()
                     desiredShaderId = matData->shaderId;
                 }
                 
-                // Debug: Log first frame only
-                static bool logged = false;
-                if (!logged && matComp->materialId <= 3) {
-                    log_info("Entity material=%u, shader=%u, albedo=(%d,%d,%d,%d)", 
-                             matComp->materialId, matData->shaderId, 
-                             albedo.r, albedo.g, albedo.b, albedo.a);
-                    if (matComp->materialId == 3) logged = true;
-                }
             }
         }
         

src/scripting/ECSBindings.cpp

@@ -5,47 +5,47 @@
 #include <string>
 
 // Global registry pointer for script access
-static entt::registry* g_registry = nullptr;
+static entt::registry* registry = nullptr;
 
 void SetGlobalRegistry(entt::registry* reg) {
-    g_registry = reg;
+    registry = reg;
 }
 
 // === Entity Management ===
 
 uint32_t AS_CreateEntity() {
-    if (!g_registry) return 0;
-    return (uint32_t)g_registry->create();
+    if (!registry) return 0;
+    return (uint32_t)registry->create();
 }
 
 void AS_DestroyEntity(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->destroy((entt::entity)entity);
+    if (!registry) return;
+    registry->destroy((entt::entity)entity);
 }
 
 bool AS_IsEntityValid(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->valid((entt::entity)entity);
+    if (!registry) return false;
+    return registry->valid((entt::entity)entity);
 }
 
 // === Transform Component ===
 
 void AS_AddTransform(uint32_t entity, float x, float y, float z) {
-    if (!g_registry) return;
-    g_registry->emplace<ECSTransform>((entt::entity)entity, 
+    if (!registry) return;
+    registry->emplace<ECSTransform>((entt::entity)entity, 
         Vector3{x, y, z}, Vector3{1.0f, 1.0f, 1.0f}, 0.0f);
 }
 
 void AS_SetPosition(uint32_t entity, float x, float y, float z) {
-    if (!g_registry) return;
-    if (auto* t = g_registry->try_get<ECSTransform>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* t = registry->try_get<ECSTransform>((entt::entity)entity)) {
         t->position = {x, y, z};
     }
 }
 
 void AS_GetPosition(uint32_t entity, float* x, float* y, float* z) {
-    if (!g_registry || !x || !y || !z) return;
-    if (auto* t = g_registry->try_get<ECSTransform>((entt::entity)entity)) {
+    if (!registry || !x || !y || !z) return;
+    if (auto* t = registry->try_get<ECSTransform>((entt::entity)entity)) {
         *x = t->position.x;
         *y = t->position.y;
         *z = t->position.z;
@@ -53,83 +53,83 @@ void AS_GetPosition(uint32_t entity, float* x, float* y, float* z) {
 }
 
 void AS_SetScale(uint32_t entity, float x, float y, float z) {
-    if (!g_registry) return;
-    if (auto* t = g_registry->try_get<ECSTransform>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* t = registry->try_get<ECSTransform>((entt::entity)entity)) {
         t->scale = {x, y, z};
     }
 }
 
 void AS_SetRotation(uint32_t entity, float rotation) {
-    if (!g_registry) return;
-    if (auto* t = g_registry->try_get<ECSTransform>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* t = registry->try_get<ECSTransform>((entt::entity)entity)) {
         t->rotation = rotation;
     }
 }
 
 float AS_GetRotation(uint32_t entity) {
-    if (!g_registry) return 0.0f;
-    if (auto* t = g_registry->try_get<ECSTransform>((entt::entity)entity)) {
+    if (!registry) return 0.0f;
+    if (auto* t = registry->try_get<ECSTransform>((entt::entity)entity)) {
         return t->rotation;
     }
     return 0.0f;
 }
 
 bool AS_HasTransform(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->all_of<ECSTransform>((entt::entity)entity);
+    if (!registry) return false;
+    return registry->all_of<ECSTransform>((entt::entity)entity);
 }
 
 void AS_RemoveTransform(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->remove<ECSTransform>((entt::entity)entity);
+    if (!registry) return;
+    registry->remove<ECSTransform>((entt::entity)entity);
 }
 
 // === Velocity Component ===
 
 void AS_AddVelocity(uint32_t entity, float vx, float vy, float vz, float angular) {
-    if (!g_registry) return;
-    g_registry->emplace<Velocity>((entt::entity)entity, Vector3{vx, vy, vz}, angular);
+    if (!registry) return;
+    registry->emplace<Velocity>((entt::entity)entity, Vector3{vx, vy, vz}, angular);
 }
 
 void AS_SetVelocity(uint32_t entity, float vx, float vy, float vz) {
-    if (!g_registry) return;
-    if (auto* v = g_registry->try_get<Velocity>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* v = registry->try_get<Velocity>((entt::entity)entity)) {
         v->linear = {vx, vy, vz};
     }
 }
 
 void AS_SetAngularVelocity(uint32_t entity, float angular) {
-    if (!g_registry) return;
-    if (auto* v = g_registry->try_get<Velocity>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* v = registry->try_get<Velocity>((entt::entity)entity)) {
         v->angular = angular;
     }
 }
 
 bool AS_HasVelocity(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->all_of<Velocity>((entt::entity)entity);
+    if (!registry) return false;
+    return registry->all_of<Velocity>((entt::entity)entity);
 }
 
 void AS_RemoveVelocity(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->remove<Velocity>((entt::entity)entity);
+    if (!registry) return;
+    registry->remove<Velocity>((entt::entity)entity);
 }
 
 // === Sprite Component ===
 
 void AS_AddSprite(uint32_t entity, int modelId, uint32_t color, float outlineSize) {
-    if (!g_registry) return;
+    if (!registry) return;
     Color col;
     col.r = (color >> 24) & 0xFF;
     col.g = (color >> 16) & 0xFF;
     col.b = (color >> 8) & 0xFF;
     col.a = color & 0xFF;
-    g_registry->emplace<Sprite>((entt::entity)entity, modelId, col, outlineSize);
+    registry->emplace<Sprite>((entt::entity)entity, modelId, col, outlineSize);
 }
 
 void AS_SetSpriteColor(uint32_t entity, uint32_t color) {
-    if (!g_registry) return;
-    if (auto* s = g_registry->try_get<Sprite>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* s = registry->try_get<Sprite>((entt::entity)entity)) {
         s->color.r = (color >> 24) & 0xFF;
         s->color.g = (color >> 16) & 0xFF;
         s->color.b = (color >> 8) & 0xFF;
@@ -138,133 +138,133 @@ void AS_SetSpriteColor(uint32_t entity, uint32_t color) {
 }
 
 void AS_SetSpriteModel(uint32_t entity, int modelId) {
-    if (!g_registry) return;
-    if (auto* s = g_registry->try_get<Sprite>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* s = registry->try_get<Sprite>((entt::entity)entity)) {
         s->modelId = modelId;
     }
 }
 
 void AS_SetSpriteOutline(uint32_t entity, float outlineSize) {
-    if (!g_registry) return;
-    if (auto* s = g_registry->try_get<Sprite>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* s = registry->try_get<Sprite>((entt::entity)entity)) {
         s->outlineSize = outlineSize;
     }
 }
 
 bool AS_HasSprite(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->all_of<Sprite>((entt::entity)entity);
+    if (!registry) return false;
+    return registry->all_of<Sprite>((entt::entity)entity);
 }
 
 void AS_RemoveSprite(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->remove<Sprite>((entt::entity)entity);
+    if (!registry) return;
+    registry->remove<Sprite>((entt::entity)entity);
 }
 
 // === Tag Component ===
 
 void AS_AddTag(uint32_t entity, const std::string& name) {
-    if (!g_registry) return;
-    g_registry->emplace<Tag>((entt::entity)entity, name);
+    if (!registry) return;
+    registry->emplace<Tag>((entt::entity)entity, name);
 }
 
 std::string AS_GetTag(uint32_t entity) {
-    if (!g_registry) return "";
-    if (auto* t = g_registry->try_get<Tag>((entt::entity)entity)) {
+    if (!registry) return "";
+    if (auto* t = registry->try_get<Tag>((entt::entity)entity)) {
         return t->name;
     }
     return "";
 }
 
 void AS_SetTag(uint32_t entity, const std::string& name) {
-    if (!g_registry) return;
-    if (auto* t = g_registry->try_get<Tag>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* t = registry->try_get<Tag>((entt::entity)entity)) {
         t->name = name;
     }
 }
 
 bool AS_HasTag(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->all_of<Tag>((entt::entity)entity);
+    if (!registry) return false;
+    return registry->all_of<Tag>((entt::entity)entity);
 }
 
 void AS_RemoveTag(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->remove<Tag>((entt::entity)entity);
+    if (!registry) return;
+    registry->remove<Tag>((entt::entity)entity);
 }
 
 // === Camera3D Component ===
 
 void AS_AddCamera3D(uint32_t entity, float px, float py, float pz, float tx, float ty, float tz, float fovy) {
-    if (!g_registry) return;
+    if (!registry) return;
     Camera3DComponent cam;
     cam.position = {px, py, pz};
     cam.target = {tx, ty, tz};
     cam.up = {0.0f, 1.0f, 0.0f};
     cam.fovy = fovy;
     cam.projection = 0; // CAMERA_PERSPECTIVE
-    g_registry->emplace<Camera3DComponent>((entt::entity)entity, cam);
+    registry->emplace<Camera3DComponent>((entt::entity)entity, cam);
 }
 
 void AS_SetCameraPosition(uint32_t entity, float x, float y, float z) {
-    if (!g_registry) return;
-    if (auto* c = g_registry->try_get<Camera3DComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* c = registry->try_get<Camera3DComponent>((entt::entity)entity)) {
         c->position = {x, y, z};
     }
 }
 
 void AS_SetCameraTarget(uint32_t entity, float x, float y, float z) {
-    if (!g_registry) return;
-    if (auto* c = g_registry->try_get<Camera3DComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* c = registry->try_get<Camera3DComponent>((entt::entity)entity)) {
         c->target = {x, y, z};
     }
 }
 
 void AS_SetCameraFovy(uint32_t entity, float fovy) {
-    if (!g_registry) return;
-    if (auto* c = g_registry->try_get<Camera3DComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* c = registry->try_get<Camera3DComponent>((entt::entity)entity)) {
         c->fovy = fovy;
     }
 }
 
 bool AS_HasCamera3D(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->all_of<Camera3DComponent>((entt::entity)entity);
+    if (!registry) return false;
+    return registry->all_of<Camera3DComponent>((entt::entity)entity);
 }
 
 void AS_RemoveCamera3D(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->remove<Camera3DComponent>((entt::entity)entity);
+    if (!registry) return;
+    registry->remove<Camera3DComponent>((entt::entity)entity);
 }
 
 // === Light Component ===
 
 void AS_AddLight(uint32_t entity, float dx, float dy, float dz, float intensity) {
-    if (!g_registry) return;
+    if (!registry) return;
     LightComponent light;
     light.direction = {dx, dy, dz};
     light.color = WHITE;
     light.intensity = intensity;
-    g_registry->emplace<LightComponent>((entt::entity)entity, light);
+    registry->emplace<LightComponent>((entt::entity)entity, light);
 }
 
 void AS_SetLightDirection(uint32_t entity, float x, float y, float z) {
-    if (!g_registry) return;
-    if (auto* l = g_registry->try_get<LightComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* l = registry->try_get<LightComponent>((entt::entity)entity)) {
         l->direction = {x, y, z};
     }
 }
 
 void AS_SetLightIntensity(uint32_t entity, float intensity) {
-    if (!g_registry) return;
-    if (auto* l = g_registry->try_get<LightComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* l = registry->try_get<LightComponent>((entt::entity)entity)) {
         l->intensity = intensity;
     }
 }
 
 void AS_SetLightColor(uint32_t entity, uint32_t color) {
-    if (!g_registry) return;
-    if (auto* l = g_registry->try_get<LightComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* l = registry->try_get<LightComponent>((entt::entity)entity)) {
         l->color.r = (color >> 24) & 0xFF;
         l->color.g = (color >> 16) & 0xFF;
         l->color.b = (color >> 8) & 0xFF;
@@ -273,81 +273,81 @@ void AS_SetLightColor(uint32_t entity, uint32_t color) {
 }
 
 bool AS_HasLight(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->all_of<LightComponent>((entt::entity)entity);
+    if (!registry) return false;
+    return registry->all_of<LightComponent>((entt::entity)entity);
 }
 
 void AS_RemoveLight(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->remove<LightComponent>((entt::entity)entity);
+    if (!registry) return;
+    registry->remove<LightComponent>((entt::entity)entity);
 }
 
 // === Material Component ===
 
 void AS_AddMaterial(uint32_t entity, unsigned int materialId) {
-    if (!g_registry) return;
-    g_registry->emplace<MaterialComponent>((entt::entity)entity, materialId);
+    if (!registry) return;
+    registry->emplace<MaterialComponent>((entt::entity)entity, materialId);
 }
 
 void AS_SetMaterialId(uint32_t entity, unsigned int materialId) {
-    if (!g_registry) return;
-    if (auto* m = g_registry->try_get<MaterialComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* m = registry->try_get<MaterialComponent>((entt::entity)entity)) {
         m->materialId = materialId;
     }
 }
 
 unsigned int AS_GetMaterialId(uint32_t entity) {
-    if (!g_registry) return 0;
-    if (auto* m = g_registry->try_get<MaterialComponent>((entt::entity)entity)) {
+    if (!registry) return 0;
+    if (auto* m = registry->try_get<MaterialComponent>((entt::entity)entity)) {
         return m->materialId;
     }
     return 0;
 }
 
 bool AS_HasMaterial(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->all_of<MaterialComponent>((entt::entity)entity);
+    if (!registry) return false;
+    return registry->all_of<MaterialComponent>((entt::entity)entity);
 }
 
 void AS_RemoveMaterialComponent(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->remove<MaterialComponent>((entt::entity)entity);
+    if (!registry) return;
+    registry->remove<MaterialComponent>((entt::entity)entity);
 }
 
 // === RenderPass Component ===
 
 void AS_AddRenderPass(uint32_t entity, int order, bool depthTest, bool depthWrite, unsigned int shaderId) {
-    if (!g_registry) return;
+    if (!registry) return;
     RenderPassComponent pass;
     pass.order = order;
     pass.depthTest = depthTest;
     pass.depthWrite = depthWrite;
     pass.shaderId = shaderId;
-    g_registry->emplace<RenderPassComponent>((entt::entity)entity, pass);
+    registry->emplace<RenderPassComponent>((entt::entity)entity, pass);
 }
 
 void AS_SetRenderPassOrder(uint32_t entity, int order) {
-    if (!g_registry) return;
-    if (auto* p = g_registry->try_get<RenderPassComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* p = registry->try_get<RenderPassComponent>((entt::entity)entity)) {
         p->order = order;
     }
 }
 
 void AS_SetRenderPassShader(uint32_t entity, unsigned int shaderId) {
-    if (!g_registry) return;
-    if (auto* p = g_registry->try_get<RenderPassComponent>((entt::entity)entity)) {
+    if (!registry) return;
+    if (auto* p = registry->try_get<RenderPassComponent>((entt::entity)entity)) {
         p->shaderId = shaderId;
     }
 }
 
 bool AS_HasRenderPass(uint32_t entity) {
-    if (!g_registry) return false;
-    return g_registry->all_of<RenderPassComponent>((entt::entity)entity);
+    if (!registry) return false;
+    return registry->all_of<RenderPassComponent>((entt::entity)entity);
 }
 
 void AS_RemoveRenderPass(uint32_t entity) {
-    if (!g_registry) return;
-    g_registry->remove<RenderPassComponent>((entt::entity)entity);
+    if (!registry) return;
+    registry->remove<RenderPassComponent>((entt::entity)entity);
 }
 
 // === Registration ===

src/scripting/ToastBindings.cpp

@@ -2,25 +2,30 @@
 #include "gui/Toast.h"
 #include <angelscript.h>
 #include <assert.h>
-
+#include <string>
+#include "../log/log.h"
 // Toast binding functions
 static void AS_ToastInfo(const std::string& message)
 {
+    log_info("%s", message.c_str());
     Toast::Info(message);
 }
 
 static void AS_ToastWarning(const std::string& message)
 {
+    log_warn("%s", message.c_str());
     Toast::Warning(message);
 }
 
 static void AS_ToastError(const std::string& message)
 {
+    log_error("%s", message.c_str());
     Toast::Error(message);
 }
 
 static void AS_ToastSuccess(const std::string& message)
 {
+    log_info("%s", message.c_str());
     Toast::Success(message);
 }