Página Inicial>Relacionado com a programação>Código-fonte C#
Baixar
MLX42

MLX42 é uma biblioteca gráfica de desempenho, fácil de usar, multiplataforma e com janelas mínimas para criar aplicativos gráficos sem ter que trabalhar diretamente com a estrutura de janelas nativa de um determinado sistema operacional.

Ele fornece ferramentas primitivas para desenhar texturas na janela, bem como modificá-las em tempo de execução à medida que são exibidas na janela.

Importante

Às vezes pode parecer que nenhuma atualização ocorre há muito tempo. Isso é esperado, o projeto/lib é considerado concluído e requer atualizações mínimas. As correções de bugs ainda são garantidas e o projeto ainda está sendo mantido ativamente.

Características

O MLX42 vem com uma infinidade de recursos que tornam seu uso realmente uma alegria, em vez de uma tarefa árdua.

Plataforma cruzada

Execute-o no WindowsXP da sua avó, no debian do seu tio ou no MacOS de um hipster! Não importa qual seja a plataforma, se o MLX42 puder ser construído sobre ela, ele será executado em seu sistema de janelas nativo.

Isso permite que você trabalhe em seu projeto, independentemente da máquina em que ele esteja.

Documentado

O MLX42 se preocupa com uma boa documentação, todas as funções, usos e até mesmo alguns trabalhos internos são documentados! Chega de adivinhar e pesquisar como algo funciona ou deveria funcionar.

Desempenho

Ele é construído em OpenGL e usa renderização em lote para acelerar o processo de renderização em comparação com outras bibliotecas.

Código aberto e orientado para a comunidade

Este projeto está sendo mantido ativamente pela Codam e também por alunos da Rede 42. Isso dá aos alunos a oportunidade direta de aprender mais sobre a biblioteca em si, bem como corrigir possíveis bugs, em vez de simplesmente aceitá-los.

Compatibilidade com Emscripten

MLX42 introduz compatibilidade com Emscripten, permitindo que MLX42 seja executado em navegadores web através do WebAssembly. Esta modificação foi possível graças a @PepeLevi, créditos a ele pelo fork e contribuições.

Destaques

  • Suporte Emscripten : Compile MLX42 com Emscripten, permitindo que aplicativos gráficos sejam executados em um ambiente web.
  • Compatibilidade com WebAssembly : Garante que o MLX42 possa ser utilizado em navegadores web modernos, expandindo sua usabilidade além dos ambientes de desktop tradicionais.
  • Documentação atualizada : orientação fornecida sobre como construir e executar projetos MLX42 usando Emscripten.

Instalação

Compilação geral

No geral, a construção deste projeto é a seguinte para TODOS os sistemas. Contanto que o CMake consiga entender isso.

  1. Baixe e construa MLX42

Caso seu sistema não tenha o glfw instalado, o cmake irá detectar isso e fazer o download para você. Você pode então executar sudo make install no diretório _deps do glfw. Se você estiver usando um computador 42 (MacOS, Linux), peça ao seu administrador de sistema favorito para instalá-lo. O mesmo vale para o CMake ou qualquer outra dependência que você possa precisar para o seu sistema.

No entanto, se você não puder fazer isso, o CMake ainda poderá buscar o GLFW e construí-lo. Você pode então vinculá-lo estaticamente da pasta _deps .

Observação

Para o Codam, o GLFW já vem instalado nos Macs.

Observação

Durante o estágio de vinculação, o sinalizador para vincular o GLFW pode ser: -lglfw3 ou -lglfw dependendo do seu sistema.

  1. Compile seu programa com a biblioteca:

    • Para: Mac OS
    • Para: Linux
    • Para Windows

  2. Lucro!

Instalando no sistema

Para construir totalmente a biblioteca e instalá-la em seu sistema, execute o seguinte comando: 

cmake -B build && cmake --build build --parallel --config (Debug | Release | RelWithDebInfo | MinSizeRel) --target install

Por padrão, o Windows colocará a lib instalada em: C:Program Files (x86)mlx42 e para MacOS/Linux ela será colocada em /usr/local/lib e /usr/local/include respectivamente.

Testes unitários

MLX42 vem com alguns testes unitários para garantir a integridade da biblioteca, para construí-los execute o seguinte comando: 

cmake -DBUILD_TESTS=ON -B build && cmake --build build --parallel

