iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-05-05 14:28:31 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fixes the texts which were exceeding 80 collumns

Browse Source
This commit is contained in:
Kemel Zaidan 2022-10-27 17:10:12 -03:00
parent 6574a37279
commit 6e3ca550f9
1 changed files with 83 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
pt-br/processing-pt.html.markdown
View File

@ -12,11 +12,12 @@ lang: pt-br
## Introdução ## Introdução
Processing é uma linguagem de programação para criação de artes digitais e Processing é uma linguagem de programação para criação de artes digitais e
conteúdo multimídia, permitindo que não programadores aprendam os fundamentos da conteúdo multimídia, permitindo que não programadores aprendam os fundamentos
programação computacional em um contexto visual. da programação computacional em um contexto visual.
Embora a linguagem seja baseada na linguagem Java, sua sintaxe foi amplamente Embora a linguagem seja baseada na linguagem Java, sua sintaxe foi amplamente
influenciado por ambas as sintaxes Java e Javascript. [Veja mais aqui](https://processing.org/reference/) influenciado por ambas as sintaxes Java e Javascript.
[Veja mais aqui](https://processing.org/reference/)
A linguagem é tipada estaticamente e também vem com a sua IDE oficial para A linguagem é tipada estaticamente e também vem com a sua IDE oficial para
compilar e executar os scripts. compilar e executar os scripts.
@ -31,7 +32,8 @@ compilar e executar os scripts.
/* /*
Como o Processing é baseado em Java, Como o Processing é baseado em Java,
a sintaxe para seus comentários é a mesma do Java (como você deve ter notado acima)! a sintaxe para seus comentários é a mesma do Java (como você deve ter notado
acima)!
Comentários de várias linhas são agrupados como visto aqui. Comentários de várias linhas são agrupados como visto aqui.
*/ */
@ -40,25 +42,26 @@ compilar e executar os scripts.
--------------------------------------- ---------------------------------------
*/ */
// No Processing, o ponto de entrada do programa é uma função chamada setup() com um // No Processing, o ponto de entrada do programa é uma função chamada setup()
// tipo de retorno void. // com um tipo de retorno void.
// Observação! A sintaxe é muito semelhante à do C++. // Observação! A sintaxe é muito semelhante à do C++.
void setup() { void setup() {
// Isso imprime a saída clássica "Hello World!" para o console quando executado. // Isso imprime a saída clássica "Hello World!" no console quando executado.
println("Olá Mundo!"); // Outra linguagem com cilada para ponto e vírgula, não é? println("Olá Mundo!"); // Outra linguagem cilada para ponto e vírgula, não é?
} }
// Normalmente, colocamos todos os códigos estáticos dentro do método setup() como o próprio nome // Normalmente, colocamos todos os códigos estáticos dentro do método setup()
// sugere, uma vez que é executado apenas uma vez. // como o próprio nome sugere, uma vez que é executado apenas uma vez.
// Pode variar da definição das cores de fundo, ou o tamanho da tela. // Pode variar da definição das cores de fundo, ou o tamanho da tela.
background(color); //define a cor do fundo background(color); //define a cor do fundo
size(largura,altura,[renderizador]); // define o tamanho da tela com parâmetro size(largura,altura,[renderizador]); // define o tamanho da tela com parâmetro
// opcional para definir o renderizador // opcional para definir o renderizador
// Você verá mais sobre isso ao longo deste documento. // Você verá mais sobre isso ao longo deste documento.
// Se você deseja executar os códigos indefinidamente, eles devem ser colocados dentro do método draw() // Se você deseja executar os códigos indefinidamente, eles devem ser colocados
// draw() deve existir caso você queira que o código seja executado continuamente e, obviamente, // dentro do método draw()
// só pode haver um método draw(). // draw() deve existir caso você queira que o código seja executado
// continuamente e, obviamente, só pode haver um método draw().
int = 0; int = 0;
void draw(){ void draw(){
// Este bloco de código faz um loop para sempre até parar // Este bloco de código faz um loop para sempre até parar
@ -92,40 +95,43 @@ double valorDouble = 1,12345D; // Double (números de ponto flutuante de 64 bits
// NOTA! // NOTA!
// Embora os tipos de dados "long" e "double" funcionem na linguagem, // Embora os tipos de dados "long" e "double" funcionem na linguagem,
// funções do Processing não usam esses tipos de dados, portanto // funções do Processing não usam esses tipos de dados, portanto
// eles precisam ser convertidos em tipos de dados "int" e "float", respectivamente, // eles precisam ser convertidos em tipos de dados "int" e "float",
// usando a sintaxe (int) e (float) antes de passar para uma função. // respectivamente, usando a sintaxe (int) e (float) antes de passar para uma
// função.
// Existem vários tipos de dados compostos que estão disponíveis por padrão para uso // Existem vários tipos de dados compostos que estão disponíveis por padrão para
// no Processing. // uso no Processing.
// Primeiramente, farei um resumo dos mais usados ​​para economizar tempo. // Primeiramente, farei um resumo dos mais usados ​​para economizar tempo.
// String // String
// Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas duplas. // Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas
// duplas.
string stringExemplo = "Olá, Processing!"; string stringExemplo = "Olá, Processing!";
// String também pode ser construída a partir de um array de tipos de dados char. Nós vamos // String também pode ser criada a partir de um array de tipos de dados char.
// discutir array muito em breve. // Nós vamos discutir array muito em breve.
char fonte = {'H', 'E', 'L', 'L', 'O'}; char fonte = {'H', 'E', 'L', 'L', 'O'};
String stringDeFonte = new String(source); // HELLO String stringDeFonte = new String(source); // HELLO
// Como em Java, strings podem ser concatenadas usando o operador "+". // Como em Java, strings podem ser concatenadas usando o operador "+".
print("Olá " + "Mundo!"); // Olá Mundo! print("Olá " + "Mundo!"); // Olá Mundo!
// Array // Array
// Arrays em Processing podem conter quaisquer tipos de dados, incluindo os próprios objetos. // Arrays em Processing podem conter quaisquer tipos de dados, incluindo os
// Como os arrays são semelhantes aos objetos, eles devem ser criados com a palavra-chave // próprios objetos. Como os arrays são semelhantes aos objetos, eles devem
// "new". // ser criados com a palavra-chave "new".
int[] arrayInt = new int[5]; int[] arrayInt = new int[5];
int[] arrayIntComValores ​​= {1, 2, 3}; // Você também pode preencher com dados. int[] arrayIntComValores ​​= {1, 2, 3}; // Você também pode preencher com dados.
// Lista de Arrays // Lista de Arrays
// As funções são semelhantes às do array; arraylists podem conter qualquer tipo de dados. // As funções são semelhantes às do array; arraylists podem conter qualquer
// A única diferença é que as listas de matrizes são redimensionadas dinamicamente, pois é uma forma de // tipo de dados. A única diferença é que as listas de matrizes são
// implementação de matriz redimensionável da interface "List" do Java . // redimensionadas dinamicamente, pois é uma forma de implementação de matriz
// redimensionável da interface "List" do Java .
ArrayList<Integer> intArrayList = new ArrayList<Integer>(); ArrayList<Integer> intArrayList = new ArrayList<Integer>();
// Objeto // Objeto
// Como é baseado em Java, o Processing suporta programação orientada a objetos. // Como é baseado em Java, o Processing suporta programação orientada a objetos.
// Isso significa que você pode basicamente definir quaisquer tipos de dados de sua preferência e manipulá-los // Isso significa que você pode basicamente definir quaisquer tipos de dados de
// para suas necessidades. // sua preferência e manipulá-los para suas necessidades.
// Claro, uma classe tem que ser definida antes para o objeto que você quer. // Claro, uma classe tem que ser definida antes para o objeto que você quer.
// Formato --> NomeClasse NameInstancia // Formato --> NomeClasse NameInstancia
UmaClasseQualquer meuObjeto // então instancia mais tarde UmaClasseQualquer meuObjeto // então instancia mais tarde
@ -133,7 +139,7 @@ UmaClasseQualquer meuObjeto // então instancia mais tarde
UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer(); UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer();
// O Processing surge com mais coleções (ex. - Dicionários e Listas) por // O Processing surge com mais coleções (ex. - Dicionários e Listas) por
// padrão, por uma questão de simplicidade, vou deixá-los fora de discussão aqui. // padrão, por uma questão de simplicidade, vou deixá-los fora da discussão aqui.
/* ------------ /* ------------
Matemática Matemática
@ -148,7 +154,8 @@ UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer();
3.0 / 2 // 1.5 3.0 / 2 // 1.5
3.0% 2 // 1.0 3.0% 2 // 1.0
// O Processing também vem com um conjunto de funções que simplificam operações matemáticas. // O Processing também vem com um conjunto de funções que simplificam operações
// matemáticas.
float f = sq(3); // f = 9.0 float f = sq(3); // f = 9.0
float p = pow(3, 3); // p = 27.0 float p = pow(3, 3); // p = 27.0
int a = abs(-13); // a = 13 int a = abs(-13); // a = 13
@ -160,18 +167,18 @@ float sr = sqrt(25); // sr = 5.0
// O Processing fornece uma maneira fácil de implementar vetores em seu ambiente // O Processing fornece uma maneira fácil de implementar vetores em seu ambiente
// usando a classe PVector. Ela pode descrever um vetor bi ou tridimensional e // usando a classe PVector. Ela pode descrever um vetor bi ou tridimensional e
// vem com um conjunto de métodos que são úteis para operações com matrizes. // vem com um conjunto de métodos que são úteis para operações com matrizes.
// Você pode encontrar mais informações sobre a classe PVector e suas funções aqui. // Você pode encontrar mais informações sobre a classe PVector e suas funções
// (https://processing.org/reference/PVector.html) // aqui. (https://processing.org/reference/PVector.html)
// Trigonometria // Trigonometria
// O processamento também suporta operações trigonométricas fornecendo um conjunto de // O processamento também suporta operações trigonométricas fornecendo um
// funções. sin(), cos(), tan(), asin(), acos(), atan() e também degrees() // conjunto de funções. sin(), cos(), tan(), asin(), acos(), atan() e também
// e radians() para conversão conveniente. // degrees() e radians() para conversão conveniente.
// No entanto, essas funções usam o ângulo em radianos como parâmetro, então é necessário // No entanto, essas funções usam o ângulo em radianos como parâmetro, então é
// converter previamente. // necessário converter previamente.
float um = sin(PI/2); // um = 1.0 float um = sin(PI/2); // um = 1.0
// Como você deve ter notado, existe um conjunto de constantes para usos trigonométricos; // Como você deve ter notado, existe um conjunto de constantes para usos
// PI, HALF_PI, QUARTER_PI e assim por diante... // trigonométricos; PI, HALF_PI, QUARTER_PI e assim por diante...
/* ------------- /* -------------
Controle de fluxo Controle de fluxo
@ -190,9 +197,10 @@ if (author.getAppearance().equals("quente")) {
int = 3; int = 3;
String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena" String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
// A estrutura switch-case pode ser usada para verificar várias condições de forma concisa. // A estrutura switch-case pode ser usada para verificar várias condições de
// É importante usar a instrução break. Se a instrução `break` // forma concisa. É importante usar a instrução break. Se a instrução `break`
// não existe o programa executa todos os casos a seguir após um caso ser verdadeiro. // não existe o programa executa todos os casos a seguir após um caso ser
// verdadeiro.
int valor = 2; int valor = 2;
switch(valor) { switch(valor) {
case 0: case 0:
@ -215,7 +223,8 @@ for(int i = 0; i < 5; i++){
print(i); // imprime de 0 a 4 print(i); // imprime de 0 a 4
} }
// Declarações While - Novamente, nada de novo se você estiver familiarizado com a sintaxe Java. // Declarações While - Novamente, nada de novo se você estiver familiarizado com
// a sintaxe Java.
int j = 3; int j = 3;
while(j > 0) { while(j > 0) {
print(j); print(j);
@ -223,7 +232,8 @@ while(j > 0) {
} }
// loop()| noLoop() | redraw() | exit() // loop()| noLoop() | redraw() | exit()
// Estas são mais funções específicas do Processing para configurar o fluxo do programa. // Estas são mais funções específicas do Processing para configurar o fluxo do
// programa.
loop(); // permite que o método draw() seja executado para sempre enquanto loop(); // permite que o método draw() seja executado para sempre enquanto
noLoop(); // só permite que ele seja executado uma vez. noLoop(); // só permite que ele seja executado uma vez.
redraw(); // executa o método draw() mais uma vez. redraw(); // executa o método draw() mais uma vez.
@ -283,10 +293,10 @@ arc(x, y, largura, altura, inicio, fim, [modo]);
// CHORD porém sem contorno // CHORD porém sem contorno
// Curvas // Curvas
// O processamento fornece duas implementações de curvas; usando curve() e bezier(). // O processamento fornece duas implementações de curvas; usando curve() e
// Como pretendo manter isso simples, não vou discutir mais detalhes. // bezier(). Como pretendo manter isso simples, não vou discutir mais detalhes.
// No entanto, se você quiser implementá-lo em seu sketch, aqui estão as referências: // No entanto, se você quiser implementá-lo em seu sketch, aqui estão as
// (https://processing.org/reference/curve_.html) // referências: (https://processing.org/reference/curve_.html)
// (https://processing.org/reference/bezier_.html) // (https://processing.org/reference/bezier_.html)
// Formas 3D // Formas 3D
@ -300,13 +310,13 @@ size(largura, altura, P3D);
// Caixa // Caixa
box(tamanho); // Cubo com o mesmo comprimento definido pelo tamanho box(tamanho); // Cubo com o mesmo comprimento definido pelo tamanho
caixa(w, h, d); // Caixa com largura, altura e profundidade definidas separadamente box(w, h, d); // Caixa com largura, altura e profundidade definidas separadamente
// Esfera // Esfera
sphere(raio); // Seu tamanho é definido usando o parâmetro raio sphere(raio); // Seu tamanho é definido usando o parâmetro raio
// O mecanismo por trás da renderização das esferas é implementado por triângulos em mosaico. // O mecanismo por trás da renderização das esferas é implementado por
// Dito isso, o nível de detalhe sendo renderizado é controlado pela função // triângulos em mosaico. Dito isso, o nível de detalhe sendo renderizado é
// sphereDetail(res) // controlado pela função sphereDetail(res)
// Mais informações aqui: (https://processing.org/reference/sphereDetail_.html) // Mais informações aqui: (https://processing.org/reference/sphereDetail_.html)
// Formas irregulares // Formas irregulares
@ -323,8 +333,8 @@ sphere(raio); // Seu tamanho é definido usando o parâmetro raio
--------------- ---------------
*/ */
// As transformações são particularmente úteis para acompanhar o espaço de coordenadas // As transformações são particularmente úteis para acompanhar o espaço de
// e os vértices das formas que você desenhou. Particularmente; // coordenadas e os vértices das formas que você desenhou. Particularmente;
// métodos de pilha de matrizes; pushMatrix(), popMatrix() e translate(x,y) // métodos de pilha de matrizes; pushMatrix(), popMatrix() e translate(x,y)
pushMatriz(); // Salva o sistema de coordenadas atual na pilha pushMatriz(); // Salva o sistema de coordenadas atual na pilha
// ... aplique todas as transformações aqui ... // ... aplique todas as transformações aqui ...
@ -338,7 +348,8 @@ translate(x, y, z); // Contraparte 3D da função
// Rotacionar // Rotacionar
rotate(ângulo); // Gira a quantidade especificada pelo parâmetro ângulo rotate(ângulo); // Gira a quantidade especificada pelo parâmetro ângulo
// Possui 3 contrapartes 3D para realizar a rotação, uma para cada dimensão: rotateX(ângulo), rotateY(ângulo), rotateZ(ângulo) // Possui 3 contrapartes 3D para realizar a rotação, uma para cada dimensão:
// rotateX(ângulo), rotateY(ângulo), rotateZ(ângulo)
// Escala // Escala
scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o. scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o.
@ -349,17 +360,17 @@ scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o.
*/ */
// Cores // Cores
// Como discuti anteriormente, a cor de fundo pode ser configurada usando a função // Como discuti anteriormente, a cor de fundo pode ser configurada usando a
// background(). Você pode definir a cor de um objeto de antemão e depois // função background(). Você pode definir a cor de um objeto de antemão e depois
// passar para a função como um argumento. // passar para a função como um argumento.
color c = cor(255, 255, 255); // BRANCO! color c = cor(255, 255, 255); // BRANCO!
// Por padrão, o Processing usa o esquema de cores RGB, mas pode ser configurado para // Por padrão, o Processing usa o esquema de cores RGB, mas pode ser configurado
// HSB usando colorMode(). Leia mais aqui: // para HSB usando colorMode(). Leia mais aqui:
// (https://processing.org/reference/colorMode_.html) // (https://processing.org/reference/colorMode_.html)
background(c); // Até agora, a cor de fundo deve ser branca. background(c); // Até agora, a cor de fundo deve ser branca.
// Você pode usar a função fill() para selecionar a cor para preencher as formas. // Você pode usar a função fill() para selecionar a cor para preencher as formas.
// Tem que ser configurado antes de você começar a desenhar formas para que as cores fiquem // Tem que ser configurado antes de você começar a desenhar formas para que as
// aplicadas. // cores fiquem aplicadas.
fill(color(0, 0, 0)); fill(color(0, 0, 0));
// Se você quiser apenas colorir os contornos das formas, você pode usar // Se você quiser apenas colorir os contornos das formas, você pode usar
// função stroke(). // função stroke().
@ -367,16 +378,14 @@ stroke(255, 255, 0, 200); // cor do traço definida para amarelo com transparên
// definido para um valor menor. // definido para um valor menor.
// Imagens // Imagens
// O processamento pode renderizar imagens e usá-las de várias maneiras. Principalmente armazenado como // O processamento pode renderizar imagens e usá-las de várias maneiras.
// Tipo de dados PImage. // Principalmente armazenado como Tipo de dados PImage.
filter(sombreador); // O processamento suporta várias funções de filtro para manipulação de imagens. filter(sombreador); // O processamento suporta várias funções de filtro para manipulação de imagens.
texture(imagem); // PImage pode ser passado em argumentos para mapeamento de textura das formas. texture(imagem); // PImage pode ser passado em argumentos para mapeamento de textura das formas.
``` ```
Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer. Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer. Renderizar modelos, shaders e outros efeitos. Há muito para se cobrir em uma
Renderizar modelos, shaders e outros efeitos. Há muito para se cobrir em uma documentação curta, então vou deixá-los aqui. Se você se interessar, por favor verifique as referências.
documentação curta, então vou deixá-los aqui. Se você se interessar,
por favor verifique as referências.
``` ```
// Antes de prosseguirmos, vou falar um pouco mais sobre como importar bibliotecas // Antes de prosseguirmos, vou falar um pouco mais sobre como importar bibliotecas
@ -387,9 +396,10 @@ por favor verifique as referências.
------- -------
*/ */
// As possibilidades do Processing pode ser estendidas ainda mais quando importamos bibliotecas // As possibilidades do Processing pode ser estendidas ainda mais quando
// e pacotes em nossos esboços. // importamos bibliotecas e pacotes em nossos esboços.
// A instrução de importação pode ser escrita como abaixo na parte superior do código-fonte. // A instrução de importação pode ser escrita como abaixo na parte superior
// do código-fonte.
import processing.algumacoisa.*; import processing.algumacoisa.*;
``` ```
@ -403,9 +413,9 @@ capaz de fazer com poucas linhas de código.
Copie o código abaixo em seu IDE do Processing e veja a mágica. Copie o código abaixo em seu IDE do Processing e veja a mágica.
``` ```
// Isenção de responsabilidade: eu não escrevi este programa porque atualmente estou ocupado com meu // Isenção de responsabilidade: eu não escrevi este programa porque atualmente
// estágio e este sketch é adaptado do openprocessing pois mostra // estou ocupado com meu estágio e este sketch é adaptado do openprocessing pois
// algo legal com um código simples. // mostra algo legal com um código simples.
// Recuperado de: (https://www.openprocessing.org/sketch/559769) // Recuperado de: (https://www.openprocessing.org/sketch/559769)
float theta; float theta;