#include "precompile.h"

#include <math.h>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include "glmhelper.h"

const glm::vec3 GlmHelper::ZERO = glm::vec3(0.0f, 0.0f, 0.0f);
const glm::vec3 GlmHelper::RIGHT = glm::vec3(1.0f, 0.0f, 0.0f);
const glm::vec3 GlmHelper::UP = glm::vec3(0.0f, 0.0f, 1.0f);
const glm::vec3 GlmHelper::DONW = glm::vec3(0.0f, 0.0f, -1.0f);

void GlmHelper::RotateY(glm::vec3& v, float angle)
{
    auto transform =
        glm::rotate(
                    glm::mat4(1.0),
                    angle,
                    //glm::radians(angle),
                    glm::vec3(0.0f, 1.0f, 0.0f)
                    );
    glm::vec4 v1 = transform * glm::vec4(v.x, v.y, v.z, 0.0f);
    v.x = v1.x;
    v.y = v1.y;
    v.z = v1.z;
}

void GlmHelper::Normalize(glm::vec3& v)
{
    v = glm::normalize(v);
    if (isnan(v.x)) {
        abort();
    }
    if (isnan(v.y)) {
        abort();
    }
    if (isnan(v.z)) {
        abort();
    }
}

float GlmHelper::Norm(const glm::vec3& v)
{
    return glm::length(v);
}

float GlmHelper::Norm2D(const glm::vec3& v)
{
    glm::vec3 v2 = v;
    v2.y = 0.0f;
    return glm::length(v2);
}

bool GlmHelper::IsZero(const glm::vec3& v)
{
    return fabs(v.x) < 0.00001f && fabs(v.y) < 0.00001f && fabs(v.z) < 0.00001f;
}

float GlmHelper::CalcAngle(const glm::vec3& v1, const glm::vec3& v2)
{
    #if 1
    glm::vec3 v3 = v1;
    glm::vec3 v4 = v2;
    v3.y = 0.0f;
    v4.y = 0.0f;
    float angle = acos(glm::dot(v3, v4) / Norm(v3) / Norm(v4));
    #else
    float angle = acos(glm::dot(v1, v2) / Norm(v1) / Norm(v2));
    #endif
    return angle / 3.1415926f;
}

void GlmHelper::FillVert(const glm::vec3& v, float* vert)
{
    vert[0] = v.x;
    vert[1] = v.y;
    vert[2] = v.z;
}

bool GlmHelper::IsEqual2D(const glm::vec3& v1, const glm::vec3& v2)
{
    return std::abs(v1.x - v2.x) < 0.00001f && std::abs(v1.z - v2.z) < 0.00001f;
}

bool GlmHelper::IsEqual3D(const glm::vec3& v1, const glm::vec3& v2)
{
    return std::abs(v1.x - v2.x) < 0.00001f &&
           std::abs(v1.y - v2.y) < 0.00001f &&
           std::abs(v1.z - v2.z) < 0.00001f;
}

glm::vec3 GlmHelper::Vec2ToVec3(const glm::vec2& v2)
{
    return glm::vec3(v2.x, 0.0f, v2.y);
}