SDL Texture not rendering after use of copy constructor - c++

Question

I'm making a basic program using SDL to render graphics. I have two classes that deal with Rendering:
A Texture class (that loads and renders the SDL_textures)
//Texture warpper class
class LTexture
{
private:
//The actual texture
SDL_Texture* mTexture;
//Image demensions
int mWidth;
int mHeight;
public:
//Initializes/Deallocates variables
LTexture();
~LTexture();
LTexture(const LTexture &rhs);
//Loads image at specified path
bool loadFromFile(std::string path);
//Deallocates texture
void free();
//Renders texture at given point
void render(int x, int y);
//Gets image dimensions
int getWidth();
int getHeight();
};
LTexture::LTexture()
{
//Initialize
mTexture = NULL;
mWidth = 0;
mHeight = 0;
}
LTexture::~LTexture()
{
//Deallocate
free();
}
LTexture::LTexture(const LTexture &rhs)
{
mTexture = rhs.mTexture;
mWidth = rhs.mWidth;
mHeight = rhs.mHeight;
}
bool LTexture::loadFromFile(std::string path)
{
//Get rid of preexisting texture
free();
//The final texture
SDL_Texture* newTexture = NULL;
//Load image at specified path
SDL_Surface* loadedSurface = IMG_Load(path.c_str());
if (loadedSurface == NULL)
{
printf("Unable to load image %s! SDL_image error: %s\n", path.c_str(), IMG_GetError());
}
else
{
//Create texture from surface pixels
newTexture = SDL_CreateTextureFromSurface(gRenderer, loadedSurface);
if (newTexture == NULL)
{
printf("Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError());
}
else
{
//Get image dimensions
mWidth = loadedSurface->w;
mHeight = loadedSurface->h;
}
//Get rid of old loaded surface
SDL_FreeSurface(loadedSurface);
}
//Return success
mTexture = newTexture;
return mTexture != NULL;
}
void LTexture::free()
{
//Free Texture if it exists
if (mTexture != NULL)
{
SDL_DestroyTexture(mTexture);
mTexture = NULL;
mWidth = 0;
mHeight = 0;
}
}
void LTexture::render(int x, int y)
{
//Set rendering space and render to screen
SDL_Rect renderQuad = { x, y, mWidth, mHeight };
SDL_RenderCopy(gRenderer, mTexture, NULL, &renderQuad);
printf("Rendering...\n");
if (mTexture == NULL)
{
printf("No texture loaded!\n");
}
else
{
printf("Texture loaded! %s\n", mTexture);
}
}
int LTexture::getWidth()
{
return mWidth;
}
int LTexture::getHeight()
{
return mHeight;
}
And a Button class(That is supposed to make it easier to switch between the different textures associated with the states of the buttons. Each object is supposed to have 3 texture objects within the button).
Declaration:
//Class for buttons and chips
class Button
{
public:
//Initializes internal variables
Button();
//Handles mouse events
void handleEvent(SDL_Event* e);
//Render buttons
void render();
//Sets top left position
void setPosition(int x, int y);
//Gets image dimensions
void setWidth(int w);
void setHeight(int h);
//Set button status
void setButtonAction(buttonAction action);
//Get button status
buttonStatus getButtonStatus();
//Perform button action !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!FIXME::HAVEN'T DEFINED!!!!!!!!!!!!!!!!!!!!!!!!!!!!1!!
void activateButton(buttonAction action);
void setTextures(LTexture out, LTexture over, LTexture down);
private:
//Top left position
SDL_Point mPosition;
//Currently used global image
buttonStatus mButtonStatus;
//What happens if button is pressed
buttonAction mButtonAction;
//Width and height
int mWidth;
int mHeight;
//Textures
LTexture mOut;
LTexture mOver;
LTexture mDown;
};
Button::Button()
{
mPosition.x = 0;
mPosition.y = 0;
mWidth = 0;
mHeight = 0;
mButtonStatus = MOUSE_OUT;
}
void Button::setPosition(int x, int y)
{
mPosition.x = x;
mPosition.y = y;
}
void Button::handleEvent(SDL_Event* e)
{
bool mInside = true;
//If mouse event happened
if (e->type == SDL_MOUSEBUTTONDOWN || e->type == SDL_MOUSEMOTION)
{
//Get mouse position
int x, y;
SDL_GetMouseState(&x, &y);
//Mouse is left of the button
if (x < mPosition.x)
{
mInside = false;
}
//Mouse is right of button
else if (x > mPosition.x + mWidth)
{
mInside = false;
}
//Mouse is above button
else if (y < mPosition.y)
{
mInside = false;
}
//Mouse is below button
else if (y > mPosition.y + mHeight)
{
mInside = false;
}
//Logic\\
//Mouse is outside of button
if (!mInside)
{
mButtonStatus = MOUSE_OUT;
}
//Mouse is inside of button
else
{
switch (e->type)
{
case SDL_MOUSEMOTION:
mButtonStatus = MOUSE_OVER;
break;
case SDL_MOUSEBUTTONDOWN:
mButtonStatus = MOUSE_BUTTON_DOWN;
break;
}
}
}
}
void Button::render()
{
switch (mButtonStatus)
{
case MOUSE_OUT:
mOut.render(mPosition.x, mPosition.y);
printf("Out rendered\n");
break;
case MOUSE_OVER:
mOver.render(mPosition.x, mPosition.y);
printf("Over rendered\n");
break;
case MOUSE_BUTTON_DOWN:
mDown.render(mPosition.x, mPosition.y);
printf("Down rendered\n");
break;
}
}
void Button::setWidth(int w)
{
mWidth = w;
}
void Button::setHeight(int h)
{
mHeight = h;
}
void Button::setButtonAction(buttonAction action)
{
mButtonAction = action;
}
buttonStatus Button::getButtonStatus()
{
return mButtonStatus;
}
void Button::setTextures(LTexture out, LTexture over, LTexture down)
{
mOut = out;
mOver = over;
mDown = down;
}
Unfortunately, when I try to use a copy constructor to pass the SDL_Texture value from the original Texture to the buttons Private texture, it doesn't pass any value, but still thinks that it's not "NULL"

Answer 1

There's two problems with this code that I can see.
The first is that in the LTexture copy constructor, you only copy the pointer to the SDL_Texture. This is called a shallow copy. Then, in the destructor of LTexture, you call free(), which deletes the SDL_Texture. This is bad, because it means that any duplicates of the LTexture now have pointers to textures that have been deleted, so they will no longer work. The best two solutions here are either to use a c++11 class called shared_ptr to store the texture, which will prevent it from being deleted, or actually make a copy of the texture and point to the new one (a deep copy). For testing, you could try just commenting out the call to SDL_DestroyTexture in free().
Additionally, you forgot to implement the assignment operator. Currently it behaves just like the copy constructor (since all you do is a shallow copy), but if you make it a deep copy, you'll have to implement that as well.