Como construir e instalar o GLFW 3 e usá-lo em um projeto Linux

95

GLFW3

Ontem à noite eu estava trabalhando até tarde tentando construir os pacotes GLFW 3 para Linux a partir do código-fonte. Esse processo me levou muito tempo, cerca de 3 horas no total, em parte porque não estou familiarizado com o CMake e em parte porque não estava familiarizado com o GLFW.

Espero que este post te livre da dificuldade que tive ontem! Achei que deveria fazer um pequeno artigo e, espero, poupar várias horas de sua vida ...

Graças a "urraka", "b6" e "niklas" no canal IRC #glfw, consegui fazer o glfw versão 3.0.1 funcionar.

Acontece que este não é um processo trivial (certamente não para mim, eu não sou especialista), pois não há muita documentação na web sobre glfw3, particularmente sobre como configurá-lo com o CMake.

Pediram-me para dividir isso em uma seção de perguntas e respostas e, portanto, fiz isso, e as partes das respostas estão agora abaixo.

Você é mantenedor do GLFW ou membro da equipe do GLFW?

Se algum dos mantenedores do GLFW3 vir isso, minha mensagem para eles é: adicione uma seção "Configurando o GLFW3 no Windows, Mac OS X e Linux" ao seu site! É muito fácil escrever programas com GLFW, já que a documentação online é muito boa, uma varredura rápida de todas as classes e módulos disponíveis e você estará pronto para começar. O exemplo de um projeto de teste apresentado aqui também é muito bom. Os dois principais problemas que encontrei foram, primeiro como faço para configurar o GLFW3 no meu sistema e, segundo, como construir um projeto GLFW3? Essas duas coisas talvez não sejam claras o suficiente para um não especialista.

Editar

Dando uma olhada rápida hoje (Data: 2014-01-14), parece que o site do GLFW passou por grandes mudanças desde a última vez que olhei e agora há uma seção sobre compilar o GLFW e construir programas com o GLFW, que eu acho que são novos.

user3728501
fonte
Obrigado por colocar isso aqui - obviamente, muito trabalho foi feito. Você se importaria de dividir em uma pergunta e uma resposta? Você pode adicionar sua própria resposta à sua própria pergunta e marcá-la como correta.
Fraser de
@Fraser Sim, claro se você acha que seria melhor assim
user3728501
1
Eu concordo. Eu gosto muito do GLFW, mas fiquei realmente frustrado ao não encontrar nenhuma documentação sobre como compilar v3 no Mac, etc.
user18490
1
@ user18490 Sim, eu achei isso surpreendente, já que o GLFW parece ser "um excedente melhor". Tenho certeza que eles mencionaram em sua documentação que o excesso só é bom para o aprendizado e se você quiser uma biblioteca de janelas profissional, use o GLFW. Portanto, o surpreendente é que eles dizem como é bom, mas não dizem como instalá-lo! (Muito diferente do SFML)
user3728501
@Edward Bird. Eu finalmente encontrei algumas informações úteis sobre esta página web sobre a instalação GLFW: scratchapixel.com/lessons/3d-basic-lessons/lesson-2-get-started/...
user18490

Respostas:

125

Etapa 1: Instalando o GLFW 3 em seu sistema com CMAKE

Para esta instalação, usei o KUbuntu 13.04, 64bit.

O primeiro passo é fazer o download da versão mais recente (presumindo que as versões futuras funcionem de maneira semelhante) de www.glfw.org , provavelmente usando este link .

A próxima etapa é extrair o arquivo e abrir um terminal. cdno diretório glfw-3.XX e execute cmake -G "Unix Makefiles"você pode precisar de privilégios elevados, e você também pode precisar instalar dependências de compilação primeiro . Para fazer isso, tente sudo apt-get build-dep glfw ou sudo apt-get build-dep glfw3 ou faça manualmente , como fiz usando sudo apt-get install cmake xorg-dev libglu1-mesa-dev... Pode haver outras libs que você precise, como as bibliotecas pthread ... Aparentemente, eu já as tinha. (Consulte as opções -l fornecidas para o estágio do vinculador g ++, abaixo.)

Agora você pode digitar makee então make install, o que provavelmente exigirá que você sudoprimeiro.

Ok, você deve obter alguma saída detalhada nos últimos três estágios do CMake, informando o que foi construído ou onde foi colocado. (Em /usr/include, por exemplo.)

Etapa 2: criar um programa de teste e compilar

O próximo passo é iniciar o vim ("o quê ?! vim ?!" você diz) ou seu IDE / editor de texto preferido ... Eu não usei o vim, usei o Kate, porque estou no KUbuntu 13.04 ... De qualquer forma, baixe ou copie o programa de teste daqui (no rodapé da página) e salve, saia.

