# data[].attributes.body
void Degree()

{

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

double result = (glm::dot(v, u)) / (glm::length(v) * glm::length(u));

double resultDegree = glm::acos(result) * RADIANS_TO_DEGREES;

std::cout << "Degree result: " << resultDegree << std::endl;

}

int main()

{

Degree();

return 0;

}

# data[].attributes.body
#include <iostream>

#include <glm/glm.hpp>

#include <glm/gtc/constants.hpp>

int main() {

const double RADIANT_TO_DEGREE = 180.0 / glm::pi<float>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float oe = glm::dot(u, v) / (glm::length(v) * glm::length(u));

float degrees = glm::acos(oe) * RADIANT_TO_DEGREE;

std::cout << "Result : " << degrees << " degrees" << std::endl;

return 0;

}

# data[].attributes.body
#include <glm/glm.hpp>

#include <glm/gtc/constants.hpp>

float dotProduct()

{

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float c = d / (glm::length(u) * glm::length(v));

float deg = glm::acos(c) * RADIANS_TO_DEGREES;

return deg;

}

int main()

{

std::cout << "Result : " << dotProduct() << std::endl;;

return 0;

}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include <iostream>

#include <glm/vec3.hpp>
#include <glm/gtx/string_cast.hpp>
#include <glm/gtc/constants.hpp>

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);
	float dotProduct = glm::dot(v, u);
	float angle = dotProduct / (glm::length(v) * glm::length(u));
	float deg = glm::degrees(glm::acos(angle));
	std::cout << "Angle between vectors v(2, -1, 1) and u(1, 1, 2): " << deg << std::endl;
	return 0;
}

# data[].attributes.body
// CMakeProject1.cpp : Defines the entry point for the application.
//

#define GLM_ENABLE_EXPERIMENTAL

#include "CMakeProject1.h"

#include "iostream"
#include "glm/gtc/constants.hpp"
#include "glm/vec3.hpp"
#include "glm/glm.hpp"
#include "glm/gtx/string_cast.hpp"

using namespace std;


int main()
{
	const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();
	const glm::vec3 v(2, -1, 1);
	const glm::vec3 u(1, 1, 2);

	const auto dot = glm::dot(u, v) / (glm::length(u) * glm::length(v));

	const auto θ = std::acos(dot);

	const auto θdegress = RADIANS_TO_DEGREES * θ;

	std::cout << θdegress << std::endl;

	return 0;
}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include <glm/vec3.hpp>
#include <glm/gtx/string_cast.hpp>
#include <glm/gtc/constants.hpp>
#include <iostream>
#include "dotProduct.h"

static void dotProduct()
{
	glm::vec3  v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float dot = glm::dot(v, u);
	float c = dot / (glm::length(u) * glm::length(v));
	float angle = glm::degrees(glm::acos(c));

	std::cout << angle << " degrees" << std::endl;
}

int main()
{
	dotProduct();
	return 0;
}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include <glm/gtc/constants.hpp>

#include <glm/gtx/string_cast.hpp>

#include <iostream>

float getAngleFromVector(glm::vec3 v, glm::vec3 u)

{

float d = glm::dot(v, u);

float a = glm::length(u) * glm::length(v);

float res = d / a;

return glm::degrees(glm::acos(res));

}

int main()

{

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float a = glm::length(u) * glm::length(v);

float res = d / a;

std::cout << "vector v = " << glm::to_string(v) << " vector u = " << glm::to_string(v) << std::endl;

std::cout << "radian = " << glm::acos(res) << std::endl;

std::cout << "Degre = " << getAngleFromVector(v, u) << std::endl;

return 0;

}

# data[].attributes.body
#include <glm/gtc/constants.hpp>
#include <glm/glm.hpp>

#include <iostream>

const float DEGREES_TO_RADIANS = 180.0 / glm::pi<float>();

int main()
{
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float dotProduct = glm::dot(v, u);
    float angle = glm::acos(dotProduct / (glm::length(u) * glm::length(v)));
    float angleDeg = glm::degrees(angle);

    std::cout << "Angle between u and v: " << angleDeg << " degrees" << std::endl;
	return 0;
}

# data[].attributes.body
#include <iostream>

#include "glm/glm.hpp"

#include "glm/gtc/constants.hpp"

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

int main()

{

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float dot = glm::dot(v, u);

float cos = dot / (glm::length(u) * glm::length(v));

float degrees = glm::acos(cos) * RADIANS_TO_DEGREES;

std::cout << "Angle = " << degrees << std::endl;

return 0;

}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include <glm/gtc/constants.hpp>
#include <iostream>
#include <glm/glm.hpp>
#include <glm/gtx/string_cast.hpp>

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	const float lu = glm::length(u);
	const float lv = glm::length(v);
	if (lu == 0 || lv == 0) {
		std::cerr << "length of u or v can't be 0" << std::endl;
		return 1;
	}
	const float radAngle = glm::dot(u, v) / (lu * lv);
	std::cout << "Result: " << glm::degrees(glm::acos(radAngle));
	return 0;
}

