C++ & SDL Texture wont load, but SDL_GetError() doesn't return anything

Question

I was playing around in SDL2 when I discovered something really strange. I'm trying to draw an optimized texture, but it won't work. The code which turns a surface to a texture doesn't work. According to the documentation, SDL_GetError() should give me the error, but it doesn't return anything... Any help would be appreciated! Here's the code:

Main.cpp:

#include "SDLHelper.h"
#include "Player.h"

#define WIDTH 640
#define HEIGHT 480
#define NAME "TILES BOI!"

int main(int args, char* argv[]){
    SDL_Window* gWindow;
    SDL_Renderer* gRenderer;
    if(!init(NAME, WIDTH, HEIGHT, &gWindow, &gRenderer)){
        printf("Failed to initialize!\n");
    }else{
            bool quit = false;
            SDL_Event e;
            Player* player = new Player(100, 100, 0, 0);
            player->texture = loadTexture("sprites/people/male_walkcycle.png", &gRenderer);
        while(!quit){
            while(SDL_PollEvent(&e) != 0){
                if(e.type == SDL_QUIT){
                        quit = true;
                }
            }

            SDL_RenderClear(gRenderer);

            SDL_RenderCopy(gRenderer, player->texture, &(player->currentTexturePos), &(player->position));

            SDL_RenderPresent(gRenderer);
        }
        close(&gWindow, &gRenderer);
    }

    return 0;
}

SDLHelper.h:

 #ifndef SDLHELPER_H
  #define SDLHELPER_H

  #include <SDL2/SDL.h>
  #include <SDL2/SDL_image.h>
  #include <stdio.h>

  bool init(const char* name, int width, int height, SDL_Window** window, SDL_Renderer** renderer);
  SDL_Texture* loadTexture(const char* path, SDL_Renderer** renderer);
    void close(SDL_Window** gWindow, SDL_Renderer** gRenderer);

    #endif

SDLHelper.cpp:

#include "SDLHelper.h"

bool init(const char* name, int width, int height, SDL_Window** window, SDL_Renderer** renderer){
    bool success = true;
    if(SDL_Init(SDL_INIT_EVERYTHING) < 0){
        printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
        success = false;
    }else{
        if(!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")){
            printf("Warning: Linear texture filtering is not enabled!\n");
        }

        *window = SDL_CreateWindow(name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, SDL_WINDOW_SHOWN);
        if(*window == NULL){
            printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
            success = false;
        }else{
            *renderer = SDL_CreateRenderer(*window, -1, SDL_RENDERER_ACCELERATED);
            if(*renderer == NULL){
                printf("Renderer could not be created! SDL Error: %s\n", SDL_GetError());
                success = false;
            }else{
                SDL_SetRenderDrawColor(*renderer, 0xFF, 0xFF, 0xFF, 0xFF);
                int imgFlags = IMG_INIT_PNG;
                if(!(IMG_Init(imgFlags) & imgFlags)){
                    printf("SDL_Image could not initialize! SDL_Image Error: %s\n",IMG_GetError());
                    success = false;
                }
            }
        }
    }
    return success;
}

SDL_Texture* loadTexture(const char* path, SDL_Renderer** renderer){
    SDL_Texture* newTexture = NULL;
    SDL_Surface* loaded = IMG_Load(path);
    if(loaded == NULL){
        printf("Unable to load image %s! SDL_Image Error: %s\n", path, IMG_GetError());
    }else{
        newTexture == SDL_CreateTextureFromSurface(*renderer, loaded);
        if(newTexture == NULL){
            printf("Unable to create texture from %s! SDL Error: %s\n", path, SDL_GetError());
        }
        SDL_FreeSurface(loaded);
    }

    return newTexture;
}

void close(SDL_Window** gWindow, SDL_Renderer** gRenderer){
    SDL_DestroyRenderer(*gRenderer);
    SDL_DestroyWindow(*gWindow);
    *gWindow = NULL;
    *gRenderer = NULL;

    //Quit SDL subsystems
    IMG_Quit();
    SDL_Quit();
}

Player.h:

#ifndef PLAYER_H
#define PLAYER_H

#include <SDL2/SDL.h>

class Player
{
public:
    Player(int h, int m, int x, int y);
    ~Player();
    SDL_Texture* texture;
    SDL_Rect position;
    SDL_Rect currentTexturePos;
    int health;
    int mana;
    const char* name = "Bobby";
};
#endif

Player.cpp:

#include "Player.h"

Player::Player(int h, int m, int x, int y){
    health = h;
    mana = m;
    position.x = x;
    position.y = y;
    position.h = 64;
    position.w = 64;
    currentTexturePos.x = 64;
    currentTexturePos.y = 0;
    currentTexturePos.h = 64;
    currentTexturePos.w = 64;
}

Player::~Player(){
    SDL_DestroyTexture(texture);
    texture = NULL;
}

Makefile:

CC = g++
FLAGS = -w -lSDL2 -lSDL2_image
OBJECTS = main.cpp SDLHelper.cpp Player.cpp
NAME = tileBasedRPG

all: $(OBJECTS)
    $(CC) $(OBJECTS) $(FLAGS) -o $(NAME)

clean:
    rm -rf *.o

Answer 1

You never assigned newTexture:

newTexture == SDL_CreateTextureFromSurface(*renderer, loaded);

when it meant to be

newTexture = SDL_CreateTextureFromSurface(*renderer, loaded);