Project an object with rotation around another object in C++/OpenGL

Question

I'm Using OpenGL/C++ to create a game.

One aspect of this game that I'm working on is having a character that shoots a projectile the way said character is facing. To do this I have a 'player' and a 'projectile'.

I pass to the projectile the characters x and y co-ordinates, the angle the player is facing. From this I want to shoot the projectile in that direction.

In my draw I am currently using glTranslate with the characters x and y and rotating the projectile on the way the character is facing. This moves my projectile to the way the player is facing.

glTranslatef(this->m_X, this->m_Y, 0);
        glRotatef(angle, 0, 0, 1);

This is where i'm stuck, I can move the projectile position by incrementing/decrementing the X and Y values in the translate. But what I'm trying to ask is how can I move the projectile along the line the player is facing.

Thanks for the help!

Answer 1

You can use polar vectors for these calculations.

http://mathworld.wolfram.com/PolarVector.html

A polar vector will allow you to make several calculations that would normally be complicated and convoluted in a simple way. Using their applied mathematics your request won't be an issue.

Here's an implementation of mine of polar vectors.

The header file:

#include <cmath>

//Using SFML Vector2 class, making a similar class is easy.
//Check this URL: http://www.sfml-dev.org/documentation/2.3.2/classsf_1_1Vector2.php

class PolarVector 
{
    public:
        float r;
        float t; ///Angle stored in degrees.

        PolarVector();
        PolarVector(float radius, float angle);
        PolarVector(const sf::Vector2f V2); ///Conversion constructor.

        sf::Vector2f TurnToRectangular() const;

};

PolarVector TurnToPolar(const sf::Vector2f point);

float getConvertedRadius(const sf::Vector2f point);

float getConvertedAngle(sf::Vector2f point);

bool operator ==(const PolarVector& left, const PolarVector& right);

bool operator !=(const PolarVector& left, const PolarVector& right);

And the source file:

#include "PolarVector.hpp"

PolarVector::PolarVector()
  :r(0.f)
  ,t(0.f)
{}

PolarVector::PolarVector(float radius, float angle)
  :r(radius)
  ,t(angle)
{}

PolarVector::PolarVector(const sf::Vector2f V2)
 :r(getConvertedRadius(V2))
 ,t(getConvertedAngle(V2))
{}

sf::Vector2f PolarVector::TurnToRectangular() const
{ return sf::Vector2f(static_cast<float>(r* std::cos(t)),    static_cast<float>(r* std::sin(t))); }

PolarVector TurnToPolar(const sf::Vector2f point)
{
    PolarVector PV;
    PV.r = getConvertedAngle(point);
    PV.t = getConvertedRadius(point);
    return PV;
}

float getConvertedRadius(const sf::Vector2f point)
{ return std::sqrt((point.x * point.x) + (point.y * point.y) ); }

float getConvertedAngle(const sf::Vector2f point)
{ return std::atan2(point.y, point.x); }

bool operator ==(const PolarVector& left, const PolarVector& right)
{
    float diffR = left.r - right.r;
    float diffA = left.t - right.t;
    return ((diffR <= EPSILON) && (diffA <= EPSILON));
}

bool operator !=(const PolarVector& left, const PolarVector& right)
{
    float diffR = left.r - right.r;
    float diffA = left.t - right.t;
    return !((diffR <= EPSILON) && (diffA <= EPSILON));
}

The reason why I suggest this is because you can do the following.

Let's say you have a 2 dimensional vector:

sf::Vector2f character(0.f, 0.f); //Origin point. First parameter is X, second is Y
float angleCharFacesAt = 0.698132; //40 degrees in radians. C++ Trigonometry uses Radians. std::cos, std::sin and std::atan2 are used internally.

For the first object or character. You want the other object to have the same angle, but a different position.

Let's say the other object has a position above it:

sf::Vector2f object(0.f, 10.f); //Above the origin point.
float angleObjectFacesAt = 0.f; //0 degrees.

So all you need to do is rotate it using a polar vector:

PolarVector PV = TurnToPolar(object); //Use this for calculations.
PV.t += angleCharFacesAt; //t is the angle parameter of the polar vector.

object = PV.TurnToRectangular(object);

By doing this you will get the rotated position of the object.

The distance between one object and the other will always be the r (Radius) value of the polar vector. So you could make the distance longer or shorter by doing this:

PolarVector PV = TurnToPolar(object); //Use this for calculations.
PV.r += 10; //Increase the radius to increase the distance between the objects.

object = PV.TurnToRectangular(object);

You should try to understand the rotation matrix and polar math to be able to achieve more things with this, but with this code it is possible. You should also put all this code in a class, but first play with it until you understand it well.

Sorry for the lengthy answer, but this is a topic that isn't very easy to explain without delving into linear algebra. The classes are for actual code manageability (I use these in my own game), but you can reproduce the same effects with the calculations only.

I personally prefer Polar Vectors over using the rotation matrix due to their usefulness in more than just rotating an object. But here's a link to understanding the rotation matrix better: https://en.wikipedia.org/wiki/Rotation_matrix

After you've done the transformation with the polar vector, you can just glTranslate to the final position given by the polar vector. You have to make sure that you rotate around the origin you are using. Otherwise rotation might not occur as you desire to use it.