sc2_common.h

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <cmath>
#include <cstdint>

namespace sc2 {

struct Point3D {
    float x;
    float y;
    float z;

    Point3D() :
        x(0.0f),
        y(0.0f),
        z(0.0f) {
    }

    Point3D(float in_x, float in_y, float in_z) :
        x(in_x),
        y(in_y),
        z(in_z) {
    }

    Point3D& operator+=(const Point3D& rhs);
    Point3D& operator-=(const Point3D& rhs);
    Point3D& operator*=(float rhs);
    Point3D& operator/=(float rhs);

    bool operator==(const Point3D& rhs) const;
    bool operator!=(const Point3D& rhs) const;
};

Point3D operator+(const Point3D& lhs, const Point3D& rhs);
Point3D operator-(const Point3D& lhs, const Point3D& rhs);
Point3D operator*(const Point3D& lhs, float rhs);
Point3D operator*(float lhs, const Point3D& rhs);
Point3D operator/(const Point3D& lhs, float rhs);
Point3D operator/(float lhs, const Point3D& rhs);

struct Point2D {
    float x;
    float y;

    Point2D() :
        x(0.0f),
        y(0.0f) {
    }

    Point2D(Point3D a) :
        x(a.x),
        y(a.y) {
    }

    Point2D(float in_x, float in_y) :
        x(in_x),
        y(in_y) {
    }

    Point2D& operator+=(const Point2D& rhs);
    Point2D& operator-=(const Point2D& rhs);
    Point2D& operator*=(float rhs);
    Point2D& operator/=(float rhs);

    bool operator==(const Point2D& rhs) const;
    bool operator!=(const Point2D& rhs) const;
};

Point2D operator+(const Point2D& lhs, const Point2D& rhs);
Point2D operator-(const Point2D& lhs, const Point2D& rhs);
Point2D operator*(const Point2D& lhs, float rhs);
Point2D operator*(float lhs, const Point2D& rhs);
Point2D operator/(const Point2D& lhs, float rhs);
Point2D operator/(float lhs, const Point2D& rhs);

typedef Point2D Vector2D;
typedef Point3D Vector3D;

struct Rect2D {
    Point2D from;
    Point2D to;
};

struct Point2DI {
    int x;
    int y;

    Point2DI(int in_x = 0, int in_y = 0) :
        x(in_x),
        y(in_y) {
    }

    Point2DI(const Point2D& point) :
        x(static_cast<int>(point.x)),
        y(static_cast<int>(point.y)) {
    }

    bool operator==(const Point2DI& rhs) const;
    bool operator!=(const Point2DI& rhs) const;
};

struct Rect2DI {
    Point2DI from;
    Point2DI to;

    Rect2DI() {
    }

    Rect2DI(const Point2DI& in_from, const Point2DI& in_to) :
        from(in_from),
        to(in_to) {
    }

    int Width() const;

    int Height() const;

    bool Contain(const sc2::Point2DI& point) const;
};

struct Color {
    uint8_t r;
    uint8_t g;
    uint8_t b;

    Color() :
        r(255),
        g(255),
        b(255) {
    }

    Color(uint8_t in_r, uint8_t in_g, uint8_t in_b) :
        r(in_r),
        g(in_g),
        b(in_b) {
    }
};

namespace Colors {
    static const Color White = Color(255, 255, 255);
    static const Color Red = Color(255, 0, 0);
    static const Color Green = Color(0, 255, 0);
    static const Color Yellow = Color(255, 255, 0);
    static const Color Blue = Color(0, 0, 255);
    static const Color Teal = Color(0, 255, 255);
    static const Color Purple = Color(255, 0, 255);
    static const Color Black = Color(0, 0, 0);
    static const Color Gray = Color(128, 128, 128);
};

float GetRandomScalar();
float GetRandomFraction();
int GetRandomInteger(int min, int max);

template <typename Container>
typename Container::value_type& GetRandomEntry(Container& container) {
    typename Container::iterator iter = container.begin();
    std::advance(iter, GetRandomInteger(0, static_cast<int>(container.size()) - 1));
    return *iter;
}

float Distance2D(const Point2D& a, const Point2D& b);
float DistanceSquared2D(const Point2D& a, const Point2D& b);
void Normalize2D(Point2D& a);
float Dot2D(const Point2D& a, const Point2D& b);

float Distance3D(const Point3D& a, const Point3D& b);
float DistanceSquared3D(const Point3D& a, const Point3D& b);
void Normalize3D(Point3D& a);
float Dot3D(const Point3D& a, const Point3D& b);

}