languages on BLOG

Entendendo diferenças entre SDL Window, Surfaces e Rendering

Fri, 16 Apr 2021 10:47:55 -0300

Nessa minha jornada em fazer um jogo rpg no estilo top-down, programando em SLD e usando GO,encontrei muitos tutoriais ensinando como usar o SDL, mas quase todos são muito voltados para exemplos de código,com pouca explicação do que são os componentes do SDL apresentados.

Eu gosto de entender aquilo que estou fazendo e por que estou usando tal elemento no lugar de outro elemento.

E dessa forma comecei a ficar confuso, afinal, o que é uma Surface, Window e Renderer? Como são relacionadas e como se diferem.

E encontrei esse post no stackoverflow que mostra que não é só eu que estava confuso, era uma dúvida bem comum.

E como forma de estudo vou descrever minha compreensão sobre o assunto.

SDL Window, Surface e Renderer

O que são, para que servem e o que os diferem.

Software Blitting

Como iremos falar de 3 coisas que envolvem computação gráfica, acho importante primeiramente comoas imagens são processadas na tela.

Bitmap

Primeiramente você precisa entender o que é um bitmap. bitmap é um arquivo de imagem não comprimido, ou seja, ele carrega todas as informações de pixel por pixel de uma imagemcomo é representado pelo computador, por coordenadas X, Y.

BLIT

O termo blit vem de bit block transfer ou “transferência de bloco bit”, e isso ocorre em bitmaps. A operação envolve ao menos dois bitmaps, uma fonte e destino.Você por imaginar um jogo 2D, como Legend of Zelda por exemplo, onde você irá precisar desenhar a grama, depois sobrepor com um outro bitmap como um arbusto e depois sobrepor com outro bitmap como o herói Link, isso tudo ocorre usando Blit.

No SDL temos o SDL_RenderCopy, que é usado extensivamente no desenvolvimento de games 2D, que é basicamente faz esse overlay descrito acima.

SDL Window

Representa a janela que onde será renderizado seu jogo ou qualquer outra coisa que você estiver fazendo com SDL. Tem atributos como largura, altura, se irá executar em Fullscreen, se é redimensionavel, se tem borda ou não e coisas do tipo.

SDL Surface

É simplesmente um estrutura que armazena informações de pixels usadas em software blitting

SDL Texture

É como o SDL Surface, até chamam ele de nova versão do SDL Surface, há inclusive métodos para converter o SDL Surface em SDL Texture.É uma estrutura que contém um eficiente, driver-especifico representação de informações de pixels.

Uma diferença significativa do SDL Surface, é que o Texture roda na GPU enquanto o Surface roda usando CPU.

SDL Renderer

Enquanto Blitting é um processo simples de copiar bits entre diferentes buffers, Renderizar envolve todo os processamentosgráficos necessários para chegar a imagem final desejada, isso pode envolver inúmeros blittings e processamentos de finalidadegráfica necessários.

O Renderer está atrelado a uma Window e só pode renderizar a ela.

Vamos ver alguns metodos que darão uma compreensão melhor do que pode ser feito.

SDL_SetRenderDrawColor(renderer, r, g, b, a);

Define a cor que é usada para limpar a tela.

SDL_RenderClear(renderer);

limpa o renderer com a cor que você definiu acima.

SDL_RenderCopy(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Rect* srcrect, SDL_Rect* dstrect)

É um dos métodos mais usados, recebe o renderer, a textura, um retângulo que refine parte da textura para aplicar e um outro retângulo que vai definir se a textura precisa mudar de escala, ser esticada ou comprimida.

SDL_RenderPresent(renderer);

Aplica as alterações para a janela.

encerrando

Espero que esse post ajude a esclarecer pessoas que como eu tinham duvidas sobre as diferenças desses elementos do SDL.

Go Maps

Wed, 31 Mar 2021 22:32:55 -0300

Maps são coleções de chave/valor, permitindo você iterar da mesma forma que você faria com arrays ou slices, porém,por ser coleções não ordenadas, não há como prever a ordem que você receberá os dados. Mesmo se você adicionar os dados em uma certa ordem, não há garantia de tal ordem na hora de resgatar esses dados.

Maps são implementados usando tabela Hash. Não vou entrar em detalhes sobre como funciona uma tabela hash, mas é interessante você saberque para armazenar chave/valor acaba sendo muito mais performático usar uma tabela Hash que armazenar em array usando registros de memória ordenados. Isso porque quando você passar a chave pedindo o valor, será executado uma hash function que recebe a chave e retornará onde está armazenado o registro, isso acontece geralmente em milissegundos em razão O(1).

Criando Maps

Há duas formas de criar maps:

Criando um map de chave string e valor int

dict := make(map[string]int)