Em seguida, basta executá-los com: 

ctest --output-on-failure --test-dir build

Baixe e construa - MLX42 

git clone https://github.com/codam-coding-college/MLX42.git
cd MLX42
cmake -B build # build here refers to the outputfolder.
cmake --build build -j4 # or do make -C build -j4

O arquivo da biblioteca de saída é chamado libmlx42.a e está localizado na pasta build especificada.

Opções disponíveis

Você pode passar opções de construção para cmake, por exemplo: cmake -DDEBUG=1 -DGLFW_FETCH=0... . Por exemplo, eles permitirão que você o construa no modo DEBUG ou altere qualquer tipo de comportamento no momento da construção.

Você pode encontrar um exemplo de makefile na documentação aqui.

Para MacOS:

Instalando as dependências

Se o seu sistema não tiver GLFW nem CMake, é altamente recomendável usar brew para instalar as dependências ausentes.

Para 42 Campi você pode usar: 42Homebrew

Caso contrário, com homebrew: 

brew install glfw
brew install cmake

Se você estiver usando Apple Silicon (chip M1 ou posterior), observe que o caminho de instalação do Homebrew é diferente. Você pode querer atualizar seu arquivo de configuração do shell. Para usuários Zsh (shell padrão nas versões mais recentes do macOS): 

nano ~ /.zshrc
export LIBRARY_PATH=/opt/homebrew/lib

Reinicie sua sessão shell ou reinicie seu terminal para que as alterações tenham efeito.

Para MacOS você precisa usar os seguintes sinalizadores para compilar seu programa com a biblioteca a fim de vincular o programa aos frameworks corretos: 

-framework Cocoa -framework OpenGL -framework IOKit

Normalmente, se você simplesmente instalou/compilou glfw a partir do código-fonte ou já o instalou, a compilação deve ser: 

gcc main.c ... libmlx42.a -Iinclude -lglfw

Através da Homebrew/42Homebrew 

 # Homebrew
gcc main.c ... libmlx42.a -Iinclude -lglfw -L " /opt/homebrew/Cellar/glfw/3.3.8/lib/ "

# 42Homebrew
gcc main.c ... libmlx42.a -Iinclude -lglfw -L " /Users/ $( USER ) /.brew/opt/glfw/lib/ "

Segurança MacOS:

Ao executar seu programa no MacOS ele pode reclamar, porque com Macs você só precisa pensar diferente. No caso de algum aviso de segurança ou do MacOS informando que não é possível verificar o autor/desenvolvedor, vá para Settings > Security & Privacy .

Haverá um pop-up na parte inferior informando que um aplicativo tentou ser executado, clique na opção para deixá-lo ser executado.

Para Linux:

  1. Instale os pacotes necessários:

Para Debian como (Ubuntu, Mint, Pop OS...): 

sudo apt update
sudo apt install build-essential libx11-dev libglfw3-dev libglfw3 xorg-dev

Para Arch-linux (Manjaro, Endeavour, Garuda): 

sudo pacman -S glfw-x11

OU (se você usar o compositor sway/wlroots ou outro compositor wayland) 

sudo pacman -S glfw-wayland

  1. Baixe e construa MLX42

  2. Compile seu programa com a biblioteca: 

gcc main.c ... libmlx42.a -Iinclude -ldl -lglfw -pthread -lm
  1. Lucro!

Para Windows (com subsistema Windows para Linux 2 (WSL2))

Importante

Antes de começar com todas essas etapas, leia isto

  1. Defina essas variáveis ​​em seu .zshrc ou .bashrc : 
 export DISPLAY= $( ip route list default | awk ' {print $3} ' ) :0
export LIBGL_ALWAYS_INDIRECT=0

(Se o comando de exportação DISPLAY estiver falhando, consulte esta postagem do StackOverflow para alternativas)

  1. Baixe e instale um aplicativo XServer com configuração estendida (XMing não se qualifica). VcXsrv funciona: https://sourceforge.net/projects/vcxsrv/

  2. Abra o Firewall do Windows Defender e siga estas etapas:

  • Vá para ‘Permitir um aplicativo ou recurso através do Firewall do Windows Defender’
  • Alterar configurações
  • Encontre o XServer instalado, para VcXsrv que é 'VcXsrv windows server'
  • Habilitar comunicação em rede privada e pública Opcionalmente, você pode fornecer essas configurações na primeira inicialização do aplicativo XServer e elas podem nem aparecer na lista até a primeira vez que você iniciar o aplicativo.
  1. Inicie o aplicativo XLaunch (para VcXsrv) e forneça estas definições de configuração:
  • Deixe o número de exibição em automático
  • Não inicie nenhum cliente
  • DESMARQUE Opção Native opengl
  • TICK Disable access control
  • Conclua a inicialização do servidor
  1. Provavelmente todas as outras etapas do Linux se aplicam, basta clonar, construir e executar.