# data[].attributes.body
#include <glm/gtc/constants.hpp>

#include <glm/vec3.hpp>

#include <glm/glm.hpp>

#include "CMakeProject2.h"

#include <iostream>

const float DEGREES_TO_RADIANTS = glm::pi<float>() / 180.0f;

const float RADIANTS_TO_DEGREES = 180.0f / glm::pi<float>();

int main() {

	glm::vec3 v1{2, -1, 1};

	glm::vec3 v2{1, 1, 2};

	float dot = glm::dot(v1, v2);

	float angle = glm::acos(dot / (glm::length(v1) * glm::length(v2)));

	float degree_angle = RADIANTS_TO_DEGREES * angle;

	std::cout << "Radiant : " << angle << "\nDegrees : " << degree_angle << std::endl;

	return 0;

}

# data[].attributes.body
// CMakeProject2.cpp : définit le point d'entrée de l'application.

//

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_FORCE_SWIZZLE

#include "glm/gtx/string_cast.hpp"

#include "CMakeProject2.h"

#include "glm/glm.hpp"

#include <glm/gtc/constants.hpp>

using namespace std;

int main()

{

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float res = glm::acos(glm::dot(v, u) / (glm::length(v) glm::length(u))) RADIANS_TO_DEGREES;

std::cout << res;

return 0;

}

# data[].attributes.body
#include <iostream>

#include <glm/glm.hpp>

#include <glm/gtc/constants.hpp>

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

int main(void)

{

float dot = glm::dot(u, v);

float formula = dot / (glm::length(u) * glm::length(v));

float result = glm::acos(formula) * RADIANS_TO_DEGREES;

std::cout << "Result: " << result << std::endl;

return 0;

}

# data[].attributes.body
glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float scalar = glm::dot(v, u);

float radiant = scalar / (glm::length(u) * glm::length(v));

float angle = glm::degrees(glm::acos(radiant));

std::cout << angle << std::endl;

# data[].attributes.body
#include <iostream>
#include <glm/vec3.hpp>// vec3, bvec3, dvec3, ivec3 and uvec3
#include <glm/gtc/constants.hpp>

#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/string_cast.hpp>

const float DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;
const float RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

int main() {

    glm::vec3 v(2,-1,1);
    glm::vec3 u(1,1,2);

    float dotRes = glm::dot(v, u);
    float cos = dotRes / (glm::length(u) * glm::length(v));
    float deg = glm::degrees(glm::acos(cos));

    std::cout << "deg of ang = " << deg << std::endl;
    return 0;
}

# data[].attributes.body
#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include "CMakeProject1.h"

#include <glm/glm.hpp>

#include <glm/gtx/string_cast.hpp>

#include <glm/gtc/constants.hpp>

using namespace std;

int main()

{

const float DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const float RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

cout << "Result 1: " << glm::degrees(acos(d / (glm::length(v) * glm::length(u)))) << endl;

return 0;

}

# data[].attributes.body
int main()
{
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);


	float d = glm::dot(v, u);
	float c = d / (glm::length(u) * glm::length(v));
	float deg = glm::acos(c) * RADIANS_TO_DEGREES;

	cout << "degrees: " << deg << endl;
	return 0;
}

# data[].attributes.body
int main() {

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float DP = glm::dot(v, u);

float cosD = DP / (glm::length(v) * glm::length(u));

float R = glm::acos(cosD);

float D = glm::degrees(R);

std::cout << "degree = " << D << std::endl;

return 0;

}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtc/constants.hpp>
#include <glm/vec3.hpp>
#include <glm/common.hpp>
#include <glm/gtx/string_cast.hpp>
#include <iostream>

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;
const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

int main()
{
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float dotResult = glm::dot(u, v);
	float cosResult = dotResult / (glm::length(u) * glm::length(v));
	float angle = glm::acos(cosResult) * RADIANS_TO_DEGREES;
	std::cout << "Angle: " << angle << std::endl;
}

# data[].attributes.body
#include "Source.h"

#include <glm/gtc/constants.hpp>

#include <glm/glm.hpp>

int ex_dot_product_practice()

{

constexpr double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

constexpr double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float c = d / (glm::length(u) * glm::length(v));

float deg = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout << "result: " << deg << std::endl;

return 0;

}

# data[].attributes.body
#include "class3.h"

#include <iostream>

#include <glm/glm.hpp>

#include <glm/gtc/constants.hpp>

int main()

{

constexpr double DEGREES_TO_RADIANS = glm::pi<double>() / 180.0;

constexpr double RADIANS_TO_DEGREES = 180.0 / glm::pi<double>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float c = d / (glm::length(u) * glm::length(v));

float deg = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout << deg << std::endl;

return 0;

}

# data[].attributes.body
#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include <iostream>

#include <glm/glm.hpp>

#include <glm/gtx/string_cast.hpp>

#include <glm/gtc/constants.hpp>

const float DEGREES_TO_RADIANS = glm::pi <float>() / 180;

const float RADIANS_TO_DEGREES = 180 / glm::pi <float>();

static void dotTrain() {

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float dp = glm::dot(v, u);

float a = glm::acos(dp / (glm::length(v) * glm::length(u)));

std::cout << a * RADIANS_TO_DEGREES << std::endl;

}

int main() {

dotTrain();

return 0;

}

# data[].attributes.body
#include <glm/gtc/constants.hpp>
#include <iostream>
#include <glm/glm.hpp>

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	const float result_deg = glm::acos(glm::dot(v, u) / (glm::length(v) * glm::length(u)));
	std::cout << glm::degrees(result_deg) << std::endl;
}

# data[].attributes.body
#include <iostream>

#include <glm/vec3.hpp>
#include <glm/gtc/constants.hpp>
#include <glm/detail/func_geometric.inl>
#include <glm/detail/func_trigonometric.inl>

const float DEGREES_TO_RADIANS = glm::pi<float>() / 180.0f;
const float RADIANS_TO_DEGREES = 180.0f / glm::pi<float>();

int main(void) {
    glm::vec3 v(2,-1,1);
    glm::vec3 u(1,1,2);
    float d = glm::dot(v, u);
    float c = d / (glm::length(u) * glm::length(v));
    float deg = glm::acos(c)*RADIANS_TO_DEGREES;

    std::cout << "Dot product: " << d << std::endl;
    std::cout << "Cosine: " << c << std::endl;
    std::cout << "Angle: " << deg << std::endl;

    return 0;
}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include "CMakeProject1.h"

#include <glm/vec3.hpp>

#include <glm/gtc/constants.hpp>

#include <glm/gtx/string_cast.hpp>

int main()

{

glm::vec3 v{ 2, -1, 1 };

glm::vec3 u{ 1, 1, 2 };

float angle{glm::acos((glm::dot(v, u) / (glm::length(v) * glm::length(u))))};

float final{ glm::degrees(angle) };

std::cout << final << '\n';

return 0;

}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/glm.hpp>
#include <glm/gtx/string_cast.hpp>
#include <iostream>
#include <stdexcept>

int main() {
  glm::vec3 u(2, -1, 1);
  glm::vec3 v(1, 1, 2);

  float lu = glm::length(u);
  float lv = glm::length(v);

  if (lu == 0 or lv == 0) {
    throw std::runtime_error("div by zero");
  }
  float angleUV = glm::acos(glm::dot(u, v) / (lu * lv));

  std::cout << "angle is " << glm::degrees(angleUV) << " degrees" << std::endl;
  return 0;
}

# data[].attributes.body
#include <glm/gtc/constants.hpp>
#include <glm/glm.hpp>
#include <iostream>

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float d = glm::dot(v, u);
	float c = d / (glm::length(u) * glm::length(v));
	float deg = glm::acos(c) * glm::degrees(1.0f);

	std::cout << "The angle between the vectors is " << deg << " degrees." << std::endl;

	return 0;
}

# data[].attributes.body
#include <glm/gtc/constants.hpp>
#include <glm/glm.hpp>

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;
const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

int main(void) {
    glm::vec3 v(2, -1, 1);
    glm::vec3 u(1, 1, 2);

    float dot = glm::dot(v, u);

    float cos = dot / (glm::length(v) * glm::length(u));
    float deg = glm::acos(cos) * RADIANS_TO_DEGREES;

    std::cout << "Angle between vectors: " << deg << " degrees" << std::endl;
}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include <iostream>

#include <glm/glm.hpp>
#include <glm/gtx/string_cast.hpp>

float ex1()
{
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);
	float d = glm::dot(v, u);
	float c = d / (glm::length(u) * glm::length(v));
	return glm::degrees(glm::acos(c));
}

int main()
{
	std::cout << "Ex 1: " << ex1() << std::endl;
	return (0);
}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include <glm/glm.hpp>

#include <iostream>

#include <glm/gtx/string_cast.hpp>

int main(void)

{

glm::vec3 v1(2, -1, 1);

glm::vec3 v2(1, 1, 2);

float dot = glm::dot(v1, v2);

float len = glm::length(v1) * glm::length(v2);

float r1 = dot / len;

float r2 = glm::degrees(glm::acos(r1));

std::cout << r2 << std::endl;

}

# data[].attributes.body
// // src/main.cpp
#define GLM_ENABLE_EXPERIMENTAL
#define GLM_FORCE_SWIZZLE