Criando um map de chave string e valor string

dictStocks := map[string]string{"tesla": "TSLA", "gamestop": "GME"}

Adicionando um novo elemento ao Map

dictStocks["amazon"] = "AMZN"

Nil maps

Você pode declarar um nil map, mas ao tentar atribuir um novo elemento resultará em Runtime Error.

var myDict map[string]stringmyDict["key"] = "value"

panic: assignment to entry in nil map

Verificando chaves

Verificar se uma chave existe faz parte de trabalhar com maps.

Quando solicitamos um valor de uma chave map temos duas opções, receber o valor e uma flag que indica se a chave existe:

dict := make(map[string]string)valor, existe = dict["chave"]

Nesse exemplo, como declaramos um mapa de chave string e valor string, caso a chave não exista, a variável valor receberá uma string zerada, ou seja uma string vazia “", e existe receberá false. Se o map fosse de valor tipo int, a variável valor receberia 0.

Iterando maps

Iterar em maps é muito semelhante a iterar em slices ou arrays usando range, exceto que não iremos receber índice e valor e sim chave e valor.

stocks := map[string]string{"taesa": "taee11", "unipar": "UNIP6"}for chave, valor := range(stocks){    ...}

Deletando um item do map

Para deletar uma chave é bem simples:

delete(meuMapa, "chave")

Alterando um map passado como argumento em uma função

Um map passado por um argumento em uma função não cria uma cópia, mantendo a referencia ao map original. Ao realizar uma alteração no map, todas as referencias serão atualizadas.

func deleteMapItem(meuMap map[string]string, indice string){delete(meuMap, indice)}func main() {stocks := map[string]string{"taesa": "taee11", "unipar": "UNIP6"}deleteMapItem(stocks, "taesa")for chave, valor := range(stocks){        fmt.Printf("%s, %s", chave, valor)}}

Resultado:

unipar, UNIP6

Porque gosto tanto da linguagem GO

Sat, 27 Mar 2021 16:52:04 -0300

Rápida performance

Go é compilado, isso significa que o código é convertido em código de maquina,onde o processador pode consumir sem ter que interpretar um script.

Isso faz com que Go seja uma linguagem rápida, podemos colocar o Go entre C++ e Javaem termos de velocidade, batendo Java em quase todos os benchmarks.

Compilação rápida = rápido Feedback de desenvolvimento

Falando do tempo de compilação do código, Go tem uma compilação extremamente rápida,e essa é uma grande vantagem em relação a Java e C++, você mal vai perceber queo código foi compilado de tão rápido. Isso faz muita diferença no dia a dia que vocêquer testar seu código inúmeras vezes ao dia.

Baixa complexidade

Programadores migram fácilmente de outras linguagem para Go, é fácil de ler e produzir,os criadores do Go procuraram manter a simplicidade na linguagem.

veja um exemplo:

package mainimport ( "fmt" "time")func hello() { fmt.Println("Hello world goroutine")}func main() { go hello() time.Sleep(1 * time.Second) fmt.Println("main function")}

Portabilidade

Go tem poucas dependências e cria binários facilmente para práticamente qualquer sistema operacional.A grande vantagem de ser compilável é que as dependências são resolvidas durante a compilação e nãodurante a interpretação, ou seja, você não precisa ficar resolvendo dependências para cada máquina que for rodar a aplicação.Se você está escrevendo uma aplicação para usuários finais é muito conveniente, você faz o build e os usuários apenas precisam o executar.

Aqui vai um exemplo de como compilar um binário para windows usando linux.

primeiro você define algumas variáveis de ambiente e depois chama o comando de build:

GOOS=windows GOARCH=386 go build -o hello.exe hello.go

fácil, não ?

Feito para usar concorrência

Go é feito nativamente para usar concorrências de forma eficiente e abstraída, você cria goroutinese o Go se encarrega em alocar elas em threads e gerênciar possíveis conflitos de concorrências entreelas. Isso permite a desenvolvedores com pouca experiência aproveitar as arquiteturas atuais de váriosnúcleos de processamento.

Veja esse simples exemplo

Pouco Verboso

Apesar de ser sim verboso comparado a python, linguagens compiladas costumam ser verbosas,mas é Go muito menos verboso que C++, C# ou Java.

Garbage Collector

Go tem um ótimo garbage Collector. Go consome pouquíssima memória

Resumindo

Alta performance
Compilação rápida
Facilidade de gerenciamento de concorrências e memórias
Baixo consumo de memória
Sintaxe simples

Acredito que tais qualidades trouxeram Go para para o ranking das linguagens mais amadas e desejadas como podemos ver nos Surveys do stackoverflow dos últimos. Para mim GO não é Hype, é uma linguagem moderna que veio para ficar.