Para Windows nativo:

Importante

Esteja ciente de que o Visual Studio (2022) é necessário para isso. Desenvolver no Windows pode ser um tanto frustrante.

É altamente recomendável que você simplesmente use o WSL2 para tornar isso o mais simples possível. No entanto, se você insiste em construir para Windows nativamente, tudo o que você precisa em termos de dependências é:

  • CMake
  • GLFW

Depois de ter todas as dependências instaladas corretamente, CMake irá gerar os arquivos do projeto do Visual Studio. Simplesmente construa-o e, assim que tiver um arquivo .lib , mova-o para o seu projeto real e instale-o como faria com qualquer outra biblioteca.

Por precaução, aqui está um vídeo mostrando como isso pode ser feito. Convenientemente, este vídeo também aborda como você pode vincular glfw .

É claro que cabe a você garantir que o código que você escreve seja portátil. Coisas que existem no Unix não existem necessariamente no Win32 .

Exemplo

MLX42

 // -----------------------------------------------------------------------------
// Codam Coding College, Amsterdam @ 2022-2023 by W2Wizard.
// See README in the root project for more information.
// -----------------------------------------------------------------------------

#include 
#include 
#include 
#include 

#define WIDTH 512
#define HEIGHT 512

static mlx_image_t * image ;

// -----------------------------------------------------------------------------

int32_t ft_pixel ( int32_t r , int32_t g , int32_t b , int32_t a )
{
    return ( r << 24 | g << 16 | b << 8 | a );
}

void ft_randomize ( void * param )
{
	( void ) param ;
	for ( uint32_t i = 0 ; i < image -> width ; ++ i )
	{
		for ( uint32_t y = 0 ; y < image -> height ; ++ y )
		{
			uint32_t color = ft_pixel (
				rand () % 0xFF , // R
				rand () % 0xFF , // G
				rand () % 0xFF , // B
				rand () % 0xFF  // A
			);
			mlx_put_pixel ( image , i , y , color );
		}
	}
}

void ft_hook ( void * param )
{
	mlx_t * mlx = param ;

	if ( mlx_is_key_down ( mlx , MLX_KEY_ESCAPE ))
		mlx_close_window ( mlx );
	if ( mlx_is_key_down ( mlx , MLX_KEY_UP ))
		image -> instances [ 0 ]. y -= 5 ;
	if ( mlx_is_key_down ( mlx , MLX_KEY_DOWN ))
		image -> instances [ 0 ]. y += 5 ;
	if ( mlx_is_key_down ( mlx , MLX_KEY_LEFT ))
		image -> instances [ 0 ]. x -= 5 ;
	if ( mlx_is_key_down ( mlx , MLX_KEY_RIGHT ))
		image -> instances [ 0 ]. x += 5 ;
}

// -----------------------------------------------------------------------------

int32_t main ( void )
{
	mlx_t * mlx ;

	// Gotta error check this stuff
	if (!( mlx = mlx_init ( WIDTH , HEIGHT , "MLX42" , true)))
	{
		puts ( mlx_strerror ( mlx_errno ));
		return ( EXIT_FAILURE );
	}
	if (!( image = mlx_new_image ( mlx , 128 , 128 )))
	{
		mlx_close_window ( mlx );
		puts ( mlx_strerror ( mlx_errno ));
		return ( EXIT_FAILURE );
	}
	if ( mlx_image_to_window ( mlx , image , 0 , 0 ) == -1 )
	{
		mlx_close_window ( mlx );
		puts ( mlx_strerror ( mlx_errno ));
		return ( EXIT_FAILURE );
	}
	
	mlx_loop_hook ( mlx , ft_randomize , mlx );
	mlx_loop_hook ( mlx , ft_hook , mlx );

	mlx_loop ( mlx );
	mlx_terminate ( mlx );
	return ( EXIT_SUCCESS );
}
Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos