Vcpkg install sfml x64 windows

Getting SFML to work with Visual Studio

Here’s a video that walks you through this process: https://watch.screencastify.com/v/VDdqsobi8ZyQUnQKNREP

An Automated Option

SFMLInstall written by Kyle.

Install Git

Git is a version control system that lets you manage and keep track of your source code history. If you’re familiar with GitHub, the difference is that GitHub is a cloud-based hosting service that lets you manage Git repositories.

Download and install Git. On the git site, find the latest source release, and click «download for windows».

Install vcpkg

Vcpkg is a C/C++ package manager for acquiring and managing libraries.
Open command prompt by pressing Win + R, typing cmd and pressing enter, or searching cmd via the windows search bar.

Once command prompt is open, type git clone https://github.com/microsoft/vcpkg

Then type cd vcpkg

Then type bootstrap-vcpkg.bat

Use vcpkg to get SFML

In command prompt, type vcpkg install SFML:x64-windows .

Then, to get SFML useable by all your IDE’s including Visual studio, type
vcpkg integrate install

Writing your first graphical SFML Program

Here’s a basic SFML program that draws a green circle to a small game screen:

Картинка с сайта: cecgameprogramming.miraheze.org

Temporary SFML Template Code

#include<SFML/Graphics.hpp>


using namespace std;


int main() {


sf::RenderWindow window(sf::VideoMode(1920,1080), "Window", sf::Style::Fullscreen);
window.setFramerateLimit(60);


sf::Event event;


while (window.isOpen()) {


while (window.pollEvent(event)) {


if (event.type == sf::Event::Closed) {
window.close();
}


}


window.clear((sf::Color::Black));


window.display();
}
}

In this blog post, I will cover the set up of a project using CMake, Visual Studio and vcpkg to create a basic SFML project.

Note: I assume you have basic familiarity with CMake and Visual Studio. Please look at my previous blog post for a small introduction to CMake and Visual Studio.

Prerequisites

• Visual Studio 15+ (2017)
• CMake 3.6+
• vcpkg

Set Up

However, first we must install Microsoft’s vcpkg tool. First, go to the repository of vcpkg and follow the instructions there to get vcpkg installed on your system. The instructions are pretty detailed and will get you set up without a hitch.

vcpkg might ask you to download CMake if the version on your system is not high enough (3.6+) or you don’t have CMake installed.

Once you have vcpkg set up, we will run it to set up SFML.

Note: vcpkg doesn’t configure the PATH environment variable, so you will have to run it from the directory you installed it in.

Now we need to run this command so let’s type it in:

vcpkg.exe install sfml

vcpkg will begin installation of SFML. vcpkg pulls the source code (where applicable) and builds the project and it’s dependencies from scratch so this may take a while. Best to relax and wait while it builds.

vcpkg will notify you when it has finished.

CMakeLists.txt

Once that is complete, we need to set up our CMakeLists.txt. Type this in:

cmake_minimum_required(VERSION 3.6)
project(simple_sfml)

set(CMAKE_MODULE_PATH
    "${CMAKE_SOURCE_DIR}/cmake_modules"
     ${CMAKE_MODULE_PATH})

find_package(SFML 2.4.2 REQUIRED system window graphics)

include_directories(${SFML_INCLUDE_DIR})

# Add MSVC compiler options
if (WIN32)
 if (MSVC)
  add_compile_options(/W3 /Za /TP /permissive-)
 endif (MSVC)
endif (WIN32)

add_executable(simple_sfml src/main.cpp)

target_link_libraries(simple_sfml ${SFML_LIBRARIES})

The first line specifies which version of CMake to use and the second line declares the project name which will also set the executable name.

In order for CMake to find SFML on your system, you need a findSFML.cmake file. This is provided by the SFML authors and you just need to include it (for example, in a cmake_modules directory) and tell CMake to load it. That’s basically what line 4 does. It appends our cmake_modules directory to CMake’s existing CMAKE_MODULE_PATH variable.

Now CMake will know where to look for SFML by using the findSFML.cmake to find the headers, *.lib‘s and *.dll‘s (including SFML’s dependencies).

Line 8 tells CMake to find SFML version 2.4.2 or higher and to load up the system, window and graphics modules of SFML. This will load and copy the correct .lib or .dll files and CMake will be able to load up debug versions when you’re debugging and release versions when you want to release your code. find_package in the background invokes SFMLconfig.cmake which sets up all this for you. SFMLconfig.cmake is provided by vcpkg and passed to CMake. We will set that up soon.

Line 10 ensures that we add (and have access to) the necessary header files which we will use in our source code.

Now, line 12 to line 17 is not necessary. I like to add these to just MSVC to get rid of any extras Microsoft has added to C++ and to be explicit on what I am compiling and linking. I will go over a quick summary of the four flags:

1. /W3 – sets the warning level for C++. I’ve read you shouldn’t use /W4 and /Wall as the former is far too picky on some warnings and the latter is broken.
2. /Za – disable Microsoft’s extensions to C++[*].
3. /TP – compile as C++ code.
4. /permissive- – makes MSVC conformant to ISO C++ as much as possible.

Line 19 we specify the executable and the source (.cpp) files to link with.

Line 21 we link the executable with the .dll files. Unfortunately, this blog post only covers dynamic linking to the “bin” directory to which the .dll files will be copied by CMake (to be honest, I haven’t figured out how to do the static linking with this approach ). Note that only the .dll files corresponding to what we asked for (the modules of SFML) in find_package will be copied over and linked.

Now we can set up the CMakeSettings.json.

CMakeSettings.json

Our CMakeSettings.json will look similar to how we set it up in my previous blog post except for one bit. We need to add a toolchain file to CMake so that CMake will know how to handle SFML. This is essentially passing the SFMLconfig.cmake file to CMake. Type in the following:

{
   "configurations": [
        {
            "name": "x86-Debug",
            "generator": "Visual Studio 15 2017",
            "configurationType": "Debug",
            "buildRoot": "${projectDir}\\build\\${name}",
            "cmakeCommandArgs": "",
            "buildCommandArgs": "-m -v:minimal",
            "variables": [
                {
                    "name": "CMAKE_TOOLCHAIN_FILE",
                    "value": "C:\\Microsoft\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake"
                }
            ]
        },
        {
            "name": "x86-Release",
            "generator": "Visual Studio 15 2017",
            "configurationType": "Release",
            "buildRoot": "${projectDir}\\build\\${name}",
            "cmakeCommandArgs": "",
            "buildCommandArgs": "-m -v:minimal",
            "variables": [
                {
                    "name": "CMAKE_TOOLCHAIN_FILE",
                    "value": "C:\\Microsoft\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake"
                }
            ]
        }
    ]
}

Take note that we need to do this for both debug and release. The “value” part will differ if you have installed vcpkg to a different location. The SFMLconfig.cmake is what sets the SFML_INCLUDE_DIR and SFML_LIBRARIES variables.

main.cpp

The main.cpp is fairly straight forward. It just creates a window which waits until it is closed [1]:

#include <SFML/Window.hpp>

int main()
{
    sf::Window window(sf::VideoMode(640, 480), "Simple SFML Example");

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }
    }

    return 0;
}

Nothing too fancy

Putting it all together

Now we have everything in place to build the project. So let’s do that by pressing F7 or by clicking “Build Solution” under “Build” in the menu bar. Compilation should succeed and we can now press F5 or clicking “Start” under “Debug” in the menu bar. We’ll see a command prompt window come up followed by our SFML window with a white background. Success!

Conclusion

In conclusion, this was quite a battle for me to get it right the first time. Mainly with the CMakeLists.txt and figuring out that findSFML.cmake is not provided by vcpkg. But once that was sorted, everything worked perfectly.

This is the general format to get most libraries going with CMake and vcpkg. You need the toolchain file and to know which targets get set by the library you’re trying to use. Take note that this approach does not hold for some libraries [2].

Link to github repository

References

[1] – https://www.sfml-dev.org/tutorials/2.4/window-window.php
[2] – https://github.com/Microsoft/vcpkg/blob/master/docs/examples/using-sqlite.md#handling-libraries-without-native-cmake-support

Resources

SFML – https://www.sfml-dev.org/learn.php
Using vcpkg – https://github.com/Microsoft/vcpkg/blob/master/docs/examples/using-sqlite.md

[*] – I have recently discovered that /Za is discouraged and that /permissive- is the recommended (and maintained) option. I will phase out this option in future usages.