Possibly faulty commit. Moving changes from laptop to pc

Author: Hugo-RM

CMakeLists.txt

@@ -60,6 +60,7 @@ set(SOURCES
 set(HEADERS
     include/RenderWindow.hpp
     include/Entity.hpp
+    include/SDLTexture.hpp
     include/Audio.hpp
     include/AudioLogic.hpp
     include/Font.hpp
@@ -152,6 +153,7 @@ set(GAME_LIB_SOURCES
 set(GAME_LIB_HEADERS
     include/RenderWindow.hpp
     include/Entity.hpp
+    include/SDLTexture.hpp
     include/Audio.hpp
     include/AudioLogic.hpp
     include/Font.hpp

include/Entity.hpp

@@ -1,10 +1,15 @@
 #pragma once
 #include <SDL.h>
 #include <SDL_image.h>
+#include "SDLTexture.hpp"
+#include <memory>
 
 class Entity
 {
 public:
+	// Constructor that takes shared ownership of texture
+	Entity(float x, float y, SharedSDLTexture texture);
+	// Constructor for raw SDL_Texture* (creates shared ownership)
 	Entity(float x, float y, SDL_Texture* texture);
 	inline float getX() const
 	{
@@ -14,28 +19,41 @@ class Entity
 	{
 		return y;
 	}
-	inline SDL_Texture *getTexture()
+	// Get raw texture pointer for SDL API calls
+	inline SDL_Texture* getTexture() const
 	{
-		return texture;
+		return texture_ ? texture_->get() : nullptr;
+	}
+	// Get shared texture for ownership transfer
+	inline SharedSDLTexture getSharedTexture() const
+	{
+		return texture_;
 	}
 	SDL_Rect getCurrentFrame();
 	void setCurrentFrameW(int w);
 	void setCurrentFrameH(int h);
+	// Set texture with shared ownership
+	inline void setTexture(SharedSDLTexture texture)
+	{
+		texture_ = texture;
+	}
+	// Set texture from raw pointer (creates shared ownership)
 	inline void setTexture(SDL_Texture* texture)
 	{
-		this->texture = texture;
+		texture_ = texture ? makeSharedSDLTexture(texture) : nullptr;
 	}
 protected:
-	inline void setX(int x)
+	// Fixed type consistency - use float to match member variables
+	inline void setX(float x)
 	{
 		this->x = x;
 	}
-	inline void setY(int y)
+	inline void setY(float y)
 	{
 		this->y = y;
 	}
 	float x;
 	float y;
 	SDL_Rect currentFrame;
-	SDL_Texture* texture;
+	SharedSDLTexture texture_;
 };

include/SDLTexture.hpp

@@ -0,0 +1,79 @@
+#pragma once
+#include <SDL.h>
+#include <memory>
+
+// RAII wrapper for SDL_Texture with proper ownership semantics
+class SDLTexture {
+public:
+    // Constructor that takes ownership of an SDL_Texture
+    explicit SDLTexture(SDL_Texture* texture = nullptr) : texture_(texture) {}
+    
+    // Destructor automatically cleans up the texture
+    ~SDLTexture() {
+        if (texture_) {
+            SDL_DestroyTexture(texture_);
+        }
+    }
+    
+    // Move constructor
+    SDLTexture(SDLTexture&& other) noexcept : texture_(other.texture_) {
+        other.texture_ = nullptr;
+    }
+    
+    // Move assignment operator
+    SDLTexture& operator=(SDLTexture&& other) noexcept {
+        if (this != &other) {
+            if (texture_) {
+                SDL_DestroyTexture(texture_);
+            }
+            texture_ = other.texture_;
+            other.texture_ = nullptr;
+        }
+        return *this;
+    }
+    
+    // Disable copy constructor and copy assignment (non-copyable resource)
+    SDLTexture(const SDLTexture&) = delete;
+    SDLTexture& operator=(const SDLTexture&) = delete;
+    
+    // Get raw pointer for SDL API calls
+    SDL_Texture* get() const noexcept { return texture_; }
+    
+    // Release ownership and return raw pointer
+    SDL_Texture* release() noexcept {
+        SDL_Texture* temp = texture_;
+        texture_ = nullptr;
+        return temp;
+    }
+    
+    // Reset with new texture (destroys current texture if it exists)
+    void reset(SDL_Texture* texture = nullptr) {
+        if (texture_) {
+            SDL_DestroyTexture(texture_);
+        }
+        texture_ = texture;
+    }
+    
+    // Check if texture is valid
+    explicit operator bool() const noexcept { return texture_ != nullptr; }
+    
+    // Get texture dimensions safely
+    bool getSize(int& width, int& height) const {
+        if (!texture_) {
+            width = height = 0;
+            return false;
+        }
+        return SDL_QueryTexture(texture_, nullptr, nullptr, &width, &height) == 0;
+    }
+
+private:
+    SDL_Texture* texture_;
+};
+
+// Type alias for shared ownership scenarios
+using SharedSDLTexture = std::shared_ptr<SDLTexture>;
+
+// Helper function to create shared SDL texture
+inline SharedSDLTexture makeSharedSDLTexture(SDL_Texture* texture) {
+    return std::make_shared<SDLTexture>(texture);
+}

src/Entity.cpp

@@ -1,17 +1,20 @@
 #include "Entity.hpp"
 
-Entity::Entity(float x, float y, SDL_Texture* texture) : x(x), y(y), texture(texture)
+// Constructor overload for raw SDL_Texture* (backward compatibility)
+Entity::Entity(float x, float y, SDL_Texture* texture) : Entity(x, y, texture ? makeSharedSDLTexture(texture) : nullptr) {
+}
+
+Entity::Entity(float x, float y, SharedSDLTexture texture) : x(x), y(y), texture_(texture)
 {
 	currentFrame.x = 0;
 	currentFrame.y = 0;
-	// Automatically detect texture size
-	if (texture != nullptr) {
-		int textureW, textureH;
-		SDL_QueryTexture(texture, NULL, NULL, &textureW, &textureH);
+	// Automatically detect texture size with error checking
+	int textureW, textureH;
+	if (texture_ && texture_->getSize(textureW, textureH)) {
 		currentFrame.w = textureW;
 		currentFrame.h = textureH;
 	} else {
-		// Default size for null textures
+		// Default size for null or invalid textures
 		currentFrame.w = 0;
 		currentFrame.h = 0;
 	}