SDL2_ttf错误：找不到入口点

Question

So, while trying to add sdl_ttf to my game project, a wierd error popped up: http://i.imgur.com/RJ32QIs.png

Everything worked fine beforehand, and the problem started when I added TTF_Init()...

These are the files in my project:

main.cpp:

#include <sdl.h>
#include <sdl_image.h>
#include <sdl_ttf.h>
#include <stdio.h>
#include "CEngine.h"

int main(int argc, char *argv[]){
    CEngine Engine;

    //Start up SDL and create window
    if(!Engine.OnInit())
    {
        printf("Failed to initialize!\n");
    }

    //Loading in the gfx
    SDL_Surface* Surf_Player = Engine.LoadSurface("./gfx/player.png");
    SDL_Surface* Surf_Tile_Grass = Engine.LoadSurface("./tilesets/grass.png");
    SDL_Surface* Surf_Tile_Stone = Engine.LoadSurface("./tilesets/stone.png");

    bool Running = true;

    //Player Location
    int PlayerX = 64;
    int PlayerY = 64;

    //Map
    char Map[16][21]={"####################",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "#                  #",
                      "####################",};

    //Event handler
    SDL_Event e;

    //Main game loop
    while(Running){
        //Handle the events
        while(SDL_PollEvent(&e)){
            if(e.type==SDL_QUIT){
                Running = false;
            }
            //User presses a key
            else if(e.type == SDL_KEYDOWN){
                //Check which key was pressed
                switch(e.key.keysym.sym){
                    case SDLK_x:
                        Running = false;
                        break;
                    case SDLK_a:
                        if(Map[(PlayerX/Engine.TILE_SIZE)-1][PlayerY/Engine.TILE_SIZE]!='#'){
                            PlayerX-=32;
                        }
                        break;
                    case SDLK_d:
                        if(Map[(PlayerX/Engine.TILE_SIZE)+1][PlayerY/Engine.TILE_SIZE]!='#'){
                            PlayerX+=32;
                        }
                        break;
                    case SDLK_w:
                        if(Map[PlayerX/Engine.TILE_SIZE][(PlayerY/Engine.TILE_SIZE)-1]!='#'){
                            PlayerY-=32;
                        }
                        break;
                    case SDLK_s:
                        if(Map[PlayerX/Engine.TILE_SIZE][(PlayerY/Engine.TILE_SIZE)+1]!='#'){
                            PlayerY+=32;
                        }
                        break;
                    case SDLK_F1:
                        PlayerX = 64;
                        PlayerY = 64;
                        break;
                }
            }
        }
        //Apply the image
        for(int y = 0; y < (Engine.SCREEN_HEIGHT/Engine.TILE_SIZE); y++){
            for(int x = 0; x <= ((Engine.SCREEN_WIDTH/Engine.TILE_SIZE)-1); x++){
                SDL_Rect Rect_Temp;
                Rect_Temp.x=x*Engine.TILE_SIZE;
                Rect_Temp.y=y*Engine.TILE_SIZE;
                if(Map[y][x] == ' '){
                    SDL_BlitSurface(Surf_Tile_Grass, NULL, Engine.Surf_Screen, &Rect_Temp);
                }
                else if(Map[y][x] == '#'){
                    SDL_BlitSurface(Surf_Tile_Stone, NULL, Engine.Surf_Screen, &Rect_Temp);
                }
            }
        }
        SDL_Rect Rect_Temp;
        Rect_Temp.x = PlayerX;
        Rect_Temp.y = PlayerY;
        SDL_BlitSurface(Surf_Player, NULL, Engine.Surf_Screen, &Rect_Temp);
        //Update the surface
        SDL_UpdateWindowSurface(Engine.Window);
    }

    //Free resources and close SDL
    Engine.OnExit();
    return 0;
}

CEngine.h:

#ifndef CENGINE_H
#define CENGINE_H

#include <SDL.h>
#include <SDL_Image.h>
#include <SDL_TTF.h>
#include <string>
#include <stdio.h>

class CEngine
{
    public:
        CEngine();

        bool OnInit();
        void OnExit();
        SDL_Surface* LoadSurface(std::string path);

        SDL_Window* Window;

        SDL_Surface* Surf_Screen;

        const int SCREEN_WIDTH = 640;
        const int SCREEN_HEIGHT = 480;

        const char* WINDOW_TITLE = "Game";

        const char TILE_SIZE = 32;
};

#endif // CENGINE_H

CEngine.cpp:

#include "CEngine.h"

CEngine::CEngine(){
    //The window where surfaces will be rendered to
    Window = NULL;

    //The surface contained by the window
    Surf_Screen = NULL;
}

bool CEngine::OnInit(){
    //Initialize SDL
    if(SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
        return false;
    }

    //Create a window
    Window = SDL_CreateWindow("Game", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    if(Window == NULL){
        printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
        return false;
    }

    //Initialize PNG loading
    int imgFlags = IMG_INIT_PNG;
    if(!(IMG_Init(imgFlags) & imgFlags)){
        printf("SDL_image could not initialize. SDL_image Error: %s\n", IMG_GetError());
        return false;
    }

    //Initilize SDL_TTF
    if(TTF_Init() == -1){
        printf("SDL_TTF could not initilize! SDL_TTF Error: %s", TTF_GetError());
        return false;
    }

    //Get window surface
    Surf_Screen = SDL_GetWindowSurface(Window);

    return true;
}

void CEngine::OnExit(){
    //Destroy window
    SDL_DestroyWindow(Window);
    Window = NULL;

    //Cleans up the sdl_image subsystems(?)
    IMG_Quit();

    //Cleans up all initilized subsystems
    SDL_Quit();
}

SDL_Surface* CEngine::LoadSurface(std::string path){
    //Optimized image
    SDL_Surface* Surf_Optimized = NULL;

    //Load the image
    SDL_Surface* Surf_Loaded = IMG_Load(path.c_str());
    if(Surf_Loaded == NULL)
    {
        printf("Unable to load image %s. SDL Error: %s.\n", path.c_str(), IMG_GetError());
        return NULL;
    }

    //Converting the loaded surface to screen format
    Surf_Optimized = SDL_ConvertSurface(Surf_Loaded, Surf_Screen->format, 0);
    if(Surf_Optimized == NULL){
        printf("Unable to optimize image %s. SDL Error: %s.", path.c_str(), SDL_GetError());
    }

    //Get rid of the unoptimized version
    SDL_FreeSurface(Surf_Loaded);

    //Return the surface
    return Surf_Optimized;
}

These are my linker settings: http://i.imgur.com/Gyq5khi.png

And it was compiled using mingw 4.7 (Update: Tried with 4.8, the same error appeared)

Thanks in advance. (I'm sorry if I'm asking a dumb question, but I couldn't find an answer anywhere.)

Answer 1

This is a runtime error rather than a link time error. It looks like there is no libfreetype-6.dll in your build folder (where your executable is), or if is there, it is corrupted and you need one that is working. Just ensure that your libfreetype-6.dll and zlib.dll are correct and working versions that are compatible with mingw-4.7

Edit

In my experience, the only foolproof way of getting things to work on mingw is to ensure that every dll is built with the same version of mingw.

I haven't had dll incompatibility problems since I switched to Nuwen distro ( http://nuwen.net/mingw.html ) and started building all dependencies manually.