spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

template<typename T>
class Vec2
{
public:
    T x;
    T y;
};
//Operatoren...
template<typename VectorType>
Vec2<VectorType> interpolate(const Vec2<VectorType> v1, const Vec2<VectorType>& v2, double inter)
{
    //Funktion interpoliert zwischen zwei Punkten
    assert(0. >= inter && inter <= 1.);

    double inter1 = 1. - inter;

    return Vec2<VectorType>(inter1 * v1.x + inter * v2.x,
                            inter1 * v1.y + inter * v2.y);
}

C-/C++-Quelltext

void makeCircle(Vec2<float> middle, float radius, std::vector<Vec2<float>>& circleVec, unsigned int phiBegin = 0U, unsigned int phiEnd = 360U)
{
    //wenn der angegebene Beginner-Winkel größer als der End-Winkel ist,
    //macht dieser Funktionscall schon keinen Sinn mehr. 
    if(phiBegin > phiEnd)
        throw std::invalid_argument("phiBegin needs to be smaller than phiEnd!");

    //Durchlaufe alle gewollten Winkel
    for(unsigned int phi = phiBegin; phi < phiEnd; ++phi)
    {
        Vec2<float> v;
        v.x = radius * std::sin(phi * 3.1415926f / 180.0f) + middle.x;
        v.y = radius * std::cos(phi * 3.1415926f / 180.0f) + middle.y;

        //Füge Winkel dem angegebenem Container hinzu
        circleVec.push_back(v);
    }
}

C-/C++-Quelltext

void getNewPath(const std::vector<Vec2<float>>& fromPath, float percent, std::vector<Vec2<float>>& newPath, int depth = -2)
//depth beschreibt wie kleinschrittig gearbeitet werden soll. Wert ist der Exponent zur Basis 10
//-2 ist schon ziemlich klein schrittig
{
    //Wenn die angegebenen Prozent an Fülle nicht größer 0 und kleiner 1 sind, läuft was schief
    if(0.f > percent || percent > 1.f)
        throw std::invalid_argument("percentage is wanted. Something smaller 0 or bigger 1 is no percentage");
    //Ist die Tiefe größer 0, gehen wir in mehr als 100% Schritten weiter.... Macht keinen Sinn. Schon depth=0 macht eher selten Sinn
    if(depth > 0)
        throw std::invalid_argument("depth should be smaller than 1");

    //Punkt ermitteln, der auf dem Graphen liegt und zum Prozentwert passt
    unsigned int index0 = static_cast<unsigned int>(percent * fromPath.size());

    //Wenn der nächste Index benutzbar ist, kanns losgehen
    if(index0 + 1U < fromPath.size())
    {
        //Nun wird der Wert ermitteln, zwischen dem interpoliert wird, schließlich bleiben eventuell noch ein paar Promille über
        unsigned int index1 = index0 + 1U;

        //Um einen Prozentwert relativ zu diesen zu interpolierenden Punkten zu erhalten, müssen wir unseren angegebenen erst einmal "konvertieren"
        double pathPercent = static_cast<double>(index0) / fromPath.size();

        //Bis zu index0 kommt aber auf jeden Fall alles vom alten in den neuen Pfad
        newPath.insert(newPath.end(), fromPath.begin(), fromPath.begin() + index0);

        //Solange i nun kleiner als unser "konvertierter" Wert ist, interpolieren wir
        for(double i = 0.; i < percent - pathPercent; i += std::pow(10, depth))
        {
            // i gibt nun unsere Prozent an, die wir interpolieren
            newPath.push_back(interpolate(fromPath[index0], fromPath[index1], i));
        }
    }
    else
    {
        //Der neue Pfad ist der alte Pfad, nichts hat sich geändert.
        newPath.insert(newPath.end(), fromPath.begin(), fromPath.end());
    }
}