Velocidade angular

Você se lembra de tudo isso?

localização = localização + velocidade
velocidade = velocidade + aceleração

O conteúdo ao qual dedicamos as duas últimas seções? Bem, vamos aplicar exatamente a mesma lógica para rotacionar um objeto.

ângulo = ângulo + velocidade angular
velocidade angular = velocidade angular + aceleração angular

Na verdade, o que temos acima é mais simples do que o que começamos, porque um ângulo é um grandeza escalar—apenas um número, e não um vetor!

Usando a resposta do desafio anterior, vamos dizer que queremos rotacionar um bastão em ProcessingJS em alguns ângulos. Teremos um código da seguinte maneira:

translate(largura/2, altura/2);
rotate(angulo);
line(-50, 0, 50, 0);
ellipse(50, 0, 8, 8);
ellipse(-50, 0, 8, 8);

Após adicionarmos nossos princípios de movimento, temos o programa abaixo. O bastão é inicializado sem rotação alguma, e então começa a rotacionar cada vez mais rápido conforme o ângulo de rotação acelera.

Essa ideia pode ser incorporada em nosso objeto Mover. Por exemplo, podemos adicionar as propriedades relacionadas ao movimento angular no nosso construtor de Mover.

var Mover = function(m, x, y) {
    this.position = new PVector(x, y);
    this.mass = m;

    this.angle = 0;
    this.aVelocity = 0;
    this.aAcceleration = 0;

    this.velocity = new PVector(random(-1, 1), random(-1, 1));
    this.acceleration = new PVector(0, 0);
};

Então, em update(), atualizamos ambos, posição e ângulo de acordo com o mesmo algoritmo!

Mover.prototype.update = function () {

    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);

    this.aVelocity += this.aAcceleration;
    this.angle += this.aVelocity;

    this.acceleration.mult(0);
};

Claro, para que isso tenha importância, também precisamos rotacionar o objeto quando o exibimos.

Mover.prototype.display = function () {
    stroke(0, 0, 0);
    fill(175, 175, 175, 200);
    rectMode(CENTER);

    // pushMatrix e popMatrix são necessárias para a rotação do objeto
    // não afeta o restante
    pushMatrix();
    // Define a origem na posição do objeto
    translate(this.location.x, this.location.y);
    // Rotaciona pelo ângulo
    rotate(this.angle);
    rect(0, 0, this.mass*16, this.mass*16);
    popMatrix();
};

Agora, se formos realmente em frente e executar o código acima, não veremos nada novo. Isso se deve ao fato de que a aceleração angular (this.aAcceleration = 0;) é inicializada em zero. Para que o objeto rotacione precisamos dar a ele uma aceleração! Certamente, poderíamos codificar em um número diferente:

this.aAcceleration = 0.01;

É assim que o programa fica com a lógica acima, com uma força calculada com base em um centro de atração:

É um bom começo, mas podemos produzir um resultado mais interessante atribuindo dinamicamente uma aceleração angular de acordo com as forças do ambiente - até porque objetos não giram por vontade própria! Agora, podemos ir bem longe neste caminho, tentando modelar a física da aceleração angular usando os conceitos de torque e momento de inércia. Esse nível de simulação está além do escopo deste curso - mas ainda vamos ficar um pouco mais complexo.

Por enquanto, uma solução rápida e suja servirá. Podemos produzir resultados razoáveis simplesmente calculando a aceleração angular em função do vetor de aceleração do objeto. Aqui está um exemplo:

this.aAcceleration = this.acceleration.x;

Sim, isso é completamente arbitrário. Mas isso faz alguma coisa. Se o objeto está acelerando para a direita, sua rotação angular acelera em sentido horário; acelerando para a esquerda resulta em uma rotação anti-horário. É claro que é importante pensar em escala neste caso. O componente x do vetor de aceleração pode ter uma quantidade muito grande, fazendo o objeto girar de uma forma que parece ridícula ou irreal. Portanto, dividindo o componente x por algum valor, ou talvez, restringindo a velocidade angular em um intervalo razoável, pode ajudar. Aqui está o método inteiro update() com estes ajustes adicionados.

Mover.prototype.update = function () {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);

    // Calcula a aceleração angular baseada na aceleração horizontal,
    //  e divide para que ela não seja tão forte
    this.aAcceleration = this.acceleration.x / 10.0;
    this.aVelocity += this.aAcceleration;

    // Aplica restrição para garantir que a velocidade não gire fora de controle
    this.aVelocity = constrain(this.aVelocity, -0.1, 0.1);
    this.angle += this.aVelocity;

    this.acceleration.mult(0);
};

É assim que o programa fica depois da implementação dessas mudanças:

Este curso "Natural Simulations" é um derivado do "The Nature of Code" por Daniel Shiffman, usado sob a Creative Commons Attribution-NonCommercial 3.0 Unported License.

Quer participar da conversa?

Entrar

Classificar por:

Nenhuma postagem por enquanto.

Você entende inglês? Clique aqui para ver mais debates na versão em inglês do site da Khan Academy.