Agora compile usando g++ -std=c++11 -c main.cpp- não tenho certeza se c ++ 11 é necessário, mas eu usei nullptr, eu precisava ... Você pode precisar atualizar seu gcc para a versão 4.7 ou a próxima versão 4.8 ... Informações sobre isso aqui .

Então corrija seus erros se você digitou o programa manualmente ou tentou ser "muito inteligente" e algo não funcionou ... Então faça um link usando este monstro! g++ main.o -o main.exec -lGL -lGLU -lglfw3 -lX11 -lXxf86vm -lXrandr -lpthread -lXiEntão você vê, na parte "instalar dependências de compilação", você também pode querer verificar se tem as bibliotecas de desenvolvimento GL, GLU, X11 Xxf86vm (seja lá o que for) Xrandr posix-thread e Xi (seja lá o que for) instaladas também. Talvez atualize seus drivers gráficos também, eu acho que GLFW 3 pode exigir OpenGL versão 3 ou superior? Talvez alguém possa confirmar isso? Você também pode precisar adicionar as opções de vinculador -ldl -lXinerama -lXcursorpara fazê-lo funcionar corretamente se você estiver recebendo referências indefinidas para dlclose(crédito para @ user2255242).

E, sim, eu realmente precisava de tantos -ls!

Passo 3: Você terminou, tenha um bom dia!

Esperançosamente, esta informação estava correta e tudo funcionou para você, e você gostou de escrever o programa de teste GLFW. Também espero que este guia tenha ajudado ou vai ajudar, algumas pessoas no futuro que estavam lutando como eu estava hoje ontem!

A propósito, todas as tags são as coisas que pesquisei no stackoverflow em busca de uma resposta que não existia. (Até agora). Com sorte, eles são o que você procurava se estivesse em uma posição semelhante à minha.

Nota do autor:

Isso pode não ser uma boa ideia. Este método (usando sudo make install) pode ser prejudicial ao seu sistema. (Veja Don't Break Debian)

O ideal é que eu, ou outra pessoa, proponha uma solução que não instale apenas arquivos lib etc nos diretórios padrão do sistema, já que eles devem ser gerenciados por gerenciadores de pacotes como apt, e fazer isso pode causar um conflito e quebrar seu sistema de gerenciamento de pacotes.

Veja a nova "resposta para 2020" para uma solução alternativa.

user3728501
fonte
Passei horas tentando descobrir isso. Esta resposta funcionou para mim: Ubuntu 13.04, x64. NetBeans C ++ IDE (adicione a linha do vinculador em Propriedades do projeto-> Construir-> Vinculador-> Bibliotecas-> Adicionar opção-> Outra opção - caso contrário, siga as instruções literalmente)
Scott Drew
Aparentemente (com o GLFW 3.0.3) algo usa, powentão adicionar -lmopções de compilação corrigiu isso.
Forest Katsch
1
Edward, obrigada. Eu precisava dessa verificação de sanidade para que todos os requisitos -l não significassem apenas que eu estava fazendo algo errado.
Wrongu 01 de
3
cara, você é um gênio do **** !!!! você tem 3 horas, eu tenho 3 dias tentando fazer isso (na verdade, pesquisando por onde começar, lendo sobre a história do excesso e assim por diante, de qualquer maneira) obrigado, muito obrigado; Gostaria também de avisar que li a página glfw, não consegui fazer o trabalho seguindo o tutorial deles, estava quase desistindo quando descobri isso e eles não explicam de forma simples e direta como você. trabalho incrível que você fez aqui !!
Victor R. Oliveira
1
Em um Linux Mint limpo, tive que instalar estes pacotes:sudo apt-get update && sudo apt-get install build-essential libevent-pthreads-2.0.5 doxygen xorg-dev libglu1-mesa-dev
Lenar Hoyt
18

Eu resolvi dessa forma

Um arquivo pkg-config descreve todos os sinalizadores de tempo de compilação e tempo de link e dependências necessárias para usar uma biblioteca.

pkg-config --static --libs glfw3

me mostra isso

-L/usr/local/lib -lglfw3 -lrt -lXrandr -lXinerama -lXi -lXcursor -lGL -lm -ldl -lXrender -ldrm -lXdamage -lX11-xcb -lxcb-glx -lxcb-dri2 -lxcb-dri3 -lxcb-present -lxcb-sync -lxshmfence -lXxf86vm -lXfixes -lXext -lX11 -lpthread -lxcb -lXau -lXdmcp  

Não sei se todas essas libs são realmente necessárias para compilar, mas para mim funciona ...

Oleh Pomazan
fonte
3
Esta resposta é imperdível. Eu não sabia sobre o pkg-config antes. Mas a partir de hoje vou usar até o fim, pois vai me ajudar a resolver qualquer tipo de problema de dependência de linkagem. Obrigado por uma resposta tão incrível.
Sayan Bhattacharjee
18

Observe que você não precisa de tantos -ls se instalar o glfw com a BUILD_SHARED_LIBSopção. (Você pode habilitar esta opção executando ccmakeprimeiro).

Desta forma, sudo make installirá instalar a biblioteca compartilhada no /usr/local/lib/libglfw.so. Você pode então compilar o arquivo de exemplo com um simples:

g++ main.cpp -L /usr/local/lib/ -lglfw

Então não se esqueça de adicionar / usr / local / lib / ao caminho de busca por bibliotecas compartilhadas antes de executar seu programa. Isso pode ser feito usando:

export LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH}

