Neste tutorial vamos explorar o mundo maravilhoso da poderosa nova expressão controlos que Adobe introduzidos com After Effects 5.5. Vamos olhar para várias formas que a expressão controlos pode ser útil em seus projetos. Primeiro vamos examinar o mais straight-forward usar controles de expressão, Que é o de usá-las como um ajuste manual "mestre" controle para ajudá-lo a criar um comp só do jeito que você quer que ele. Então vamos estudar usando expressão controles como comandante animação controladores. Próxima vamos analisar o modo como você pode usar uma expressão como um controlo limitado tipo de variável global para distribuir informações para expressões em outras camadas. Finalmente, Vamos nos divertir usando expressão controles para criar a maior do mundo cameraman. Que é um lote de terra para cobrir, Portanto, vamos avançar!
After Effects 5.5 apresenta seis novos controles expressão: Controle deslizante, ângulo controle, Caixa de controlo, Cor controlo, Ponto de controlo, E camada de controle. Estes controles são aplicados como efeitos e estão localizadas na "expressão controlos" grupo no sentido de menu. Quando utilizar esses animação a nível mundial para o controlo, Gosto de aplicá-las a uma camada nulo (e, em seguida, desligar a visibilidade do nulo para não atravancar o comp janela) para que ele seja fácil de encontrá-los mais tarde, Mas você pode aplicá-las, bem como a outras camadas. O primeiro controle vamos olhar para o controle deslizante.
| Controle deslizante --- --- |
Vá em frente e abra o arquivo de projeto e selecione a guia para o "slider" comp. Comp este contém uma camada nula (a que um controle deslizante tem sido aplicado), Uma simples ilustrador gráfico camada que foi duplicada um monte de vezes, E uma câmara. Notar que os gráficos são camadas 3d, porque vamos estar usando o controle deslizante para a posição das camadas em "z" espaço. Selecione a camada nulo e pressione Ctrl + Shift + T (pc) ou cmd + shift + t ( MAC ) Para revelar o "efeito controlos" paleta. Selecione uma das camadas e gráficos tipo "p" para revelar a posição propriedade. Clique na pequena twirly revelar a seguinte expressão:
Posição + [0,0,(index-1) * This_comp.Camada ( "null 1").Efeito ( "controle deslizante").Param ( "slider")]
Esta expressão estabelece cada camada da posição do "z" espaço com base em sua camada número (índice) menos um, Vezes o valor da barra. Assim como o valor da barra aumenta, As camadas vai espalhar-nos ao longo do eixo z. Vá em frente e esfrega o valor do deslocamento (clicando e arrastando sobre o valor). Bastante lisonjeiro, Hum? Notar que se você arrastar o valor negativo, As camadas propagação no sentido negativo z. Você também pode ajustar o valor clicando na pequena twirly ao lado de "barra" e arraste o controle deslizante. Uma outra coisa a se notar é que, se você clique com o botão direito (pc) ou Control-clique ( MAC ) Sobre o valor e selecione "Editar valor" no menu de contexto, Você pode ajustar o intervalo da barra. Você pode querer fazer isso dar-te um leque mais amplo ou mais precisão com o controle deslizante.
Nota de que a criação de um comp como esta é bastante simples. O gráfico camadas são exactamente os mesmos. Uma vez que você começa a expressão criada você pode criar rapidamente um monte de duplicatas, digitando ctrl + d (pc) ou cmd + d ( MAC ), Ea expressão será automaticamente acomodar qualquer número de camadas.
| --- ângulo e cor controla --- |
Selecione a guia para o "ângulo e cor comp". Comp este contém um nulo e múltiplas cópias de uma camada gráfica que teve a sua âncora ponto deslocado para a parte inferior e teve a "Matiz" efeito aplicada. Selecione a camada nulo e pressione Ctrl + Shift + T (pc) ou cmd + shift + t ( MAC ) Para revelar o "efeito controlos" paleta. Você perceberá que a nulidade tem um ângulo de controlo e controlos aplicados duas cores. A cor controlos foram renomeados "start_color" e "end_color" para que possa consultá-las pelo seu nome na nossa manifestação. Selecione uma das camadas e gráficos tipo "r" para revelar a rotação propriedade e clique no pequeno twirly para revelar a seguinte expressão:
Índice * This_comp.Camada ( "null 1").Efeito ( "ângulo de controlo").Param ( "ângulo")
Esta expressão calcula a rotação da camada por camada multiplicando o número (índice) pelo valor do ângulo de controlo. Com a camada gráfica ainda seleccionado, Tipo "e" para mostrar os efeitos aplicados para a camada. Você perceberá que a tintura afeta tem sido aplicado. Clique no twirly pouco ao lado de "Matiz" e clique na twirly ao lado de "mapa de branco", para revelar a seguinte expressão (você vai ter que expandir a área expressão para ver tudo):
If (This_comp.Num_layers 3) (
This_comp.Camada ( "null 1").Efeito ( "start_color").Param ( "cor")
}
Else (
This_comp.Camada ( "null 1").Efeito ( "start_color").Param ( "cor") +
(This_comp.Camada ( "null 1").Efeito ( "end_color").Param ( "cor")-This_comp.Camada ( "null 1").Efeito ( "start_color").Param ( "cor")) *
((index-1) / (This_comp.Num_layers - 2))
}
Esta expressão primeiro verifica se existe apenas uma camada gráfica, Caso em que apenas utiliza a cor do "start_color" controle (isto é necessário porque, sem esse código, A expressão vai abortar em uma "divisão por zero" erro quando você aplicá-la a uma única camada). O resto da expressão abrange os habituais caso existem múltiplas camadas gráfico. Nesse caso, A expressão para barrar a cor de modo a permitir que a camada superior recebe o "start_color" ea camada inferior recebe a "end_color" e as outras camadas receber algo em entre. Notar que os valores das cores são realmente 4-dimensional arrays na forma [vermelho,Verde,Azul,AlfA], onde o valor de cada elemento varia de 0 (preto) a 1 (branco). Usaremos essas informações posteriormente (felizmente, AE 5.5 introduziu user-friendly vetor matemática por isso podemos usar normal operadores aritméticos sobre esses valores e não têm de se preocupar com sua matrizes para a direita agora).
Vá em frente e esfrega o ângulo controlar e vigiar as expressões fazer suas coisas. Tente mudar as cores. Ficando ainda quaisquer ideias criativas?
| Controles automatizados --- --- |
Selecione a guia para o "controlo automatizado" comp. Comp esta é uma espécie de combinação dos dois primeiros que analisámos, Com o controle deslizante, ângulo, Cor e controlos aplicados para a camada nulo (selecione "nulo 1" e digite Ctrl + Shift + T (pc) ou cmd + shift + t ( MAC ) Para vê-los). O que é diferente sobre esta comp é que nós adicionamos expressões para a expressão controlos. Com "null 1" seleccionado, Tipo "e" para revelar a expressão controlos. Clique no twirly ao lado de "controle deslizante" e clique no próximo a um "deslocamento". Você verá esta expressão:
Math.Sin (altura * 2) * 25
Essa expressão apenas cria um valor oscilante para controlar o cursor. O "25" estabelece os valores máximos de 25 e -25. O "tempo * 2" significa que o ciclo irá repetir a cada 3 segundos (para os curiosos: A matemática.Pecado parâmetro para a sua função espera estar em radianos - o ciclo repete a cada 2 * pi radianos, que é de cerca de 6.28).
Agora clique no twirly ao lado de "ângulo de controlo" e, em seguida, clique no próximo a um "ângulo". Você verá esta expressão:
Math.Sin (altura * 2) * 6
Esta expressão semelhante irá variar o ângulo de controlo de 6 graus a -6 graus cada três segundo.
Clique no twirly ao lado de "start_color" e clique na próxima a uma "cor" para revelar a seguinte expressão:
R = matemática.Cos (altura * 2) / 2 +.5;
G = 0;
B =- matemática.Cos (altura * 2) / 2 +.5;
[r,g,b,1]
Lembro quando eu mencionei que cor é realmente um 4-dimensional array na forma de [r,g,b,A]? E é neste ponto que precisamos de saber que. Esta expressão varia nosso início de cor vermelha [1,0,0,1] para azul [0,0,1,1] sobre a nossa 3-segundo ciclo. Notar que é sempre verde off (0) e alfa é sempre relativo (1).
Clique no twirly ao lado de "end_color" e clique na próxima a uma "cor" para revelar a seguinte expressão:
R = matemática.Cos (altura * 2) / 2 +.5;
G = 1;
B =- matemática.Cos (altura * 2) / 2 +.5;
[r,g,b,1]
Esta expressão é muito semelhante ao anterior, Exceto que temos verde ligado, Por isso, será o nosso fim variando de cor amarela [1,1,0,1] para cian [0,1,1,1].
Ok. Inspecionar o comp e vê-lo ir.
Agora vamos para mudar um pouco de artes. A caixa de controle fornece uma maneira conveniente de iniciar e parar uma animação simplesmente adicionando keyframes para a caixa de controle. Selecione a guia para o "caixa" comp. Comp este contém um simples "metrônomo" pré-comp nulo e uma camada com uma caixa de controlo aplicadas. O "metrônomo" pré-comp contém um simples 1-ciclo-e-volta diante de uma oscilação 25x250 sólidos que teve o seguinte ciclo de geração de expressão aplicada à rotação propriedade (ver o meu "Animando um passeio de ciclo"Tutorial para mais informações sobre este tipo de expressão):
Loop_out ( "ciclo",0)
Na "caixa" comp, Selecione a camada nulo e digite "e" para revelar a caixa de controle. Clique no twirly revelar a keyframes. Os keyframes apenas alternar o "on" e "off" estado da caixa de controlo. Selecione a opção "metrônomo" pré-comp e digite "RR" para revelar o tempo remapear propriedade. Clique no twirly para revelar a expressão que tem sido aplicado ao tempo remapear propriedade:
If (This_comp.Camada ( "null 1").Efeito ( "caixa de controlo").Param ( "caixa") 0) (
Xtime = tempo;
While (xtime 0 & & This_comp.Camada ( "null 1").Efeito ( "caixa de controlo").Param ( "caixa").Value_at_time (xtime) 0) (
Xtime = xtime - This_comp.Frame_duration;
}
Tempo - xtime;
}
Else (
0
}
Basicamente, O que esta expressão não é executado o metrónomo animação (começando com o primeiro quadro), sempre que a caixa é "relativo". Sempre que a caixa é "desligado" a animação é realizada no primeiro quadro. Inspecionar o comp e notar o efeito. A expressão obras de looping de volta no tempo até que ele encontra pela última vez a caixa de controle foi desligado, Descobrir há quanto tempo que foi, E ligar esse valor para o tempo remapeamento propriedade do metrônomo comp. Você pode querer brincar com o movimento em torno de keyframes ou adicionar novos.
O que se desejava para a exploração de tal ordem que a animação será executado enquanto a caixa estava em, Mantenha a posição actual, enquanto a caixa está desligado e retomar de onde parou quando a caixa vem de novo? Substituindo o tempo remapeamento uma expressão com o presente irá fazer o truque:
Xtime = 0;
Total_on_time = 0;
While (xtime altura) (
If (This_comp.Camada ( "null 1").Efeito ( "caixa de controlo").Param ( "caixa").Value_at_time (xtime) 0) (
Total_on_time = Total_on_time + This_comp.Frame_duration;
}
Xtime = xtime + This_comp.Frame_duration;
}
Total_on_time
Essa expressão apenas através dos lacetes comp frame-por-frame, Acumulando ", em" tempo que vai até que chegue ao actual momento comp. O total ", em" tempo fica ligado ao tempo remapear propriedade. Brincar com ele, se desejar.
| Variáveis globais --- --- |
Às vezes, quando você estiver desenvolvendo uma expressão que você encontrar a Situação em que seria muito útil ter acesso a variáveis globais que você pode usar para compartilhar informações entre as camadas. Acontece que em alguns casos especiais, Você pode usar comandos para realizar esta expressão. Selecione a guia para o "variáveis globais" comp. Se você olhou para a minha "Gerador aleatório Motion"Tutorial, Comp este parece-me bastante familiar para você. Se não, E você estiver interessado em saber como funciona a parte aleatória, Confira os outros tutoriais, porque estou indo só para cobri-lo brevemente aqui. Comp esta consiste de nosso novo amigo o nulo camada com um ponto de controlo aplicadas e uma simples 50x50 sólido (duplicada um monte de vezes) com as seguintes expressões aleatórias-motion aplicada à posição, Rotação e opacidade:
Posição:
I = This_comp.Camada ( "null 1").Efeito ( "ponto controle").Param ( "ponto") [1]
Porcento = This_comp.Camada ( "null 1").Efeito ( "ponto controle").Param ( "ponto") [0];
Seed_random (I,True);
Target_x = random () * This_comp.Largura;
Target_y = random () * This_comp.Altura;
Seed_random (I-1,True);
Old_x = random () * This_comp.Largura;
Old_y = random () * This_comp.Altura;
[old_x,Old_y] + ([target_x,Target_y] - [old_x,Old_y]) * por cento;
Rotação:
I = This_comp.Camada ( "null 1").Efeito ( "ponto controle").Param ( "ponto") [1];
Porcento = This_comp.Camada ( "null 1").Efeito ( "ponto controle").Param ( "ponto") [0];
Seed_random (I,True);
Target_Rotação = random () * 720;
Seed_random (I-1,True);
Old_Rotação = random () * 720;
Old_Rotação + (target_Rotação - old_Rotação) * por cento;
Opacidade:
I = This_comp.Camada ( "null 1").Efeito ( "ponto controle").Param ( "ponto") [1];
Porcento = This_comp.Camada ( "null 1").Efeito ( "ponto controle").Param ( "ponto") [0];
Seed_random (I,True);
Target_Opacidade = random () * 100;
Seed_random (I-1,True);
Old_Opacidade = random () * 100;
Old_Opacidade + (target_Opacidade - old_Opacidade) * por cento;
Inspecionar o comp e você verá que comporta de forma diferente das similares comps na "geração aleatória Motion "Tutorial (onde o movimento é um pouco caótico). Neste novo comp, O movimento é aleatório, mas sincronizado. A chave para proporcionar esse "mestre de controlo" é a utilização do ponto de controlo para passar dois principais "variáveis globais" para as outras camadas. Usei um ponto de controlo para este porque é um 2-dimensional array e eu precisava para passar dois valores. Eu poderia ter utilizado dois deslizante controles, mas isso parecia mais fácil. Se você comparar o que precede a essas expressões no outro tutorial você verá que todo o código que é usado para descobrir o que estamos no segmento ( "I") e até que o segmento em que estamos ( "por cento") está em falta e tem sido Substituído, com referências aos dois valores do ponto de controlo aplicadas ao null layer. Null e selecione o tipo "e" para revelar o ponto de controlo. Clique no twirly e clique no próximo a um "ponto controle" para revelar esta expressão:
Start = 0; / / condições iniciais
End = 0;
I = 1;
Tmin = .5; / / tempo de ciclo mínimo (não pode ser zero)
Tmax = 2; / / tempo de ciclo máximo
While (hora = fim) (
I = 1; seed_random (I,True);
Start = fim;
Fim = fim + random (tmin,Tmax);
}
Porcento = (hora - iniciar) / (end - start);
[por cento,I]
Este é o lugar onde todos os desaparecidos código passou. A expressão nula na camada faz todo o calendário cálculos e passa o "eu" e "por cento" variáveis para as outras camadas através do 2 dimensional valor do ponto de controlo. No outro tutorial, Cada camada teve o seu próprio calendário cálculos de forma aleatória os números gerados foram diferentes para cada camada. Nesta versão, Todas as camadas chegar o momento calculado pela camada null.
Ok - é isso para a base "como expressão do controle trabalho?"Parte do tutorial. Olhou para todos nós, a expressão controlos excepto a camada de controlo. Ainda estou tentando pensar em um bom uso para que um. O problema com a camada de controle é que você não pode Keyframe-lo. Se você pudesse lhe Keyframe, Seria uma escolha melhor do que o controle deslizante que vamos estar a utilizar a partir de agora em diante.
Com o show. Agora vamos ter algum divertimento real aplicação desta variável global negócio e acabam construindo o mundo o maior cameraman!
| --- precisamos de um plano!--- |
Aqui é a idéia básica: Queremos acabar com um comp onde temos um monte de camadas voando aleatoriamente no espaço 3D. Queremos ser capazes de selecionar uma camada, em qualquer momento e ter o nosso "cameraman" pan, Inclinar, Foco, E de zoom no assunto em nosso modo que permanece centrada na moldura até nós decidimos olhar para outra camada. Então o que precisamos fazer para conseguir isso? Já temos o "voando ao acaso", o código a partir do outro tutorial, Mas teremos de a adaptar ao espaço 3D. Precisamos de desenvolver expressões para câmera pan, Inclinar, Focagem e de zoom. Precisamos de uma maneira de dizer a todos os nossos câmera camada expressões que queremos focar . Uma vez que todas as expressões de nossa necessidade desta informação, Usaremos um controle deslizante como uma variável global. Então, Esperemos, Todos teremos de fazer é Keyframe o controle deslizante com o índice de qualquer camada queremos focar em um determinado momento.
Selecione a guia para o "puxar foco" comp. Neste comp vamos dar os primeiros passos para estabelecer os conceitos que é preciso para construir a nossa incrível cameraman. Aviso que temos quatro camadas contendo gráficos, Null uma camada com um controle deslizante, E uma câmara. Neste comp os gráficos camadas não se movem, Mas eles estão espalhados em "z" espaço. Vá em frente e visualizar o comp. Você percebe que a câmera focaliza os gráficos um-por-um. Null e selecione o tipo "e" para revelar o controle deslizante. Clique no twirly e você será capaz de ver o keyframes. Se você clique com o botão direito (pc) ou Control-clique ( MAC ) Sobre a keyframes, Você vê que eles contêm apenas a camada números em seqüência (1,2,3,4). A ideia é que, quando um novo Keyframe é encontrado, O foco irá tranSitar da camada que incidiu sobre a camada representada pelo novo Keyframe mais de um montante pré-definido de tempo. Provavelmente o elemento mais importante deste comp é a expressão aplicada ao "foco distância" parâmetro da câmara. Preciso avisá-lo - esta expressão é bastante assustador procurando um monstro. É realmente não é tão ruim quanto parece, Mas o código é pesado o suficiente para que eu não estou indo para reproduzir-lo aqui - se você quiser vê-lo você precisa de olhar para ele no comp. Selecione a câmera e clique em sua camada twirly. Clique no twirly ao lado de "Opções" e finalmente, Clique no twirly ao lado de "distância focal" para revelar a expressão:
Ok, Antes de pânico, Deixe-me dizer que a maioria do código está lá apenas para lidar com especial "fronteira" condições que normalmente não é o verdadeiro. Por exemplo, a Situações em que o controle deslizante não tem keyframes ou apenas 1 Keyframe são tratados como casos especiais, Como são os casos em que a actual comp tempo é o primeiro Keyframe antes ou após o último Keyframe. Habitualmente, O actual momento comp cairá entre dois keyframes e esse é o caso, vamos examinar mais de perto. Além disso, O código é mais complicado devido à morosidade cordas é necessário para aceder ao keyframes no controle deslizante. Javascript tem uma "com o" comando que pode potencialmente ser utilizado para limpar o código de um lote, Mas introduz o seu próprio nível de complexidade e de questões para que não vai entrar em que aqui.
Ok. Vamos olhar para o código. A primeira linha define uma variável chamada "Foco_time", que é a passagem do tempo (em segundos) que o que pretendemos fazer para mudar enfoque de uma camada para a próxima. Vamos saltar a "fronteira" condição código eu estava falando mais cedo e descer para o bom. Olhar para a secção que começa com "I = n; "(É cerca de 2 / 3 da forma como estabelece o código). Basicamente esta parte do código é um loop que ciclos para trás no tempo a partir do último Keyframe até que encontra os keyframes em cada lado da hora atual. Então ele olha para ver se ele está dentro do período de transição onde deveria estar a mudar foco. Se estiver na zona de transição, Ele calcula que a percentagem de transição deve ser concluída hoje. Senão ela incide apenas sobre a nova camada. Note que este código é um pouco diferente do que o código que você verá no final comp porque neste comp a câmera não é tão panning ou inclinando a expressão é apenas o cálculo da distância z ao gráfico camadas.
Agora eu sei que alguns de vocês estão a pensar neste momento. Não é apenas um ser muito mais fácil para o foco Keyframe distância directa e eliminar todas as outras coisas este? Paciência, Gafanhoto.
Selecione a guia para o "foco e zoom" comp. Este comp é praticamente idêntico ao anterior comp, Excepto que uma expressão tem sido adicionado à propriedade zoom da câmera é igual ao que estabelece o foco distância. Inspecionar o comp para ver o efeito. Você pode examinar as expressões, se desejar, Ou ficar à toa com o keyframes. É muito bonito o que você esperaria por este ponto.
| --- pan, Inclinar, Foco, E zoom --- |
Temos finalmente chegou à grande final! Você vai precisar para a produção feixe para obter o pleno efeito desta (por causa do ruído fractal filtro utilizado para o fundo). Se você não tem a produção do molho, Eu suspeito que continuará a trabalhar na maior parte - você deve apenas ver tudo contra um não-movimento fundo liso. Selecione a opção "pan, Inclinar, Foco e zoom "tab. Vá em frente e visualizar o comp agora e nós vamos passar por isso quando você estiver através.
Existem várias coisas acontecendo aqui. Nós temos as nossas camadas gráfica com o movimento aleatório expressão bombeada até fazer 3d. Sinta-se livre para olhar para o código se você quiser ver como fazer isso e compará-la com o código na versão 2D na "geração aleatória Motion "Tutorial. A câmera tem uma expressão muito semelhante ao do foco expressão (visto acima), aplicada para a câmera do "ponto de interesse" propriedade de manter a câmera apontou para a voar objetos. A diferença é que o "ponto de interesse" cálculo é igual à posição da camada que a câmera está focando (excepto durante as transições, Quando o "ponto de interesse" são alguns percentuais ao longo do caminho entre as duas camadas. Uma vez que a expressão para o "ponto de interesse" é fazer todo o trabalho, As expressões para o foco e zoom distância propriedades simplesmente tornar-se:
Comprimento (posição,Point_of_interest)
Isto é apenas a distância entre a câmera para o ponto de interesse. Eu preciso de dizer algumas palavras sobre o pano de fundo para este comp (as "nuvens" layer). Acho que é o plano, o que realmente vende o efeito da inclinação e panning porque sem o fundo para fornecer um ponto de referência visual, Seria pouco parecido com as camadas foram movendo, Um-por-um, Para a posição na frente da câmera. Para evitar ter que construir um enorme background 3d camada que iria preencher o comp janela, não importa que forma a câmera pontos, Decidi apenas usar um sólido com 2d fractal ruído aplicado, Porque fractal compensar o ruído tem um parâmetro que torna essencial alargar indefinidamente em qualquer direção. O truque é associar a compensação para o "ponto de interesse" para que o fundo parece estar respondendo ao movimento da câmera. Esta expressão, Aplicado ao "compensar turbulência" parâmetro fractal do ruído parece fazer o truque:
Z = This_comp.Camada ( "câmera 1").Point_of_interest [2]-This_comp.Camada ( "câmera 1").Posição [2];
Y = This_comp.Camada ( "câmera 1").Point_of_interest [1];
X = This_comp.Camada ( "câmera 1").Point_of_interest [0];
Y_ângulo = radians_to_degrees (matemática.Atan (y / z));
X_ângulo = radians_to_degrees (matemática.Atan (x / z));
[This_comp.Width/2-y_ângulo * 12,This_comp.Altura / 2 + x_ângulo * 12]
Esta expressão foi desenvolvido um pouco por tentativa e erro, Com um pouco de ciência nos arremessam.
Gastar algum tempo explorando este comp. Olhar para as expressões em posição propriedade dos gráficos camadas. O mundo 3D espaço para o movimento aleatória destas camadas é limitado a 1.5 vezes a largura de comp x, 1.5 tempo para a comp altura y e z para 1500. Você pode editar estes valores na expressão para ver o efeito. Trapaceie com os parâmetros e a expressão para o ruído fractal. Alterar o parâmetro pan_time na câmera do "ponto de interesse" expressão. Alterar o keyframes (ou adicionar novos) no nulo do controle deslizante (lembre-se de manter com os valores inteiros de 1,2,3 e 4, Correspondente à camada índices das 4 camadas gráficas). Divertir-se!
Bem, Aí está. Parabéns se você ficar o curso. Esperamos que você pegou informação suficiente sobre a forma de expressão e controles combiná-los com as expressões para que você realmente perigosos.!
# # Dan ebberts
Sinta-se livre para discutir esta técnica no After Effects fórum Aqui no Creativecow.
|
