O bloco de código é um recurso exclusivo no Dynamo que vincula dinamicamente um ambiente de programação visual com um baseado em texto. O bloco de código tem acesso a todos os nós do Dynamo e pode definir um gráfico completo em um nó. Leia este capítulo com atenção, já que o bloco de código é um bloco de construção fundamental do Dynamo.
As funções podem ser criadas em um Code Block e chamadas em outro lugar da definição do Dynamo. Isto cria outra camada de controle em um arquivo paramétrico e pode ser visualizado como uma versão com base em texto de um nó personalizado. Neste caso, o Code Block "principal" é facilmente acessível e pode ser localizado em qualquer lugar do gráfico. Não é necessário fio!
A primeira linha tem a palavra-chave "def", depois o nome da função e, a seguir, os nomes das entradas entre parênteses. Os contraventamentos definem o corpo da função. Retorne um valor com "return =". Os Blocos de código que definem uma função não possuem portas de entrada ou saída porque eles são chamados de outros Blocos de código.
Chame a função com outro Code Block no mesmo arquivo fornecendo o mesmo nome e o mesmo número de argumentos. Funciona da mesma forma que os nós prontos para uso da sua biblioteca.
Faça o download do arquivo de exemplo clicando no link abaixo.
É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.
Neste exercício, vamos criar uma definição genérica que irá criar esferas a partir de uma lista de entrada de pontos. O raio dessas esferas é conduzido pela propriedade Z de cada ponto.
Vamos começar com um intervalo de números de dez valores , de 0 a 100. Conecte-os a um nó Point.ByCoordinates para criar uma linha diagonal.
Crie um Bloco de código e insira a nossa definição.
Use estas linhas de código:
O inputPt é o nome que atribuímos para representar os pontos que guiarão a função. Por agora, a função não está fazendo nada, mas vamos desenvolver essa função nas etapas a seguir.
Quando a função Bloco de código é adicionada, colocamos um comentário e uma variável sphereRadius que consulta a posição Z de cada ponto. Lembre-se de que inputPt.Z não precisa de parênteses como um método. Essa é uma consulta das propriedades de um elemento existente; portanto, nenhuma entrada é necessária:
Agora, vamos recordar a função que criamos em outro Bloco de código. Se clicarmos duas vezes na tela para criar um novo bloco de código e digitarmos sphereB, notamos que o Dynamo sugere a função sphereByZ que foi definida. A função foi adicionada à biblioteca intellisense. Muito legal.
Agora, chamamos a função e criamos uma variável chamada Pt para conectar os pontos criados nas etapas anteriores:
Observe que, na saída, temos todos os valores nulos. Por que isso ocorre? Quando definimos a função, estamos calculando a variável sphereRadius, mas não definimos o que a função deve ser retornada como uma saída. Podemos corrigir isso na próxima etapa.
Uma etapa importante: é necessário definir a saída da função adicionando a linha
return = sphereRadius;à função sphereByZ.Agora, vemos que a saída do Bloco de código nos fornece as coordenadas Z de cada ponto.
Agora, vamos criar esferas reais editando a função Principal.
Primeiro definimos uma esfera com a linha de código:
sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);Em seguida, alteramos o valor de retorno para sphere em vez de sphereRadius:
return = sphere;Isso nos fornece algumas esferas gigantes em nossa visualização do Dynamo.
1. Para reduzir o tamanho dessas esferas, vamos atualizar o valor sphereRadius adicionando um divisor:
sphereRadius = inputPt.Z/20;Agora podemos ver as esferas separadas e começar a entender a relação entre o raio e o valor Z.
No nó Point.ByCoordinates, alterando a amarra de Lista mais curta para Produto transversal, criamos uma grade de pontos. A função sphereByZ ainda está em pleno efeito, de modo que todos os pontos criam esferas com raios com base em valores Z.
E apenas para efeitos de teste, conectamos a lista original de números à entrada X para Point.ByCoordinates. Agora temos um cubo de esferas.
Observação: Se isso levar muito tempo para ser calculado no computador, tente alterar #10 para algo como #5.
Lembre-se: A função sphereByZ que foi criada é uma função genérica, para que possamos recuperar a hélice de uma lição anterior e aplicar a função a ela.
Uma etapa final: vamos conduzir a relação do raio com um parâmetro definido pelo usuário. Para fazer isso, é necessário criar uma nova entrada para a função e também substituir o divisor 20 por um parâmetro.
Atualize a definição de sphereByZ para:
Atualize o Bloco de código secundário adicionando uma variável de relação à entrada:
sphereByZ(Pt,ratio);Conecte um controle deslizante à entrada do Bloco de código recém-criado e varie o tamanho dos raios com base na relação de raio.
Os blocos de código são uma janela localizada no DesignScript, a linguagem de programação principal do Dynamo. Desenvolvido do zero para suportar fluxos de trabalho de projeto exploratório, o DesignScript é uma linguagem legível e concisa que oferece comentários imediatos a pequenos bits de código e também é dimensionado para interações grandes e complexas. O DesignScript também forma a espinha dorsal do mecanismo que motiva a maioria dos aspectos do Dynamo “essenciais”. Como quase todas as funções encontradas nos nós e nas interações do Dynamo têm uma relação estreita com a linguagem de scripts, há oportunidades únicas para alternar o uso entre as interações baseadas em nós e os scripts de uma forma fluida.
Para iniciantes, os nós podem ser convertidos automaticamente em sintaxe de texto para ajudar a aprender o DesignScript ou simplesmente para reduzir o tamanho de seções maiores de gráficos. Isso é feito usando um processo denominado “Nó para código”, que é descrito com mais detalhes na seção Sintaxe do DesignScript. Os usuários mais experientes podem usar os blocos de código para criar mashups personalizados de relacionamentos existentes de usuários e funcionalidades, usando muitos paradigmas de codificação padrão. Entre o usuário iniciante e o avançado, há um grande número de atalhos e fragmentos de código que aceleram seus projetos. Embora o termo “bloco de código” possa ser um pouco intimidador para não programadores, é fácil de usar e robusto. Um iniciante pode usar o bloco de código de forma eficiente com codificação mínima, e um usuário avançado pode definir definições de script para serem chamadas em outro lugar em uma definição do Dynamo.
Em resumo, os blocos de código são uma interface de scripts de texto em um ambiente de scripts visuais. Eles podem ser usados como números, sequências de caracteres, fórmulas e outros tipos de dados. O bloco de código é projetado para o Dynamo, portanto, é possível definir variáveis arbitrárias no bloco de código, e essas variáveis são automaticamente adicionadas às entradas do nó:
Com os blocos de código, um usuário tem a flexibilidade de decidir como especificar as entradas. Confira a seguir várias maneiras de criar um ponto básico com coordenadas (10, 5, 0):
À medida que você aprende mais sobre as funções disponíveis na biblioteca, lembre-se de que digitar “Point.ByCoordinates” é mais rápido do que pesquisar na biblioteca e localizar o nó apropriado. Quando você digita “Point.”, por exemplo, o Dynamo exibirá uma lista de possíveis funções para aplicar a um ponto. Isso torna o script mais intuitivo e ajudará no processo de aprendizagem de como aplicar funções no Dynamo.
O bloco de código pode ser encontrado em Core>Input>Actions>Code Block. Mas existe um modo mais rápido: basta clicar duas vezes na tela e o bloco de código aparece. Esse nó é usado com tanta frequência que recebeu o privilégio de ser acionado com duplo clique.
Os blocos de código também são flexíveis em relação aos tipos de dados. O usuário pode definir rapidamente os números, as sequências e as fórmulas, e o bloco de código fornecerá o resultado desejado.
Na imagem abaixo, é possível ver que a forma de fazer as coisas “à moda antiga” é um pouco demorada: o usuário procura o nó desejado na interface, adiciona o nó à tela e insere os dados. Com o bloco de código, o usuário pode clicar duas vezes na tela para abrir o nó e digitar o tipo de dados correto com sintaxe básica.
Os nós número, sequência de caracteres e fórmula são três exemplos de nós do Dynamo que são provavelmente obsoletos em comparação ao bloco de código.
“Tradicional”
Blocos de código
Existem alguns métodos de abreviação básicos no bloco de código que, em termos simples, facilitam muito o gerenciamento de dados. Vamos explicar os conceitos básicos abaixo e discutir como a abreviação pode ser usada para criar e consultar dados.
É possível reduzir o método para definir intervalos e sequências para a abreviação básica. Use a imagem abaixo como um guia para a sintaxe “...” para definir uma lista de dados numéricos com o bloco de código. Após obter o travamento dessa notação, a criação de dados numéricos é um processo realmente eficiente:
Neste exemplo, um intervalo de números é substituído pela sintaxe básica do Bloco de código que define
beginning..end..step-size;. Representados numericamente, temos:0..10..1;Observe que a sintaxe
0..10..1;é equivalente a0..10;Um tamanho de etapa de 1 é o valor padrão para a notação abreviada. Assim,0..10;será fornecida uma sequência de 0 a 10 com um tamanho de etapa de 1.O exemplo de Sequência é semelhante, exceto se usarmos “#” para indicar que desejamos 15 valores na lista em vez de uma lista que vai até 15. Neste caso, estamos definindo:
beginning..#ofSteps..step-size:A sintaxe real para a sequência é0..#15..2Usando o símbolo “#” da etapa anterior, agora o colocamos na parte “step-size” da sintaxe. Agora, temos um intervalo de números que se estende de “beginning” até “end”, e a notação “step-size” distribui uniformemente alguns valores entre os dois:
beginning..end..#ofSteps
A criação de intervalos avançados nos permite trabalhar com uma lista de listas de forma simples. Nos exemplos abaixo, vamos isolar uma variável da notação do intervalo principal e criar outro intervalo dessa lista.
1. Criando intervalos aninhados, compare a notação com “#” e a notação sem. A mesma lógica se aplica a intervalos básicos, exceto pelo fato de que fica um pouco mais complexo.
2. Podemos definir um subintervalo em qualquer lugar dentro do intervalo principal e observar que também podemos ter dois subintervalos.
3. Controlando o valor “end” em um intervalo, criamos mais intervalos de comprimentos diferentes.
Como um exercício lógico, compare as duas abreviações acima e tente analisar como os subintervalos e a notação # controlam a saída resultante.
Além de criar listas com abreviações, podemos criar listas imediatamente. Essas listas podem conter um amplo intervalo de tipos de elementos e também podem ser consultadas (lembre-se: as próprias listas são objetos). Para resumir, com o bloco de código você faz listas e consulta itens de uma lista com colchetes :
1. Crie listas rapidamente com sequências de caracteres e consulte-as usando o índice do item.
2. Crie listas com variáveis e consulte usando a notação de abreviação de intervalo.
O gerenciamento com listas aninhadas é um processo semelhante. Esteja ciente da ordem da lista e chame de volta usando vários conjuntos de colchetes:
1. Defina uma lista de listas.
2. Consulte uma lista com uma notação de colchete único.
3. Consulte um item com uma notação de colchete duplo.
Faça o download do arquivo de exemplo clicando no link abaixo.
É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.
Neste exercício, flexibilizaremos nossas novas habilidades de abreviação para criar uma superfície de casca de ovo moderna definida por intervalos e fórmulas. Durante este exercício, observe como usamos o bloco de código e os nós do Dynamo existentes em conjunto: usamos o bloco de código para o levantamento de dados pesados enquanto os nós do Dynamo são visualmente dispostos para a legibilidade da definição.
Comece criando uma superfície conectando os nós acima. Em vez de usar um nó de número para definir a largura e o comprimento, clique duas vezes na tela e digite 100; em um bloco de código
Defina um intervalo entre 0 e 1 com 50 divisões digitando
0..1..#50em um Bloco de código.Conecte o intervalo a Surface.PointAtParameter, que usa os valores u e v entre 0 e 1 na superfície. Lembre-se de alterar a Amarra para Produto transversal clicando com o botão direito do mouse no nó Surface.PointAtParameter.
Nesta etapa, empregamos nossa primeira função para mover o eixo de pontos para cima no Z. Esse eixo controlará uma superfície gerada com base na função subjacente. Adicione novos nós, como mostrado na imagem abaixo
Em vez de usar um nó de fórmula, usamos um Bloco de código com a linha:
(0..Math.Sin(x*360)..#50)*5;. Para analisar isso rapidamente, definimos um intervalo com uma fórmula dentro dele. Essa fórmula é a função Seno. A função seno recebe entradas de grau no Dynamo, portanto, para obter uma onda senoidal completa, multiplicamos nossos valores de x (essa é a entrada de intervalo de 0 a 1) por 360. Em seguida, queremos o mesmo número de divisões que os pontos de eixo de controle para cada linha, portanto, definimos cinquenta subdivisões com #50. Finalmente, o multiplicador de 5 simplesmente aumenta a amplitude da conversão para que possamos ver o efeito na Visualização do Dynamo.
Apesar de o Bloco de código anterior funcionar bem, não era completamente paramétrico. Queremos controlar os parâmetros dinamicamente; portanto, substituiremos a linha da etapa anterior por
(0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;. Isso nos oferece a capacidade de definir esses valores com base nas entradas.
Alterando os controles deslizantes (de 0 a 10), obtemos resultados interessantes.
Efetuando uma transposição no intervalo de números, inverteremos a direção da onda da cortina:
transposeList = List.Transpose(sineList);
Obtemos uma superfície de casca de ovo distorcida quando adicionamos sineList e tranposeList:
eggShellList = sineList+transposeList;
Vamos alterar os valores dos controles deslizantes especificados abaixo para “acalmar as águas” deste algoritmo.
Por último, vamos consultar partes isoladas dos dados com o bloco de código. Para regenerar a superfície com um intervalo específico de pontos, adicione o bloco de código acima entre os nós Geometry.Translate e NurbsSurface.ByPoints. Isso tem a linha de texto: sineStrips[0..15..1];. Isso selecionará as primeiras 16 linhas de pontos (de 50). Recriando a superfície, podemos ver que geramos uma parte isolada do eixo de pontos.
Na etapa final, para tornar esse Bloco de código mais paramétrico, controlaremos a consulta usando um controle deslizante que varia entre 0 e 1. Fazemos isso com esta linha de código:
sineStrips[0..((List.Count(sineStrips)-1)*u)];. Isso pode parecer confuso, mas a linha de código nos fornece uma forma rápida de dimensionar o comprimento da lista em um multiplicador entre 0 e 1.
Um valor de 0.53 no controle deslizante cria uma superfície logo após o ponto central do eixo.
E, conforme esperado, um controle deslizante de 1 cria uma superfície com base no eixo completo de pontos.
Analisando o gráfico visual, podemos realçar os blocos de código e ver cada uma de suas funções.
1. O primeiro Bloco de código substitui o nó Número.
2. O segundo Bloco de código substitui o nó Intervalo de números.
3. O terceiro Bloco de código substitui o nó Fórmula (assim como List.Transpose, List.Count e Intervalo de números).
4. O quarto Bloco de código consulta uma lista de listas, substituindo o nó List.GetItemAtIndex.
Tipo de dados | Dynamo padrão | Equivalente ao bloco de código |
Números |
Sequências de caracteres |
Sequências |
Intervalos |
Obter item no índice |
Criar lista |
Concatenar sequências de caracteres |
Declarações condicionais |
Nó(s) | Equivalente ao bloco de código | Nota |
Qualquer operador (+, &&, >=, Not, etc.) | +, &&, >=, !, etc. | Observe que “Not” se torna “!”, mas o nó é chamado “Not” para distinguir de “Factorial” |
Booleano true | true; | Repare nas minúsculas |
Booleano false | false; | Repare nas minúsculas |
Você pode ter notado um tema comum nos nomes dos nós no Dynamo: cada nó usa uma sintaxe de “.” sem espaços. Isso ocorre porque o texto na parte superior de cada nó representa a sintaxe real dos scripts, e “.” (ou notação de ponto) separa um elemento dos métodos possíveis que podemos chamar. Isso cria uma conversão fácil de scripts visuais em scripts baseados em texto.
Como uma analogia geral da notação de ponto, como podemos lidar com uma maçã paramétrica no Dynamo? Abaixo estão alguns métodos que iremos executar na maçã antes de decidir comê-la. (Observação: Estes não são métodos reais do Dynamo):
| Humanamente legível | Notação de ponto | Saída |
|---|---|---|
Não sei o que você acha, mas com base nos resultados da tabela acima, parece uma maçã saborosa. Acho que vou nomeá-la Apple.eat().
Com a analogia da maçã em mente, vamos examinar Point.ByCoordinates e mostrar como podemos criar um ponto usando o bloco de código.
A sintaxe do bloco de código Point.ByCoordinates(0,10); fornece o mesmo resultado que um nó Point.ByCoordinates no Dynamo, exceto que podemos criar um ponto usando um nó. Isso é mais eficiente do que fazer a conexão com um nó separado em “X” e “Y”.
Usando Point.ByCoordinates no bloco de código, estamos especificando as entradas na mesma ordem que o nó pronto para uso (X,Y).
É possível chamar qualquer nó normal na biblioteca através de um bloco de código, desde que o nó não seja um nó da “IU” especial: aqueles com um recurso especial da interface do usuário. Por exemplo, é possível chamar Circle.ByCenterPointRadius, mas não faria muito sentido chamar um nó Watch 3D.
Os nós normais (a maioria da biblioteca) geralmente são de três tipos. Você verá que a biblioteca está organizada tendo em mente essas categorias. Os métodos ou nós desses três tipos são tratados de forma diferente quando executados dentro de um bloco de código.
Criar – Cria (ou constrói) algo
Ação – Realiza uma ação sobre algo
Consulta – Obtém uma propriedade de algo que já existe
A categoria “Criar” construirá a geometria do zero. Inserimos valores no bloco de código da esquerda para a direita. Essas entradas estão na mesma ordem que as entradas no nó de cima para baixo.
Comparando o nó Line.ByStartPointEndPoint e a sintaxe correspondente no bloco de código, obtemos os mesmos resultados.
Uma ação é algo que você faz em relação a um objeto desse tipo. O Dynamo usa a notação de ponto, comum a muitas linguagens de codificação, para aplicar uma ação a um item. Uma vez que você tenha o item, digite um ponto e, em seguida, o nome da ação. A entrada do método do tipo de ação é colocada entre parênteses como acontece nos métodos do tipo de criação, com a diferença de não ser necessário especificar a primeira entrada que você vê no nó correspondente. Em vez disso, especificamos o elemento no qual estamos executando a ação:
O nó Point.Add é um nó de tipo de ação, de modo que a sintaxe funciona de forma um pouco diferente.
As entradas são (1) o ponto e (2) o vetor a ser adicionado. Em um Bloco de código, nomeamos o ponto (o item) “pt”. Para adicionar um vetor chamado *“vec” * a “pt”, podemos escrever pt.Add(vec) ou: item, ponto, ação. A ação Adicionar tem somente uma entrada ou todas as entradas do nó Point.Add, menos a primeira. A primeira entrada do nó Point.Add é o ponto em si.
Os métodos de tipo consulta obtêm uma propriedade de um objeto. Como o próprio objeto é a entrada, não é necessário especificar nenhuma entrada. Nenhum parêntese é necessário.
A amarra com nós é um pouco diferente da amarra com bloco de código. Com nós, o usuário clica com o botão direito do mouse no nó e seleciona a opção de amarra a ser executada. Com o bloco de código, o usuário tem muito mais controle sobre como os dados são estruturados. O método abreviado do bloco de código usa guias de replicação para definir como várias listas unidimensionais devem ser emparelhadas. Os números entre colchetes angulares “<>” definem a hierarquia da lista aninhada resultante: <1>,<2>,<3> etc.
Neste exemplo, usaremos uma abreviação para definir dois intervalos (obtenha mais informações sobre abreviação na seção seguinte deste capítulo). Em resumo,
0..1;é equivalente a{0,1}e-3..-7é equivalente a{-3,-4,-5,-6,-7}. O resultado nos fornece listas de dois valores x e cinco valores y. Se não usarmos guias de replicação com estas listas não coincidentes, obteremos uma lista de dois pontos, que é o comprimento da lista mais curta. Usando guias de replicação, podemos encontrar todas as possíveis combinações de coordenadas 2 e 5 (ou um Produto transversal).Usando a sintaxe Point.ByCoordinates
(x_vals<1>,y_vals<2>);, obtemos duas listas com cinco itens em cada lista.Usando a sintaxe Point.ByCoordinates
(x_vals<2>,y_vals<1>);, obtemos cinco listas com dois itens em cada lista.
Com essa notação, também podemos especificar qual lista será dominante: 2 listas de 5 itens ou 5 listas de 2 itens. No exemplo, alterar a ordem dos guias de replicação resulta em uma lista de linhas de pontos ou em uma lista de colunas de pontos em um eixo.
Embora os métodos de bloco de código acima possam ter algumas informações úteis, há um recurso no Dynamo chamado “Nó para código” que tornará o processo mais fácil. Para usar esse recurso, selecione uma matriz de nós no gráfico do Dynamo, clique com o botão direito do mouse na tela e selecione “Nó para código”. O Dynamo condensa esses nós em um bloco de código, com todas as entradas e saídas. Não só essa é uma ótima ferramenta para a aprendizagem do bloco de código, como também permite que você trabalhe com um gráfico do Dynamo mais eficiente e paramétrico. Concluiremos o exercício abaixo usando “Nó para código”, por isso, continue acompanhando.
Faça o download do arquivo de exemplo clicando no link abaixo.
É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.
Para mostrar as capacidades do bloco de código, vamos converter uma definição de campo atrativo existente em formato de bloco de código. O trabalho com uma definição existente demonstra como o bloco de código se relaciona com os scripts visuais e é útil para aprender a sintaxe do DesignScript.
Comece recriando a definição na imagem acima (ou abrindo o arquivo de amostra).
Observe que a amarra em Point.ByCoordinates foi definida como Produto transversal.
Cada ponto em um eixo é movido para cima na direção Z com base em sua distância até o ponto de referência.
Uma superfície é recriada e espessada, criando uma convexidade na geometria relacionada à distância até o ponto de referência.
Começando do início, vamos definir primeiro o ponto de referência: Point.ByCoordinates
(x,y,0);Usamos a mesma sintaxe Point.ByCoordinates como especificado na parte superior do nó do ponto de referência.As variáveis x e y são inseridas no Bloco de código de forma que possamos atualizá-las dinamicamente com controles deslizantes.
Adicione alguns controles deslizantes às entradas de Bloco de código que variam de -50 a 50. Dessa forma, podemos expandir através do eixo padrão do Dynamo.
Na segunda linha do Bloco de código, definimos uma abreviação para substituir o nó de sequência numérica:
coordsXY = (-50..50..#11);Discutiremos mais sobre isso na próxima seção. Por enquanto, observe que essa abreviação é equivalente ao nó Sequência numérica no script visual.
Agora, queremos criar um eixo de pontos com base na sequência coordsXY. Para fazer isso, queremos usar a sintaxe Point.ByCoordinates, mas também precisamos iniciar um Produto transversal da lista da mesma maneira que fizemos no script visual. Para fazer isso, digitamos a linha:
gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);Os colchetes angulares indicam a referência do produto transversal.Observe no nó Watch3D que temos um eixo de pontos no eixo do Dynamo.
Agora, a parte difícil: queremos mover o eixo de pontos para cima com base na distância deles até o ponto de referência. Primeiro, vamos chamar esse novo conjunto de pontos transPts. E, como uma conversão é uma ação em um elemento existente, em vez de usar
Geometry.Translate..., vamos usargridPts.TranslateLendo o nó real na tela, vemos que há três entradas. A geometria para converter já está declarada porque estamos executando a ação naquele elemento (com gridPts.Translate). As duas entradas restantes serão inseridas entre os parênteses da função: direção e distância.
A direção é muito simples, usamos um
Vector.ZAxis()para mover verticalmente.A distância entre o ponto de referência e cada ponto do eixo ainda precisa ser calculada; portanto, fazemos isso como uma ação para o ponto de referência da mesma maneira:
refPt.DistanceTo(gridPts)A linha final do código fornece os pontos convertidos:
transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));
Agora, temos um eixo de pontos com a estrutura de dados apropriada para criar uma superfície Nurbs. Construímos a superfície usando
srf = NurbsSurface.ByControlPoints(transPts);
E, finalmente, para adicionar alguma profundidade à superfície, construímos um sólido usando
solid = srf.Thicken(5);Neste caso, aumentamos a espessura da superfície 5 unidades no código, mas sempre podemos declará-la como uma variável (chamando-a de espessura, por exemplo) e, em seguida, controlamos esse valor com um controle deslizante.
O recurso “Nó para código” automatiza todo o exercício que acabamos de concluir com o clique de um botão. Isso não só é eficaz para criar definições personalizadas e blocos de código reutilizáveis, também é uma ferramenta realmente útil para saber como criar um script no Dynamo:
Inicie com o script visual existente na etapa 1 do exercício. Selecione todos os nós, clique com o botão direito do mouse na tela e selecione “Nó para código”. É tão simples quanto isso.
O Dynamo automatizou uma versão com base em texto do gráfico visual, incluindo a amarra e outros itens. Teste isso em seus scripts visuais e aproveite ao máximo o recurso de bloco de código.
Qual é a cor da maçã?
Apple.color
vermelho
A maçã está madura?
Apple.isRipe
true
Quanto a maçã pesa?
Apple.weight
170 g
De onde veio a maçã?
Apple.parent
árvore
O que a maçã cria?
Apple.children
sementes
Esta maçã foi cultivada localmente?
Apple.distanceFromOrchard
96 km