E você pode colocar isso no seu ~/.bashrcpara não ter que digitar o tempo todo.

CastleDefender
fonte
1
esta informação é realmente importante para aqueles que gostariam de configurar um IDE em vez de usar o terminal para compilar e executar; Você poderia dar mais detalhes sobre como fazer isso? Tentei, mas não tive sucesso
Victor R. Oliveira
Noob aqui! Eu sei que isso é um pouco antigo, mas realmente me ajudou. Alguém pode explicar (ou criar um link para alguém explicando) por que usar uma biblioteca compartilhada faria com que não precisássemos vincular todas as outras bibliotecas, muitas das quais também eram arquivos de objetos compartilhados? Além disso, tive que definir a variável LD_LIBRARY_PATH após a compilação, ou enfrentaria a ira dos erros GNU quando tento executar meu executável recém-compilado.
Sammaron
1
Olá Sammaron, obrigado por falar sobre o LD_LIBRARY_PATH, atualizarei minha resposta para incluir isso. O motivo pelo qual você não precisa especificar todas as outras bibliotecas ao usar a biblioteca glfw é porque o glfw já as carrega. Você pode usar o comando lddpara verificar quais bibliotecas são carregadas por um programa quando ele é executado. Também é uma boa maneira de verificar se as bibliotecas foram encontradas corretamente. Você pode usar lddem seu programa e em /usr/local/lib/libglfw.so para comparar.
CastleDefender
Obrigado pela resposta! Além disso, eu queria me corrigir um pouco: a variável LD_LIBRARY_PATH é uma solução viável, mas se a biblioteca foi instalada no caminho padrão que o carregador estará procurando de qualquer maneira, a execução sudo ldconfigdeve resolver este problema, e não requer que LD_LIBRARY_PATH seja configurado toda vez. Esta resposta fornece uma discussão sobre por que isso pode ser preferido.
Sammaron
Depois de fazer o build shared, tive que compilar / vincular 2 outros. g ++ main.cpp -L / usr / local / lib / -lglfw -lGLU -lGL funcionou para mim.
Sridhar Thiagarajan
9

Como a resposta aceita não permite mais edições, vou resumi-la com um único comando de copiar e colar (substitua 3.2.1 pela versão mais recente disponível na primeira linha):

version="3.2.1" && \
wget "https://github.com/glfw/glfw/releases/download/${version}/glfw-${version}.zip" && \
unzip glfw-${version}.zip && \
cd glfw-${version} && \
sudo apt-get install cmake xorg-dev libglu1-mesa-dev && \
sudo cmake -G "Unix Makefiles" && \
sudo make && \
sudo make install

Se você deseja compilar um programa, use os seguintes comandos:

g++ -std=c++11 -c main.cpp && \
g++ main.o -o main.exec -lGL -lGLU -lglfw3 -lX11 -lXxf86vm -lXrandr -lpthread -lXi -ldl -lXinerama -lXcursor

Se você estiver seguindo o tutorial learnopengl.com, pode ser necessário configurar o GLAD também. Nesse caso, clique neste link

http://glad.dav1d.de/#profile=core&specification=gl&api=gl%3D3.3&api=gles1%3Dnone&api=gles2%3Dnone&api=glsc2%3Dnone&language=c&loader=on

e então clique no botão "Gerar" no canto inferior direito do site e baixe o arquivo zip. Extraia-o e compile as fontes com o seguinte comando:

g++ glad/src/glad.c -c -Iglad/include

Agora, os comandos para compilar seu programa ficam assim:

g++ -std=c++11 -c main.cpp -Iglad/include && \
g++ main.o glad.o -o main.exec -lGL -lGLU -lglfw3 -lX11 -lXxf86vm -lXrandr -lpthread -lXi -ldl -lXinerama -lXcursor
Adrian
fonte
2
Brilhante! Trabalhou para mim no Ubuntu 16.04 com GLFW v3.2.1. Apenas duas pequenas correções: set version = XXX deve ser simplesmente version = "XXX" e não deve haver nenhum .zip no final desta linha: cd glfw - $ {version} .zip
Tim
2

