skein/src/orbit.cpp

#include "orbit.hpp"

#include "astro/stateVectorIndices.hpp"
#include "astro/orbitalElementConversions.hpp"

Orbit::Orbit(int vertexCount) :
    _keplerianElements(std::vector<float>(6))
{
    _keplerianElements[astro::semiMajorAxisIndex] = .75;
    _keplerianElements[astro::eccentricityIndex] = .5;
    _keplerianElements[astro::inclinationIndex] = _pi / 2.0 + 1;
    _keplerianElements[astro::argumentOfPeriapsisIndex] = 2.0;
    _keplerianElements[astro::longitudeOfAscendingNodeIndex] = 0;

    for (int i = 0; i < vertexCount; i++)
    {
        float t = (float)i / (float)vertexCount * 2.0 * _pi;
        glm::vec3 pos = getPosition(t);

        _vertices.push_back(pos.x);
        _vertices.push_back(pos.y);
        _vertices.push_back(pos.z);
    }

    glGenVertexArrays(1, &_vao);
    glGenBuffers(1, &_vbo);

    glBindVertexArray(_vao);

    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
    size_t vboBufferSize = _vertices.size() * sizeof(float);
    glBufferData(GL_ARRAY_BUFFER, vboBufferSize, &_vertices[0], GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);
}

// Interpolate a position around the orbit.
// t is in range 0..1 and wraps.
glm::vec3 Orbit::getPosition(const float meanAnomaly)
{
    // Get eccentric anomaly from elliptical mean anomaly
    const float eccentricity = _keplerianElements[astro::eccentricityIndex];
    float eccentricAnomaly = astro::convertEllipticalMeanAnomalyToEccentricAnomaly(
        eccentricity,
        meanAnomaly,
        (float)10e-3,
        100);

    // Get true anomaly from eccentric anomaly
    float trueAnomaly = astro::convertEccentricAnomalyToTrueAnomaly(
        eccentricAnomaly,
        eccentricity);

    std::vector<float> kepler(_keplerianElements);
    kepler[astro::trueAnomalyIndex] = trueAnomaly;

    std::vector<float> cartesian = astro::convertKeplerianToCartesianElements(kepler, 1.0);
    return glm::vec3(
        cartesian[astro::xPositionIndex],
        cartesian[astro::yPositionIndex],
        cartesian[astro::zPositionIndex]);
}

glm::vec3 Orbit::getTangent(const float meanAnomaly)
{
    float epsilon = 0.01;
    glm::vec3 ahead = getPosition(meanAnomaly + epsilon);
    glm::vec3 behind = getPosition(meanAnomaly - epsilon);
    return glm::normalize(ahead - behind);
}

void Orbit::render()
{
    glBindVertexArray(_vao);
    glBindBuffer(GL_ARRAY_BUFFER, _vbo);

    glDrawArrays(GL_LINE_LOOP, 0, _vertices.size() / 3);
}

Orbit::~Orbit()
{
    glDeleteVertexArrays(1, &_vao);
    glDeleteBuffers(1, &_vbo);
}