Como eu construo o Unity a partir da fonte?

Gostaria de saber como criaria o Unity a partir do código-fonte na atual versão de desenvolvimento. Por favor, cubra os seguintes tópicos:

• Quais pacotes são necessários para compilar o Unity?
• Onde obteria o código fonte atual?
• Quais são as etapas para realmente configurar e compilar o Unity?
• É possível executar com segurança a versão mais recente juntamente com a versão dos repositórios?

Construindo a Unidade a partir da Fonte

Neste guia, você criará uma versão separada do tronco do Unity (instalado localmente no diretório inicial), para que você não precise se preocupar em corromper a versão dos repositórios do Ubuntu e também não precisará obter permissões de root em todo o site. processo inteiro (exceto para instalar as dependências de compilação).

0. Instalando Dependências de Construção

Você precisará executar isso uma vez para instalar todas as dependências de compilação necessárias:

sudo apt-get install bzr cmake compiz-dev gnome-common libbamf3-dev libboost-dev \
libboost-serialization-dev libgconf2-dev libgdu-dev libglewmx1.6-dev \
libgnome-desktop-3-dev libibus-1.0-dev libindicator3-dev libjson-glib-dev \
libnotify-dev libnux-2.0-dev libpci-dev libsigc++-2.0-dev libunity-dev \
libunity-misc-dev libutouch-geis-dev libxxf86vm-dev libzeitgeist-dev xsltproc

Se você tiver repositórios de código-fonte (aka deb-src) ativados, poderá usar:

sudo apt-get build-dep unity

1. Preparando o meio ambiente

Substitua SOURCEe PREFIXpelos diretórios que você deseja que a fonte e construa os arquivos. Neste exemplo, coloquei os dois no meu diretório pessoal:

export SOURCE=$HOME/source/unity
export PREFIX=$HOME/build/unity

export PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig:$PKG_CONFIG_PATH"
export LD_LIBRARY_PATH="$PREFIX/lib:$LD_LIBRARY_PATH"
export LD_RUN_PATH="$PREFIX/lib:$LD_RUN_PATH"
export XDG_DATA_DIRS="$PREFIX/share:$XDG_DATA_DIRS"

mkdir -p "$PREFIX"
mkdir -p "$SOURCE"
cd "$SOURCE"

2. Construindo o Nux

Você provavelmente precisará pegar a versão mais recente Nuxpara obter o tronco do Unity para compilar:

bzr branch lp:nux
cd nux
./autogen.sh --disable-examples --disable-gputests --disable-tests --prefix="$PREFIX"
make -j4
make install
cd ..

Dica : A maioria dos desktops e laptops modernos possui vários núcleos. Você pode acelerar bastante a compilação aproveitando isso. O makecomando possui suporte interno para isso, que você pode ativar usando a opção -jN, em que N é o número de tarefas a serem executadas em paralelo. Uma boa regra é executar 2 vezes o número de núcleos no seu processador. Portanto, em um computador dual core normal, você deve executar make -j4para minimizar o tempo de compilação.

3. Construindo a Unidade

Agora pegue o código Unity mais recente e construa-o:

bzr branch lp:unity
cd unity
mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DGSETTINGS_LOCALINSTALL=ON -DCMAKE_INSTALL_PREFIX="$PREFIX"
make -j4
make install

É isso, saia e entre novamente e você deve estar executando o Unity mais recente. Como alternativa , você pode executar

setsid $PREFIX/bin/unity

4. Atualizando

Certifique-se de preparar o ambiente como descrito na etapa 1 e, em seguida, basta inserir os dois diretórios de nível superior nuxe unity, executar bzr pull, reconstruir e reinstalar.

Sugiro remover e recriar o builddiretório no unitydiretório, para garantir que nenhum arquivo antigo esteja interferindo na sua compilação.

5. Removendo a Unidade

Remova os três diretórios $SOURCE, $PREFIXe ~/.compiz-1.

Link útil:

• http://unity.ubuntu.com/getinvolved/development/unity/

Eu criei um script baseado no script de construção de Wayland e nessas instruções para automatizar a instalação de pré-requisitos, clonagem, atualização, configuração e criação do Unity.

https://github.com/bitshifter/Unity-Build/raw/master/build-unity.sh

Construindo em seu diretório pessoal

Às vezes, por razões de teste, é útil compilar o Unity e o nux em seu diretório pessoal, para que você possa tentar ver se algo está corrigido no tronco sem mexer nos pacotes e / ou PPAs. Perguntei a Jason Smith (Unity Dev) como ele constrói o Unity e ele explicou seu método para mim:

1. Verifique se você possui todas as dependências de compilação desta resposta.

2. Primeiro, crie um diretório em sua casa chamado "teste"; é aqui que criaremos o Unity. Crie um pequeno script que prepare o ambiente de construção, substitua o diretório inicial pelo seu:

   #!/bin/bash
   
   PREFIX=/home/jorge/staging
   
   export XDG_DATA_DIRS="$PREFIX/share:$XDG_DATA_DIRS"
   export LD_LIBRARY_PATH="$PREFIX/lib/"
   export PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig/"
   

   Eu chamo isso unity.she corro toda vez que quero construir o Unity. Então, basicamente, chmod +x unity.she ./unity.shquando você deseja construir.

3. Compile o nux:

   bzr branch lp:nux
   cd nux
   ./autogen.sh --prefix=/home/jorge/staging
   make -j4
   make install
   cd ..
   

4. Criar unidade:

   bzr branch lp:unity
   cd unity
   mkdir build
   cd build
   cmake .. -DCMAKE_INSTALL_PREFIX=/home/jorge/staging/ -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DGSETTINGS_LOCALINSTALL=ON
   make -j4
   make install
   

NOTA: Isso cria o nux e a unidade em seu diretório pessoal, não há necessidade de sudo aqui ou algo assim.

• Ao sair e voltar, a versão do Unity / nux será executada automaticamente desde que foi incorporada ~/.compiz
• Para voltar aos pacotes normais, basta sair, excluir ~/.compize entrar novamente.

O código fonte do ambiente padrão (Unity) pode ser encontrado no pacote unity. Instale o código-fonte com apt-get source unityas dependências para construí-lo sudo apt-get build-dep unitye desvie-o.

Isso permitirá que você posicione o iniciador à direita, inferior, superior etc.

Há uma excelente documentação oficial aqui - Developing Unity .

Aqui está um trecho dele sobre a construção do Unity - instalando a partir do código-fonte e compilando

Construindo a Unidade

Essas instruções ajudarão você a construir a unidade a partir da fonte. No entanto, há algumas coisas a considerar:

• É recomendável que você nunca copie nada que tenha construído localmente fora do diretório inicial. Fazer isso está causando problemas, principalmente porque estamos construindo todo o shell da área de trabalho. Se você conseguir arruinar seu shell de desktop em todo o sistema, será um programador muito triste!
• Supõe-se que você esteja executando a versão precisa do Ubuntu.
• Supõe-se também que você deseja construir a unidade a partir do tronco (ou seja, lp: unity).

Obtendo o código fonte:

Se você ainda não possui o Bazaar instalado, instale-o agora:

sudo apt-get install bzr

Você desejará criar uma pasta para o código da unidade. Faça algo parecido com isto:

mkdir -p ~/code/unity
cd ~/code/unity

Vamos pegar o código na barra de ativação:

bzr branch lp:unity trunk

Isso pode demorar um pouco.
Instalando dependências de compilação:

Precisamos obter as dependências de construção para a unidade. Felizmente, o apt-get torna isso trivial:

sudo apt-get build-dep unity

Unidade de compilação:

Use este conjunto de funções bash para facilitar esta etapa significativamente. Para usá-los, copie o seguinte código bash em um arquivo em seu diretório pessoal chamado .bash_functions:

function recreate-build-dir()
{
   rm -r build
   mkdir build
   cd build
}

function remake-autogen-project()
{
    ./autogen.sh --prefix=$HOME/staging --enable-debug
    make clean && make && make install
}

function remake-unity()
{
    recreate-build-dir
    cmake .. -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DCMAKE_INSTALL_PREFIX=$HOME/staging/ -DGSETTINGS_LOCALINSTALL=ON
    make  && make install
}

function unity-env
{
 export PATH=~/staging/bin:$PATH
 export XDG_DATA_DIRS=~/.config/compiz-1/gsettings/schemas:~/staging/share:/usr/share:/usr/local/share
 export LD_LIBRARY_PATH=~/staging/lib:${LD_LIBRARY_PATH}
 export LD_RUN_PATH=~/staging/lib:${LD_RUN_PATH}
 export PKG_CONFIG_PATH=~/staging/lib/pkgconfig:${PKG_CONFIG_PATH}
 export PYTHONPATH=~/staging/lib/python2.7/site-packages:$PYTHONPATH
}

Agora execute isso em um terminal:

echo ". ~/.bash_functions" >> ~/.bashrc

Isso garante que na próxima vez que você abrir um shell bash, as funções listadas acima estarão disponíveis para você. Para evitar ter que fechar e reabrir um terminal, podemos lê-los manualmente apenas uma vez:

. ~/.bash_functions

Agora você deve poder executar:

remake-unity

do trunk/diretório que criamos anteriormente. É isso aí - você está construindo a unidade!

A instalação ficou mais complicada recentemente: um novo módulo foi adicionado ao compiz chamado GTK Load (ou ele trava no XInternAtom). Precisamos ativar este módulo para usar o 4.0.1, mas ativá-lo trará a unidade 3.8.

Está ficando difícil manter os dois. O jeito que eu fiz foi:

• vá na pasta compiz-1 e renomeie todos os .so por .so1, exceto libgtkloader.so
• reinicie o compiz com o unity 4.0.1
• ative o módulo gtk Load no compizconfig-settings-manager
• renomeie as bibliotecas de volta para .so
• reinicie o compiz.