Grande guia, obrigado. Com a maioria das instruções aqui, ele quase foi criado para mim, mas ainda havia um erro.

/usr/bin/ld: //usr/local/lib/libglfw3.a(glx_context.c.o): undefined reference to symbol 'dlclose@@GLIBC_2.2.5'
//lib/x86_64-linux-gnu/libdl.so.2: error adding symbols: DSO missing from command line
collect2: error: ld returned 1 exit status

Depois de pesquisar esse erro, tive que adicionar -ldlà linha de comando.

g++ main.cpp -lglfw3 -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor -lGL -lpthread -ldl

Em seguida, o aplicativo de amostra "hello GLFW" compilado e vinculado.

Eu sou muito novo no Linux, então não estou completamente certo do que exatamente esta biblioteca extra faz ... além de corrigir meu erro de link. No entanto, vejo essa mudança de linha cmd na postagem acima.

user2941878
fonte
Eu tenho o arquivo .o e .exec .. por favor me ajude, como executá-lo?
Buddhika Chaturanga
0

Se alguém está ficando preguiçoso e talvez não saiba como configurar o shell para todas as bibliotecas e -l s, criei um script python (você precisa ter o python3, a maioria dos usuários de linux tem.) Que permite compilar facilmente scripts e executá-los sem me preocupar muito, ele só tem chamadas de sistema regulares, apenas organizadas de forma organizada, eu criei para mim mesmo, mas talvez seja útil: Aqui está

mathmaniage
fonte
0

A resposta bem descrita já está aí, mas passei por esta receita MAIS CURTA :

  1. Instale Linuxbrew
  2. $ brew install glfw
  3. cd /home/linuxbrew/.linuxbrew/Cellar/glfw/X.X/include
  4. sudo cp -R GLFW /usr/include

Explicação: Conseguimos construir o GLFW pelo CMAKE, que é feito pelo Linuxbrew (porta Linux do amado Homebrew). Em seguida, copie os arquivos de cabeçalho para onde o Linux lê ( /usr/include).

Shayan Amani
fonte
0

Resposta atualizada de 2020

É 2020 (7 anos depois) e aprendi mais sobre Linux durante esse tempo. Especificamente, pode não ser uma boa ideia executar sudo make installdurante a instalação de bibliotecas, pois elas podem interferir no sistema de gerenciamento de pacotes. (Neste caso, aptcomo estou usando o Debian 10.)

Se isso não estiver correto, corrija-me nos comentários.

Solução alternativa proposta

Essas informações são retiradas dos documentos do GLFW, no entanto, expandi / simplifiquei as informações que são relevantes para os usuários Linux.

  • Vá para o diretório inicial e clone o repositório glfw do github
cd ~
git clone https://github.com/glfw/glfw.git
cd glfw
  • Você pode, neste ponto, criar um diretório de construção e seguir as instruções aqui ( instruções de construção do glfw ), no entanto, optei por não fazer isso. O comando a seguir ainda parece funcionar em 2020, entretanto, não é explicitamente declarado nas instruções online do glfw.
cmake -G "Unix Makefiles"
  • Pode ser necessário executar sudo apt-get build-dep glfw3antes (?). Executei este comando e de sudo apt install xorg-devacordo com as instruções.

  • Finalmente corra make

  • Agora, no diretório do seu projeto, faça o seguinte. (Vá para o seu projeto que usa as libs glfw)

  • Crie um CMakeLists.txt, o meu é assim

CMAKE_MINIMUM_REQUIRED(VERSION 3.7)
PROJECT(project)

SET(CMAKE_CXX_STANDARD 14)
SET(CMAKE_BUILD_TYPE DEBUG)

set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)

add_subdirectory(/home/<user>/glfw /home/<user>/glfw/src)


FIND_PACKAGE(OpenGL REQUIRED)

SET(SOURCE_FILES main.cpp)

ADD_EXECUTABLE(project ${SOURCE_FILES})
TARGET_LINK_LIBRARIES(project glfw)
TARGET_LINK_LIBRARIES(project OpenGL::GL)
  • Se você não gosta do CMake, peço desculpas, mas na minha opinião é a maneira mais fácil de fazer seu projeto funcionar rapidamente. Eu recomendaria aprender a usá-lo, pelo menos em um nível básico. Infelizmente, não conheço nenhum bom tutorial CMake

  • Então faça cmake .e make, seu projeto deve ser construído e vinculado à biblioteca compartilhada glfw3

  • Existe alguma maneira de criar uma biblioteca vinculada dinâmica. Acredito ter usado o método estático aqui. Por favor, comente / adicione uma seção nesta resposta abaixo se você souber mais do que eu

  • Isso deve funcionar em outros sistemas, se não, avise-me e ajudarei se for capaz de

user3728501
fonte