Update from task 8f5f5615-9e0f-40cb-8b38-ecc911acf640

.gitignore

@@ -7,9 +7,6 @@
 *.so
 *.a
 *.out
-build/
-dist/
-target/
 
 # Dependencies
 node_modules/
@@ -18,26 +15,28 @@ venv/
 __pycache__/
 .mypy_cache/
 .pytest_cache/
+target/
 .gradle/
-julia-*/
-zig*/
 
-# Editors and IDEs
+# Logs and temp files
+*.log
+*.tmp
+*.swp
+
+# Editors
 .vscode/
 .idea/
-*.swp
-*.swo
-*.tmp
 
 # System files
 .DS_Store
 Thumbs.db
+
+# Environment
 .env
 .env.local
 *.env.*
 
-# Logs and coverage
-*.log
+# Coverage
 coverage/
 htmlcov/
 .coverage
@@ -61,8 +60,4 @@ htmlcov/
 *.Z
 *.lz
 *.lzo
-*.tar.gz
-*.tar.bz2
-*.tar.xz
-*.tar.zst
 ```

FarmEngine/assets/shaders/terrain.frag.glsl

@@ -13,6 +13,10 @@ layout(binding = 2) uniform sampler2D normalMap;
 layout(binding = 3) uniform sampler2D roughnessMap;
 layout(binding = 4) uniform sampler2D metalnessMap;
 
+layout(binding = 0) uniform CameraData {
+    vec3 cameraPosition;
+} cameraData;
+
 layout(binding = 5) uniform LightData {
     vec3 position;
     vec3 color;
@@ -45,7 +49,7 @@ void main() {
 
     // Lighting
     vec3 lightDir = normalize(position - fragPosition);
-    vec3 viewDir = normalize(cameraPosition - fragPosition);
+    vec3 viewDir = normalize(cameraData.cameraPosition - fragPosition);
     vec3 halfDir = normalize(lightDir + viewDir);
 
     // Diffuse (Lambert)

FarmEngine/core/Engine.h

@@ -7,6 +7,10 @@
 
 namespace farm {
 
+// Alias for FarmEngine namespace to maintain backward compatibility
+namespace EngineNS = FarmEngine;
+
+
 // Forward declarations
 class Window;
 class Renderer;

FarmEngine/core/ecs/ECS.cpp

@@ -31,8 +31,8 @@ void ECS::destroyEntity(EntityID entity) {
 
     // Limpiar componentes
     for (auto& componentList : components) {
-        if (componentList.second && entity < componentList.second->size()) {
-            (*componentList.second)[entity].reset();
+        if (entity < componentList.size()) {
+            componentList[entity].reset();
         }
     }
 

FarmEngine/core/ecs/ECS.h

@@ -56,8 +56,8 @@ class ECS {
 private:
     std::vector<Entity> entities;
     std::vector<EntityID> availableIDs;
-    std::unordered_map<std::type_index, std::vector<std::unique_ptr<Component>>> components;
-    std::unordered_map<std::type_index, EntityID> componentTypeToIndex;
+    std::vector<std::vector<std::unique_ptr<Component>>> components;
+    std::unordered_map<std::type_index, uint32_t> componentTypeToIndex;
 
     uint32_t nextComponentIndex = 0;
 
@@ -68,18 +68,18 @@ class ECS {
 // Template implementations
 template<typename T, typename... Args>
 T& ECS::addComponent(EntityID entity, Args&&... args) {
+    if (entity >= entities.size() || !entities[entity].active) {
+        throw std::out_of_range("Invalid or inactive entity ID");
+    }
+
     auto index = getComponentTypeIndex<T>();
 
     if (index >= components.size()) {
         components.resize(index + 1);
     }
 
-    if (!components[index]) {
-        components[index] = std::vector<std::unique_ptr<Component>>();
-    }
-
-    while (components[index]->size() <= entity) {
-        components[index]->push_back(nullptr);
+    while (components[index].size() <= entity) {
+        components[index].push_back(nullptr);
     }
 
     auto component = std::make_unique<T>(std::forward<Args>(args)...);
@@ -94,13 +94,17 @@ T& ECS::addComponent(EntityID entity, Args&&... args) {
 
 template<typename T>
 T* ECS::getComponent(EntityID entity) {
+    if (entity >= entities.size() || !entities[entity].active) {
+        return nullptr;
+    }
+
     auto index = getComponentTypeIndex<T>();
 
-    if (index >= components.size() || !components[index]) {
+    if (index >= components.size()) {
         return nullptr;
     }
 
-    if (entity >= components[index]->size()) {
+    if (entity >= components[index].size()) {
         return nullptr;
     }
 
@@ -109,19 +113,33 @@ T* ECS::getComponent(EntityID entity) {
 
 template<typename T>
 void ECS::removeComponent(EntityID entity) {
+    if (entity >= entities.size() || !entities[entity].active) {
+        return;
+    }
+
     auto index = getComponentTypeIndex<T>();
 
-    if (index < components.size() && components[index] && entity < components[index]->size()) {
+    if (index < components.size() && entity < components[index].size()) {
         components[index][entity].reset();
         entities[entity].mask.reset(index);
     }
 }
 
 template<typename T>
 uint32_t ECS::getComponentTypeIndex() {
-    static uint32_t index = []() {
-        return nextComponentIndex++;
-    }();
+    auto key = std::type_index(typeid(T));
+
+    auto it = componentTypeToIndex.find(key);
+    if (it != componentTypeToIndex.end()) {
+        return it->second;
+    }
+
+    if (nextComponentIndex >= MAX_COMPONENTS) {
+        throw std::overflow_error("Maximum number of component types exceeded");
+    }
+
+    uint32_t index = nextComponentIndex++;
+    componentTypeToIndex[key] = index;
     return index;
 }
 

FarmEngine/core/memory/MemoryManager.cpp

@@ -17,7 +17,7 @@ void* MemoryManager::allocate(size_t size, MemoryTag tag) {
     void* ptr = malloc(size);
 
     if (ptr) {
-        AllocationHeader header{size, tag, allocationCounter++};
+        AllocationHeader header{ptr, size, tag, allocationCounter++};
         allocations.push_back(header);
         totalAllocated += size;
     }
@@ -28,11 +28,10 @@ void* MemoryManager::allocate(size_t size, MemoryTag tag) {
 void MemoryManager::deallocate(void* ptr) {
     if (!ptr) return;
 
-    // Buscar y remover la asignación
+    // Buscar y remover la asignación por puntero
     auto it = std::find_if(allocations.begin(), allocations.end(),
         [ptr](const AllocationHeader& h) {
-            // En una implementación real, compararíamos punteros reales
-            return false; // Simplificado para este ejemplo
+            return h.ptr == ptr;
         });
 
     if (it != allocations.end()) {
@@ -50,21 +49,28 @@ void* MemoryManager::reallocate(void* ptr, size_t newSize) {
         return nullptr;
     }
 
+    // Find old allocation to get old size
+    size_t oldSize = 0;
+    auto it = std::find_if(allocations.begin(), allocations.end(),
+        [ptr](const AllocationHeader& h) {
+            return h.ptr == ptr;
+        });
+
+    if (it != allocations.end()) {
+        oldSize = it->size;
+    }
+
     void* newPtr = realloc(ptr, newSize);
     if (newPtr) {
-        // Find and update allocation header
-        auto it = std::find_if(allocations.begin(), allocations.end(),
-            [ptr, newPtr](const AllocationHeader& h) {
-                // In real implementation, compare actual pointers
-                return false; // Simplified for this example
-            });
-
         if (it != allocations.end()) {
+            // Update existing record
             totalAllocated -= it->size;
+            it->ptr = newPtr;
             it->size = newSize;
             totalAllocated += newSize;
         } else {
-            AllocationHeader header{newSize, MemoryTag::None, allocationCounter++};
+            // Create new record if old one wasn't found
+            AllocationHeader header{newPtr, newSize, MemoryTag::None, allocationCounter++};
             allocations.push_back(header);
             totalAllocated += newSize;
         }

FarmEngine/core/memory/MemoryManager.h

@@ -47,6 +47,7 @@ class MemoryManager {
     MemoryManager& operator=(const MemoryManager&) = delete;
 
     struct AllocationHeader {
+        void* ptr;
         size_t size;
         MemoryTag tag;
         uint32_t id;