#include <fmt/core.h> // Include fmt library
#include <glm/glm.hpp>
#include <glm/gtx/string_cast.hpp>
#include <iostream>

#include <glm/gtc/constants.hpp>

int main() {
    const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;
    const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();


    glm::vec3 v(2,-1,1);
    glm::vec3 u(1,1,2);

    float d = glm::dot(u, v);
    float angle = glm::acos((d / (glm::length(v) * glm::length(u)))) * RADIANS_TO_DEGREES;

    std::cout << "Angle is: " << angle << std::endl;


    return 0;
}

# data[].attributes.body
#include <iostream>

#include <glm/glm.hpp>

# define GLM_ENABLE_EXPERIMENTAL

#include <glm/gtx/string_cast.hpp>

using namespace std;

int main()

{

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

const float dot = glm::dot(v, u);

const float cos = dot / (glm::length(v) * glm::length(u));

const float res = glm::acos(cos) * RADIANS_TO_DEGREES;

cout << res << endl;

return 0;

}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include <glm/glm.hpp>

#include <glm/gtx/string_cast.hpp>

#include <glm/gtc/constants.hpp>

#include <iostream>

int main(void) {

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float c = d / (glm::length(u) * glm::length(v));

float deg = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout << "v: " << glm::to_string(v) << std::endl;

std::cout << "u: " << glm::to_string(u) << std::endl;

std::cout << "d: " << d << std::endl;

std::cout << "c: " << c << std::endl;

std::cout << "deg: " << deg << std::endl;

std::cout << "rad: " << glm::radians(deg) << std::endl;

return 0;

}

# data[].attributes.body
#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include <glm/gtx/string_cast.hpp>

#include <glm/gtc/constants.hpp>

#include <glm/glm.hpp>

#include <iostream>

int main()

{

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v (2, -1, 1);

glm::vec3 u (1, 1, 2);

float dot = glm::dot(v, u);

float result = dot / (glm::length(u) * glm::length(v));

float degrees = glm::acos(result) * RADIANS_TO_DEGREES;

std::cout << degrees << std::endl;

return 0;

}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL

#include <glm/glm.hpp>

#include <iostream>

#include <glm/gtc/constants.hpp>

int main()

{

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>()

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float dot = glm::dot(v, u);

float angle = glm::acos(dot / (glm::length(v) glm::length(u))) * RADIANS_TO_DEGREES;

std::cout << "Angle between v and u: " << angle << std::endl;

return 0;

}

# data[].attributes.body
#include <iostream>

#include <glm/glm.hpp>

#include <glm/gtc/constants.hpp>

int main() {

const double DEGREES_TO_RADIANS = glm::pi<float>() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi<float>();

glm::vec3 v(2,-1,1);

glm::vec3 u(1,1,2);

float deg = (glm::acos(glm::dot(v,u) / (glm::length(v) glm::length(u)))) RADIANS_TO_DEGREES;

std::cout << "Angle between vectors: " << deg << std::endl;

return 0;

}

# data[].attributes.body
#define GLM_ENABLE_EXPERIMENTAL
    #include <glm/gtx/string_cast.hpp>
    #include <glm/glm.hpp>
#include <iostream>

float CalculateDegrees(const glm::vec3 &v, const glm::vec3 &u)
{
    float dot     = glm::dot(v, u);
    float lengthV = glm::length(v);
    float lengthU = glm::length(u);

    return glm::degrees(acos(dot / (lengthV * lengthU)));
}

int main()
{
    glm::vec3 v(2.f, -1.f, 1.f);
    glm::vec3 u(1.f,  1.f, 2.f);

    float angle = CalculateDegrees(v, u);

    std::cout << "Angle between v and u : " << angle << std::endl;
    return 0;
}

# data[].attributes.body
#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include <iostream>

#include <glm/glm.hpp>

#include <glm/gtx/string_cast.hpp>

#include <glm/gtc/constants.hpp>

const double DEG_TO_RAD = glm::pi<double>() / 180.0;

const double RAD_TO_DEG = 180.0 / glm::pi<double>();

int main()

{

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

const double v_dot_u = glm::dot(v, u);

const double v_angle_u = glm::acos(v_dot_u / (glm::length(v) glm::length(u))) RAD_TO_DEG;

std::cout << "v angle u: " << v_angle_u << std::endl;

return 0;

}

# data[].attributes.body
#include <iostream>

#define GLM_ENABLE_EXPERIMENTAL

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

const float DEGREES_TO_RADIANS = 180.0 / glm::pi<float>();

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float d = glm::dot(v, u);
	float lengths = glm::length(u) * glm::length(v);
	float degree = glm::acos(d / lengths);
	std::cout << "Result 1:" << glm::degrees(degree) << std::endl;
	std::cout << "Result 2:" << degree * DEGREES_TO_RADIANS << std::endl;

	return 0;
}