Propriedades de SnakeCase
Última atualização em
10 de abr de 2024
- Guia do usuário do After Effects
- Versões beta
- Introdução
- Espaços de trabalho
- Projetos e composições
- Importação de gravação
- Preparação e importação de imagens estáticas
- Importação do After Effects e do Adobe Premiere Pro
- Importação e interpretação de vídeo e áudio
- Preparo e importação de arquivos de imagem 3D
- Importação e interpretação de itens de gravação
- Trabalhar com itens de gravação
- Detectar pontos de edição usando a Detecção de edição de cena
- Metadados XMP
- Textos e gráficos
- Texto
- Animações
- Trabalhar com Modelos de animações no After Effects
- Usar expressões para criar listas suspensas em Modelos de animações
- Trabalhar com propriedades essenciais para criar Modelos de animações
- Substituir imagens e vídeos em Modelos de animações e Propriedades essenciais
- Anime de maneira mais rápida e fácil usando o painel Propriedades
- Desenho, pintura e caminhos
- Visão geral de camadas de forma, caminhos e gráficos vetoriais
- Ferramentas de pintura: Pincel, Carimbo e Borracha
- Traçados de forma cônica
- Atributos de forma, operações de pintura e operações de caminho para camadas de forma
- Use o efeito de forma Deslocar caminhos para alterar formas
- Criação de formas
- Criar máscaras
- Remover objetos de seus vídeos com o painel Preenchimento com reconhecimento de conteúdo
- Pincel tipo rotoscópio e Refinar fosco
- Camadas, marcadores e câmera
- Animação, quadros-chave, rastreamento de movimento e chaveamento
- Animação
- Quadro-chave
- Rastreamento de movimento
- Aplicação de máscara
- Transparência e composição
- Ajustar cor
- Predefinições de animação e efeitos
- Visão geral das predefinições de animação e efeitos
- Lista de efeitos
- Gerenciador de efeitos
- Efeitos de simulação
- Efeitos de estilo
- Efeitos de áudio
- Efeitos de distorção
- Efeitos de perspectiva
- Efeitos de canal
- Efeitos de geração
- Efeitos Tempo
- Efeitos de transição
- O efeito Reparo do obturador de rolagem
- Efeitos Desfoque e Tornar nítido
- Efeitos de Canal 3D
- Efeitos de utilitários
- Efeitos de fosco
- Efeitos Ruído e Granulação
- Efeito de ampliação com preservação de detalhes
- Efeitos obsoletos
- Expressões e automação
- Expressões
- Noções básicas de expressão
- Entender sobre a linguagem de expressões
- Utilização de controles de expressão
- Diferenças de sintaxe entre os mecanismos de expressão Javascript e Legacy ExtendScript
- Edição de expressões
- Erros de expressão
- Utilização do editor de expressões
- Usar expressões para editar e acessar propriedades de texto
- Referência de idioma de expressão
- Exemplos de expressão
- Automação
- Expressões
- Vídeo imersivo, VR e 3D
- Construa ambientes VR no After Effects
- Aplicar efeitos de vídeo imersivo
- Ferramentas de composição para vídeos VR/360
- Renderizador 3D avançado
- Importar e adicionar modelos 3D à composição
- Importação de modelos 3D das bibliotecas da Creative Cloud
- Iluminação com base na imagem
- Extração e animação de luzes e câmeras de modelos 3D
- Rastreamento de movimento de câmera 3D
- Projetar e aceitar sombras
- Animações de modelos 3D incorporadas
- Coletor de sombras
- Extração de dados de profundidade 3D
- Modificar as propriedades de materiais de uma camada 3D
- Trabalhar no Espaço de design 3D
- Gizmos de transformação 3D
- Faça mais com a animação 3D
- Visualização de alterações em projetos 3D em tempo real com o mecanismo Mercury 3D.
- Adicionar design responsivo aos gráficos
- Exibições e visualizações
- Renderização e exportação
- Noções básicas de renderização e exportação
- Codificação em H.264 no After Effects
- Exportar um projeto do After Effects como um projeto do Adobe Premiere Pro
- Conversão de filmes
- Renderização de vários quadros
- Renderização automatizada e renderização de rede
- Renderização e exportação de imagens estáticas e sequências de imagens estáticas
- Utilização do codec GoPro CineForm no After Effects
- Trabalho com outros aplicativos
- Colaboração: Frame.io e Team Projects
- Memória, armazenamento e desempenho
- Knowledge Base
Este documento explica as diferenças de sintaxe da linguagem de expressões entre os mecanismos de expressão Javascript e Legacy ExtendScript no After Effects 16.0.
Consulte este documento para saber mais sobre como melhorar suas expressões para o mecanismo de expressões de Javascript, ou ao corrigir erros que ocorrem quando a avaliação de expressões escritas para versões anteriores do After Effects retorna falhas no mecanismo de expressões de Javascript.
A linguagem de expressões no After Effects tem base em Javascript, que é uma implementação de ECMAScript. O mecanismo de expressões Javascript no After Effects 16.0 tem base em ECMAScript 2018. O mecanismo de expressões Legacy ExtendScript tem base em ECMAScript 3 (1999). (O Adobe ExtendScript também é a linguagem usada na criação de scripts no After Effects e em outros aplicativos da Adobe.)
Você pode seguir os exemplos fornecidos abaixo, além da orientação para a criação de expressões que funcionam em ambos os mecanismos de expressões JavaScript e Legacy ExtendScript.
As diferenças principais entre os mecanismos de expressão Javascript e Legacy ExtendScript são:
- Sintaxe moderna do Javascript: adições feitas ao Javascript no ECMAScript 5 até o ECMAScript 2018 permitem sintaxe e métodos novos em expressões ao usar o mecanismo de expressões de Javascript. Além disso, algumas pequenas melhorias foram feitas na sintaxe de expressões ao usar o mecanismo de expressões de Javascript. Aqui estão algumas diferenças:
- Sintaxe herdada incompatível: algumas sintaxes herdadas não são compatíveis com o mecanismo de expressões de Javascript. Essas exceções estão documentadas aqui, juntamente com as alterações necessárias para tornar a sintaxe não funcional compatível com o mecanismo do Javascript. Aqui estão algumas diferenças:
- Diferenças da sintaxe if...else
- If e else não podem estar na mesma linha sem colchetes
- Expressões não podem terminar em uma declaração de função
- A sintaxe abreviada this() não é permitida; em vez disso, use thisLayer()
- O acesso do índice de matrizes da propriedade de Texto de origem a caractere requer .value
- Propriedades e métodos em Snakecase não são permitidos
- Uso de eval() com expressões (.jsxbin) binárias
- Suporte limitado para o objeto $. (Dólar)
- Não permite o uso de ...reflect.properties, ...reflect.methods e toSource()
- Requisitos de sintaxe para bibliotecas da expressão.jsx e eval (): ao usar expressões em uma biblioteca de funções de expressões .jsx ou quando uma expressão é chamada de dentro de eval(), thisLayer. e thisProperty. devem ser chamados explicitamente, e operações matemáticas em matrizes devem ser substituídas por matemática de vetores. Aqui estão algumas diferenças fundamentais:
Sintaxe moderna do Javascript: melhorias feitas à linguagem de expressões
As expressões podem usar a sintaxe de JavaScript do ECMAScript 2018
Muitas adições foram feitas à linguagem JavaScript desde o ECMAScript 3. Há novos métodos para usar com sequências de caracteres, matrizes e objetos que são mais compactos e legíveis. Também há novas maneiras de declarar variáveis e funções, bem como parâmetros padrão, operadores spread e muito mais. Este documento não aborda essas alterações, porque se aplicam à linguagem JavaScript. Os recursos para saber mais sobre as muitas adições de sintaxe podem ser encontrados nos seguintes links:
- Guia do Javascript (também conhecido como ES5 ECMAScript 5)
- Novos métodos de matriz
- Novos métodos de objeto
- JSON.stringify() e JSON.parse()
Recursos adicionais e detalhados recomendados para saber mais sobre o JavaScript:
.value não é mais necessário ao vincular a outras propriedades a partir do Texto de origem
Ao fazer referência a outro valor de propriedade a partir de uma propriedade de texto de origem, o mecanismo do Legacy ExtendScript requer que .value seja adicionado ao final da propriedade. O mecanismo do JavaScript mostra o valor da propriedade por padrão, a menos que outro atributo como .propertyIndex ou .name seja usado explicitamente.
Por exemplo:
thisCompayer(“Solid 1”)ransformosition //No mecanismo herdado, isso equivale a “[object Property]” quando aplicado a uma propriedade de Texto de origem. // No mecanismo do JavaScript, isso equivale ao valor da propriedade Posição da camada “Solid 1” quando aplicado a uma propriedade de Texto de origem.
Congelar valores de propriedade com posterizeTime(0)
No After Effects 16.0, posterizeTime(0) congela o valor de propriedade na hora 0 na composição. Isso se aplica aos mecanismos de Javascript e de Legacy ExtendScript.
Observação:
Isso não tem compatibilidade com versões anteriores e pode causar resultados inesperados em versões do After Effects anteriores à 16.0.
Sintaxe herdada incompatível
Praticamente qualquer sintaxe de expressão do mecanismo de expressões do Legacy ExtendScript tem compatibilidade com versões futuras do mecanismo de expressões de Javascript. No entanto, há algumas sintaxes herdadas que não são compatíveis com o mecanismo de expressões de Javascript. Às vezes, isso é causado por alterações de sintaxe no Javascript moderno. Em outros casos, sintaxes obsoletas ou desatualizadas foram removidas. Os exemplos de sintaxes funcionais e não funcionais estão localizados abaixo.
A maioria dessas diferenças de sintaxe pode ser corrigida por meio do script do aplicativo que re-escreve as expressões.
Diferenças da sintaxe if...else
Geralmente, é recomendável escrever sempre instruções if...else com quebras de linhas e colchetes de acordo com as diretrizes MDN. O mecanismo do Legacy ExtendScript costumava tolerar sintaxes amplas em intruções if...else, no entanto, o mecanismo do JavaScript é restrito. A sintaxe de if...else incorreta retorna falha na avaliação ao usar o mecanismo do JavaScript.
Concluir de uma expressão com uma instrução if não é permitido
Quando uma expressão é concluída com uma instrução if sem uma instrução else, o mecanismo do JavaScript falha ao avaliar e retorna o erro “Valor indefinido usado na expressão (pode ser um subscript fora do intervalo da matriz?)”. No mecanismo do Legacy ExtendScript, a seguinte expressão avalia para 100 se o tempo for maior que 1 segundo, caso contrário resulta em 50:
var x = 50;
if ( time > 1 ) {
x = 100
}
O “else” aqui é inferido, mas não definido.
O mecanismo JavaScript requer a parte else da instrução para ser exibido explicitamente, caso seja a última instrução na expressão:
var x = 50;
if ( time > 1 ) {
x = 100;
} else {
x;
}
Isso resultará na avaliação correta em ambos os mecanismos do JavaScript e do Legacy ExtendScript.
If e else não podem estar na mesma linha sem colchetes
Uma instrução if...else em uma única linha sem colchetes avalia no mecanismo do Legacy ExtendScript, mas não avalia no mecanismo do JavaScript e retorna um erro como “Erro de sintaxe: Token inesperado else” ou “Valor indefinido usado na expressão (pode ser um subscript fora do intervalo da matriz?)”. O erro varia, dependendo do tipo de contexto e de propriedade.
No mecanismo do Legacy ExtendScript, a seguinte expressão avalia para 100 se o tempo for maior que 1 segundo, caso contrário resulta em 50:
if ( time > 1 ) 100 else 50;
O mecanismo JavaScript requer quebra de linha ou colchete para avaliar instruções if...else. Para casos simples, o operador ternário pode ser usado. Qualquer uma das seguintes sintaxes pode ser usada com o mecanismo do JavaScript:
// Solução A: adicionar uma quebra de linha antes de “else” permitirá que ambos os mecanismos avaliem corretamente.
if ( time > 1 ) 100
else 50;
// Solução B: adicionar o bracketing correto também permitirá que ambos os mecanismos avaliem corretamente.
if ( time > 1 ) { 100 } else { 50 };
//Solução C: use um operador ternário no lugar da instrução “if…else”, que também avalia corretamente em ambos os mecanismos.
time > 1 ? 100 : 50;
Todas as soluções acima avaliam corretamente no mecanismo do JavaScript e no mecanismo do Legacy ExtendScript.
Expressões não podem terminar em uma declaração de função
Se uma expressão é concluída com uma declaração de função, o mecanismo JavaScript não avalia a expressão com o erro “objeto do tipo localizado onde requer um número, uma matriz ou uma propriedade”. No mecanismo do JavaScript, o último item avaliado deve retornar um valor, em vez de declarar um.
Os seguintes exemplos funcionam no mecanismo do Legacy, mas não no mecanismo do JavaScript:
timesTen( value ); // O mecanismo herdado avalia esta linha, embora a função seja declarada abaixo.
function timesTen ( val ) {
return val * 10
}
Quando uma função é chamada como a última linha (em vez da declaração), a expressão será avaliada corretamente em ambos os mecanismos:
function timesTen ( val ) {
return val * 10
}
timesTen( value ); // O mecanismo JavaScript precisa que a chamada de função aconteça abaixo da declaração para retornar o valor correto.
A sintaxe abreviada this() não é permitida; em vez disso, use thisLayer()
No mecanismo herdado do ExtendScript, this podia ser usado como formato abreviado para thisLayer. No mecanismo do JavaScript, this se refere ao objeto global e thisLayer deve ser usado. Usar this no mecanismo do JavaScript resultará normalmente no erro “this não é uma função”.
No exemplo a seguir do Legacy ExtendScript, this é usado para criar um vínculo compacto a uma propriedade Posição da camada de texto da propriedade Texto de origem:
this(5)(2).value;
No mecanismo do JavaScript, this deve ser substituído por thisLayer:
thisLayer(5)(2).value;
Usar thisLayer é compatível com ambos os mecanismos de expressão.
O acesso do índice de matrizes da propriedade de Texto de origem a caractere requer .value
No mecanismo de expressão do Legacy ExtendScript, os caracteres de uma propriedade de texto podem ser acessados com anotação entre colchetes como uma matriz:
text.sourceText[0] // Retorna o primeiro caractere do valor de texto da propriedade Texto de origem.
No mecanismo do JavaScript, .value deve ser adicionado para acessar os caracteres:
text.sourceText.value[0] // Retorna o primeiro caractere do valor de texto da propriedade Texto de origem.
Essa sintaxe é compatível com ambos os mecanismos.
Propriedades e métodos de SnakeCase não são permitidos
As propriedades e os métodos obsoletos do SnakeCase (gravados com um underscore (_) em vez do camelCase) não são suportados pelo mecanismo do JavaScript. Em vez disso, as versões de camelCase devem ser usadas, porque são compatíveis com os dois mecanismos. A seguir está uma lista do SnakeCase obsoleto e o camelCase correspondente.
|
|
Propriedades de camelCase |
Métodos do SnakeCase |
Métodos do camelCase |
|---|---|---|---|
|
this_comp this_layer this_property color_depth has_parent in_point out_point start_time has_video has_audio audio_active anchor_point audio_levels time_remap casts_shadows light_transmission accepts_shadows accepts_lights frame_duration shutter_angle shutter_phase num_layers pixel_aspect point_of_interest depth_of_field focus_distance blur_level cone_angle cone_feather shadow_darkness shadow_diffusion active_camera |
thisComp thisLayer thisProperty colorDepth hasParent inPoint outPoint startTime hasVideo hasAudio audioActive anchorPoint audioLevels timeRemap castsShadows lightTransmission acceptsShadows acceptsLights frameDuration shutterAngle shutterPhase numLayers pixelAspect pointOfInterest depthOfField focusDistance blurLevel coneAngle coneFeather shadowDarkness shadowDiffusion activeCamera |
value_at_time() velocity_at_time() speed_at_time() nearest_key() posterize_time() look_at() seed_random() gauss_random() ease_in() ease_out() rgb_to_hsl() hsl_to_rgb() degrees_to_radians() radians_to_degrees() from_comp_to_surface() to_comp_vec() from_comp_vec() to_world_vec() from_world_vec() to_comp() from_comp() to_world() from_world() temporal_wiggle() loop_in_duration() loop_out_duration() loop_in() loop_out() |
valueAtTime() velocityAtTime() speedAtTime() nearestKey() posterizeTime() lookAt() seedRandom() gaussRandom() easeIn() easeOut() rgbToHsl() hslToRgb() degreesToRadians() radiansToDegrees() fromCompToSurface() toCompVec() fromCompVec() toWorldVec() fromWorldVec() toComp() fromComp() toWorld() fromWorld() temporalWiggle() loopInDuration() loopOutDuration() loopIn() loopOut() |
Uso de eval() com expressões (.jsxbin) binárias
As expressões codificadas no formato binário do ExtendScript (salvas como um arquivo binário. jsxbin do ExtendScript Toolkit CC) não são suportadas pelo mecanismo do JavaScript.
Se você deseja ofuscar uma expressão, use o mecanismo do Legacy ExtendScript ou use um método diferente de ofuscação que seja compatível com o ECMAScript 2018. Alguns métodos de ofuscação podem não ser compatíveis com os dois mecanismos de expressão.
Suporte limitado para o objeto $. (Dólar)
Os métodos e as propriedades do objeto $. (Dólar) são específicos ao ExtendScript e são suportados em maior parte no mecanismo do JavaScript. Esta tabela lista usos não suportadas e suportados do objeto $. (Dólar):
|
Sem suporte a $. |
Com suporte a $. |
|---|---|
|
$.fileName $.hiResTimes $.stack $.evalFile() $.lista() $.setenv() $.getenv() $.appEncoding $.buildDate $.decimalPoint $.dictionary $.erro $.flags $.includePath $.level $.line $.locale $.localize $.memCache $.os $.screens $.strict $.version |
$.build $.engineName (isso não é compatível com o mecanismo do Legacy ExtendScript) $.global |
Não há suporte para ...reflect.properties, ...reflect.methods e toSource()
reflect.properties e reflect.methods não são suportados no mecanismo do JavaScript; são métodos específicos ao ExtendScript que não têm nenhum equivalente direto no JavaScript.
toSource() no JavaScript foi descontinuado e não faz parte de nenhum monitoramento padrão.
Para exibir uma lista de propriedades e métodos disponíveis para qualquer propriedade específica do After Effects semelhante ao que foi fornecido pelos métodos acima, use a seguinte expressão em uma propriedade de Texto de origem e vincule-a à sua propriedade desejada, por exemplo, usando o ícone de seleção no lugar de thisProperty na linha 1:
let obj = thisProperty; // Substitui “thisProperty” por um link de propriedade para a propriedade desejada.
let props = [
do {
ObjectetOwnPropertyNames(obj)orEach(prop => {
if (propsndexOf(prop) === -1) {
propsush(prop
}
}
} while (obj = ObjectetPrototypeOf(obj)
propsoin(“\n” // Retorna uma matriz de sequências de caracteres que lista as propriedades e os métodos disponíveis.
A expressão acima não é compatível com o mecanismo do Legacy ExtendScript. Usa a sintaxe e os métodos não disponíveis no ECMAScript 3.
Requisitos de sintaxe para bibliotecas de expressão .jsx e eval() com o mecanismo JavaScript
Ao usar expressões em uma biblioteca de funções de expressões .jsx ou quando uma expressão é chamada de dentro de eval(), determinadas sintaxes precisam ser modificadas:
Um prefixo thisLayer. ou thisProperty. explícito deve ser adicionado a qualquer método ou atributo nativo ou que não é chamado explicitamente uma camada ou propriedade. O prefixo instrui o mecanismo do JavaScript que o objeto está chamando o método ou atributo.
Operações matemáticas em valores de matriz como Posição devem ser calculados usando matemática vetorial ou usando funções de looping para atuar em cada item da matriz. Operadores matemáticos sobrecarregados como posição + [100,100] não avaliarão.
Ao usar o mecanismo JavaScript, as expressões são processadas antes da avaliação para fazer parte da sintaxe de expressões do Legacy ExtendScript legível pelo novo mecanismo. No entanto, essas tarefas de pré-processamento não são executadas ao avaliar expressões de uma biblioteca de funções de expressões .jsx ou quando uma expressão é chamada de dentro de eval(). As modificações acima da sintaxe devem ser feitas manualmente para esses casos. Todas essas modificações da sintaxe são compatíveis com versões anteriores com o mecanismo do Legacy ExtendScript, portanto, uma biblioteca de expressões .jsx escrita para trabalhar com o mecanismo JavaScript também trabalhará com o mecanismo do Legacy ExtendScript.
Dica de desempenho: devido à falta de pré-processamento, chamar expressões complexas de uma biblioteca .jsx com essa sintaxe e o mecanismo do JavaScript, pode resultar em uma melhoria no desempenho, comparado a chamar a mesma expressão diretamente em uma propriedade.
Prefixar explicitamente métodos e atributos nativos com thisLayer. ou thisProperty.
A tabela a seguir lista os métodos e atributos que exigem um prefixo. Por exemplo, o tempo deve ser escrito como thisLayer.time, e wiggle() deve ser escrito como thisProperty.wiggle().
Esses prefixos são necessários somente em casos em que o atributo ou método já não está sendo chamado explicitamente em outra camada ou propriedade. Por exemplo, ao chamar thisComp.layer(1).hasParent, adicionar thisLayer. não é obrigatório pois .hasParent já está sendo chamado explicitamente em layer(1).
|
Métodos que requerem thisLayer. |
Atributos que requerem thisLayer. |
Métodos que requerem thisProperty. |
Atributos que requerem thisProperty. |
|---|---|---|---|
|
comp() |
time |
valueAtTime() |
velocity |
Substituição de operadores matemáticos com funções matemáticas vetoriais
Os mecanismos Javascript e LegacyExtendScript permitem sobrecarga de operadores matemáticos para matrizes usando sintaxes como posição + [100,100], mas isso não funciona para expressões em uma biblioteca de funções de expressão .jsx ou para dentro de eval().
Para executar a matemática em propriedades de matriz como Posição, Escala etc., os equivalentes matemáticos de vetores devem ser usados para adição, subtração, multiplicação e divisão. As funções matemáticas vetoriais também funcionarão para números regulares, portanto uma função que pode ser chamada em propriedades de dados de qualquer um dos dois tipos de dados deve usar as funções matemáticas vetoriais.
Observação:
O prefixo thisLayer. deve ser usado com as funções matemáticas de vetores.
- Adição: thisLayer.add(vec1, vec2)
- Subtração: thisLayer.sub(vec1, vec2)
- Multiplicação: thisLayer.mul(vec, amount)
- Divisão: thisLayer.div(vec, amount)
Abaixo estão alguns exemplos de expressões usando a matemática padrão e a matemática vetorial atualizada. As expressões matemáticas de vetores também usam os prefixos thisLayer. ou thisProperty. apropriados quando necessário.
Para localizar a diferença entre um wiggle() e o valor de uma propriedade de Posição:
// Matemática padrão: wiggle() - value; // Matemática vetorial: thisLayer.sub( thisProperty.wiggle(), value );
Para interpolar entre dois valores, de modo similar a linear(), mas com um intervalo estendido além do mínimo e o máximo definido:
// Matemática padrão: value1 + ( ( t - tMin ) / ( tMax - tMin ) ) * ( value2 - value1 ); // Matemática vetorial: thisLayer.add( value1, thisLayer.mul( thisLayer.div( thisLayer.sub( t, tMin ), thisLayer.sub( tMax, tMin ) ), thisLayer.sub( value2, value1 ) ) );
Para repetir uma propriedade de Posição para dentro e para fora:
// Matemática padrão: loopIn( “cycle” ) + loopOut( “cycle” ) - value; Matemática vetorial: thisLayerub( thisLayerdd( thisPropertyoopIn( “cycle” ), thisPropertyoopOut( “cycle” ) ), value
