내적연습 by Mankyu Sung

5763908_김동선

qwersd3348 — 2025-09-15 05:00:41 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

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

glm::vec3 v(2.0f, -1.0f, 1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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 와 u의 각도: "<

return 0;

}

5763848_강승우

seungu286 — 2025-09-15 05:00:46 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main() {

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

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

glm::vec3 v(2.0f, -1.0f,1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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

std::cout <<"v, u deg: " << deg << std::endl;

return 0;

}

5763973_김영인

2025-09-15 05:00:55 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

const double RADIANS_TO_DEGREES = 180.0 / glm::pi(); //세타는 무조건 라디안

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 res = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout<

return 0;

}

5881327_박인엽

inyup1014 — 2025-09-15 05:01:14 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

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;

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

return 0;

}

5469640_서보성

ssbss0329 — 2025-09-15 05:01:24 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

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

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;

}

5645974_김재현

2025-09-15 05:02:17 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

const double RADIAN_TO_DEGREES = 180.0 / glm::pi();

int main()

{

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

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

float up = dot(v, u);

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

float answer = up / down;

float degree = glm::acos(answer) * RADIAN_TO_DEGREES;

std::cout << degree << std::endl;

return 0;

}

5881375_서민기

2025-09-15 05:02:29 UTC

//Q1

#define GLM_ENABLE_EXPERIMENTAL

#include

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

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

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;

std::cout << deg;

return 0;

}

//Q2

#include

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

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

int main()

{

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

glm::vec3 a;

glm::vec3 b;

glm::vec3 c (0, 1, 0);

a = v - b;

b = c (v c);

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

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

retrun 0;

}

5764232_최영환

2025-09-15 05:02:51 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

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;

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

return 0;

}

5763865_권기환

rnjs498913 — 2025-09-15 05:03:07 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

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

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

int main() {

glm::vec3 v(2.0f, -1.0f, 1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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

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

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

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

return 0;

}

5764020_노도현

2025-09-15 05:03:21 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

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

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

int main() {

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

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

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

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

float angle = glm::acos(b) * RADIANS_TO_DEGREES;

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

return 0;

}

5702680_정상윤

2025-09-15 05:03:22 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

const double DEREES_TO_RADIANS = glm::pi() / 180.0;

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

int main()

{

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

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

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

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

return 0;

}

5881470_이동우

2025-09-15 05:03:31 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main() {

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

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

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;

}

5764201_차승재

2025-09-15 05:03:38 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

using namespace std;

int main(){

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

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

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

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

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

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

float e = d / c;

e = glm::acos(e) * RADIANS_TO_DEGREES;

cout << e << endl;

return 0;

}

5881634_황윤희

2025-09-15 05:04:19 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main()

{

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

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

glm::vec3 v(2.0f, -1.0f, 1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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;

}

5763882_김규태

2025-09-15 05:04:34 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main() {

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

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

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

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

float a = glm::dot(v, u); //벡터 v, c 내적

float b = glm::length(v) * glm::length(u); //벡터 v, c 크기 곱

float r = a / b; //코사인 값 구하기

float angle = acos(r) * RADIANS_TO_DEGREES; //코사인 값을 각도로 변환

std::cout << "cos(v,u) = " << angle << std::endl;

return 0;

}

5881452_오예림

2025-09-15 05:04:51 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

using namespace std;

int main() {

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

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

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

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

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

cout << "Dot: " << d << endl;

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

cout << "Cosine: " << c << endl;

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

cout << "Degrees: " << deg << endl;

return 0;

}

5646139_설문관

hyoseong01 — 2025-09-15 05:04:53 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

const double DEGREES_TO_RADIANS = glm::pi() / 180.0f;

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

int main()

{

/*glm::vec3 v(7, 3, -2);

glm::vec3 u(10, 4, 2);

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

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

return 0;*/

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

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

//내적

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

//거리 곱

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

std::cout << glm::acos(a/b) * RADIANS_TO_DEGREES << std::endl;

}

5764107_오제휴

ohjh6190 — 2025-09-15 05:05:19 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

const double DEGREE_TO_RADIANS = glm::pi() / 180.0;

const double RADIANS_TO_DEGREE = 180.0 / glm::pi();

glm::vec3 v(2.0f, -1.0f, 1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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

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

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

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

5585435_안재현

ajh20000523 — 2025-09-15 05:05:23 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main()

{

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

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

glm::vec3 v(2.0f, -1.0f, 1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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;

}

5855134-응엔만히에우

manhhieuptneu — 2025-09-15 05:06:10 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

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

glm::vec3 v(2.0f, -1.0f, 1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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;

}

5820658_전형진

2025-09-15 05:06:15 UTC

// main.cpp

// 5820658 전형진, 2025-09-15

#define GLM_ENABLE_EXPERIMENTAL

#include

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

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

glm::vec3 v, u;

float c, d, deg;

int main()

{

// DOT PRODUCT

v = glm::vec3(2.0f, -1.0f, 1.0f);

u = glm::vec3(1.0f, 1.0f, 2.0f);

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

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

deg = (glm::acos(c) *RAD_TO_DEG);

std::cout << "\nDOT PRODUCT ANSWER : " << deg; // print the answer

std::cout << "\n5820658 전형진 과제 끝." << std::endl;

return 0; // end program

}

5764095_오도혁

2025-09-15 05:06:16 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

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;

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

return 0;

}

5820553_이보은

2025-09-15 05:07:37 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

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

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 << std::to_string(deg) << std::endl;

return 0;

}

5764186_정현욱

2025-09-15 05:08:20 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

const double RADIANS_TO_DEGREES = 180.0 / glm::pi(); //세타는 무조건 라디안

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 res = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout<

return 0;

}

5763939_김민성

2025-09-15 05:09:32 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

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 res = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout << res;

return 0;

}

5881253_김인혜

2025-09-15 05:09:47 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

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;

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

return 0;

}

5881560 정재현

ddorangii — 2025-09-15 05:12:04 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_FORCE_SWIZZLE

#include

int main() {

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

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

float rma = 180 / glm::pi(); // 라디안을 앵글로 바꾸는 값

float d = glm::dot(v, u); // 내적 값 v*u

float s = (glm::length(u) * glm::length(v)); // 벡터 당 스칼라값 곱

float c = d / (glm::length(u) * glm::length(v)); // 코사인 값

float ag = glm::acos(c) * rma; // 최종 계산

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

return 0;

}

5645870_권오준

2025-09-15 05:12:42 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

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

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

int main()

{

glm::vec3 v(2.0f, -1.0f, 1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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

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

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

std::cout << degree << std::endl;

return 0;

}

5764081_송승민

2025-09-15 05:14:29 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main()

{

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

glm::vec3 a(2.0f, -1.0f, 1.0f);

glm::vec3 b(1.0f, 1.0f, 2.0f);

float c = glm::dot(a, b);

float d = c / (glm::length(a) * glm::length(b));

float e = glm::acos(d) * RADIANS_TO_DEGREES;

std::cout << e << std::endl;

return 0;

}

5881603_최인경

2025-09-15 05:19:20 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main()

{

// 라디안 구하기

const double DEGRESS_TO_RADIANS = glm::pi() / 180.0;

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

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

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

float d = glm::dot(v, u); // 벡터 내적

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

float value = glm::acos(rad) * RADIANS_TO_DEGREES;

std::cout << value << std::endl;

return 0;

}

5881270_김지운

2025-09-15 05:30:31 UTC

define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main() {

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

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

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

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

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

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

std::cout << "Angle : " << deg << " degrees\n";

}

5764095_오도혁_벡터분할

2025-09-15 05:31:52 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

int main()

{

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

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

glm::vec3 b = glm::dot(v, u) * u;

glm::vec3 a = v - b;

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

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

return 0;

}

5763848_강승우 2

seungu286 — 2025-09-15 05:32:35 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main() {

glm::vec3 v(1.0f, 2.0f, -1.0f);

glm::vec3 b;

glm::vec3 c(0.0f,1.0f,0.0f);

b = c * glm::dot(v, c);

glm::vec3 a = v - b;

std::cout <<"a: "<

return 0;

}

5763973_김영인_벡터분할

2025-09-15 05:33:29 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

const double RADIANS_TO_DEGREES = 180.0 / glm::pi(); //세타는 무조건 라디안

//glm::radians(), ::degrees() 위에 꺼랑 같음

int main()

{

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

glm::vec3 c(0, 1, 0);

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

glm::vec3 b = c * d;

glm::vec3 a = v - b;

std::cout << to_string(a)<

return 0;

}

5763865_권기환_벡터분할

rnjs498913 — 2025-09-15 05:33:29 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main() {

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

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

glm::vec3 b = glm::dot(v, u) * u;

glm::vec3 a = v - b;

std::cout << to_string(a) << std::endl;

std::cout << to_string(b) << std::endl;

return 0;

}

5764107_오제휴 2

ohjh6190 — 2025-09-15 05:34:33 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

glm::vec3 v(1.0f, 2.0f, -1.0f);

glm::vec3 c(0.0f, 1.0f, 0.0f);

glm::vec3 b = c * glm::dot(c, v);

glm::vec3 a = v - b;

std::cout << "a = " << glm::to_string(a) << ", b = " << glm::to_string(b) << std::endl;

return 0;

}

5702680_정상윤_벡터분할

2025-09-15 05:34:52 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

glm::vec3 c(0, 1, 0);

glm::vec3 b = c * glm::dot(v, c);

glm::vec3 a = v - b;

std::cout << "a = " << glm::to_string(a) << std::endl << "b = " << glm::to_string(b) << std::endl;

return 0;

}

5764186_정현욱_벡터분할

2025-09-15 05:34:52 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

const double RADIANS_TO_DEGREES = 180.0 / glm::pi(); //세타는 무조건 라디안

int main()

{

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

glm::vec3 c(0, 1, 0);

glm::vec3 b = glm::dot(c, v) * c;

glm::vec3 a = v - b;

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

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

return 0;

}

5763882_김규태 2

2025-09-15 05:35:29 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

int main() {

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

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

glm::vec3 b = u * (glm::dot(v, u));

glm::vec3 a = v - b;

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

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

return 0;

}

5645870_권오준_벡터분할

2025-09-15 05:35:38 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

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

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

int main()

{

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

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

glm::vec3 l = u * glm::dot(v, u);

//b = c * (v c)

glm::vec3 b = u * l;

glm::vec3 a = v - b;

std::cout << glm::to_string(a) << std::endl;

std::cout << glm::to_string(b) << std::endl;

return 0;

}

5764232_최영환_벡터

2025-09-15 05:35:38 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

int main()

{

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

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

glm::vec3 b = glm::dot(v, u) * u;

glm::vec3 a = v - b;

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

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

return 0;

}

5645974_김재현_벡터분할

2025-09-15 05:35:41 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

const double RADIAN_TO_DEGREES = 180.0 / glm::pi();

int main()

{

// v = a + b

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

glm::vec3 unit_vector_b(0, 1, 0);

glm::vec3 b = unit_vector_b * dot(v, unit_vector_b);

glm::vec3 a = v - b;

std::cout << glm::to_string(a) << " = a\n"

<< glm::to_string(b) << " = b" << std::endl;

return 0;

}

5855134- 응웬만히에우 2

manhhieuptneu — 2025-09-15 05:35:53 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

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

glm::vec3 b = glm::dot(v, u) * u;

glm::vec3 a = v - b;

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

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

return 0;

}

5881603__최인경_벡터분할

2025-09-15 05:36:04 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main()

{

// 벡터 분할

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

glm::vec3 c(0, 1, 0);

float l = glm::dot(v, c);

glm::vec3 b = c * l;

glm::vec3 a = v - a;

std::cout << glm::to_string(a) << glm::to_string(b) << std::endl;

return 0;

}

5881634_황윤희_벡터분할

2025-09-15 05:36:28 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main()

{

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

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

glm::vec3 v(1.0f, 2.0f, -1.0f);

glm::vec3 u(0, 1.0f, 0);

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

glm::vec3 b = u * l;

glm::vec3 a = v - b;

std::cout << "a: " << to_string(a) << std::endl;

std::cout << "b: " << to_string(b) << std::endl;

return 0;

}

5881560 정재현

ddorangii — 2025-09-15 05:36:43 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_FORCE_SWIZZLE

#include

#include // glm::radians, glm::degrees

int main() {

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

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

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

glm::vec3 b = u * vu;

glm::vec3 a = v - b;

std::cout << "vec b = " << glm::to_string(b) << std::endl;

std::cout << "vec a = " << glm::to_string(a) << std::endl;

return 0;

}

5585435_안재현_벡터분할

ajh20000523 — 2025-09-15 05:36:56 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main()

{

glm::vec3 v(1.0f, 2.0f, -1.0f);

glm::vec3 u(0.0f, 1.0f, 0.0f);

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

glm::vec3 b = u * d;

glm::vec3 a = v - b;

std::cout << glm::to_string(a) << glm::to_string(b) << std::endl;

return 0;

}

5764201_차승재_백터분할

2025-09-15 05:37:23 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

using namespace std;

int main(){

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

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

glm::vec3 v(1.0f, 2.0f, -1.0f);

glm::vec3 c(0.0f, 1.0f, 0.0f);

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

glm::vec3 b = c * d;

glm::vec3 a = v - b;

cout << glm::to_string(a) << " " << glm::to_string(b) << endl;

//e = glm::radians(e) * glm::acos(e);

//cout << e << endl;

return 0;

}

5881452_오예림_벡터분할

2025-09-15 05:38:16 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

using namespace std;

int main() {

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

glm::vec3 c(0, 1, 0);

float l = glm::dot(v, c);

glm::vec3 b = c * l;

glm::vec3 a = v - b;

cout << "a: " << glm::to_string(a) << endl;

cout << "b: " << glm::to_string(b) << endl;

return 0;

}

5646139_설문관_벡터분할

hyoseong01 — 2025-09-15 05:38:32 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

const double DEGREES_TO_RADIANS = glm::pi() / 180.0f; //glm::radians()

const double RADIANS_TO_DEGREES = 180.0 / glm::pi(); //glm::degrees()

int main()

{

/*glm::vec3 v(7, 3, -2);

glm::vec3 u(10, 4, 2);

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

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

return 0;*/

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

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

//내적

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

//거리 곱

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

//std::cout << glm::degrees(glm::acos(a / b)) /** RADIANS_TO_DEGREES*/ << std::endl;

/*glm::vec3 v1(2, 0, 0);

glm::vec3 u1(-1, 1, 0);

v1 = glm::normalize(v1);

u1 = glm::normalize(u1);

float d = glm::dot(v1, u1);

std::cout << d << std::endl;*/

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

glm::vec3 c(0, 1, 0);

glm::vec3 b = c * glm::dot(v2, c);

glm::vec3 a = v2 - b;

std::cout << "a: " << glm::to_string(a) << std::endl << "b: " << glm::to_string(b) << std::endl;

}

5881253_김인혜_벡터분할

2025-09-15 05:39:27 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main()

{

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

glm::vec3 c(0, 1, 0);

float l = glm::dot(v, c);

glm::vec3 b = c * l;

glm::vec3 a = v - b;

std::cout << "a = " << glm::to_string(a) << std::endl;

std::cout << "b = " << glm::to_string(b) << std::endl;

return 0;

}

5881470_이동우_2

2025-09-15 05:39:29 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

int main()

{

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

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

glm::vec3 b = glm::dot(v, u) * u;

glm::vec3 a = v - b;

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

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

return 0;

}

5881327_박인엽

inyup1014 — 2025-09-15 05:40:04 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

int main()

{

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

glm::vec3 u2(0, 1, 0);

float l = glm::dot(v2, u2);

glm::vec3 b = u2 * l;

glm::vec3 a = v2 - b;

std::cout << glm::to_string(a)<< glm::to_string(b) << std::endl;

return 0;

}

5764020_노도현 벡터분할

2025-09-15 05:40:24 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

int main() {

glm::vec3 v(1.0f, 2.0f, -1.0f);

glm::vec3 b;

glm::vec3 c(0.0f, 1.0f, 0.0f);

b = c * glm::dot(v, c);

glm::vec3 a = v - b;

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

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

return 0;

}

5763939_김민성 2

2025-09-15 05:46:38 UTC

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_SWIZZLE

#include

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

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

int main()

{

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

glm::vec3 c(0, 1, 0);

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

glm::vec3 b = c * d;

glm::vec3 a = v - b;

std::cout << to_string(a) << std::endl << to_string(b);

return 0;

}

5907100_이명종_벡터1

2025-09-15 05:47:57 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

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

glm::vec3 v(2.0f, -1.0f, 1.0f);

glm::vec3 u(1.0f, 1.0f, 2.0f);

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

float c = d / (glm::length(u) * glm::length(v)); //u,v 크기 계산

float deg = glm::acos(c) * RADIANS_TO_DEGREES; //역함수 구해서 radian으로 변환

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

}

5907100_이명종_벡터2

2025-09-15 06:08:17 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

glm::vec3 v(1.0f, 2.0f, -1.0f);

glm::vec3 u(0.0f, 1.0f, 0.0f);

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

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

float x = c / c2;

glm::vec3 b = x * u;

glm::vec3 a = v - b;

std::cout << to_string(a)<< std::endl;

std::cout <

}

5881270_김지운_벡터분할

2025-09-16 13:46:26 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main() {

glm::vec3 v(1.0f, 2.0f, -1.0f);

glm::vec3 u(0.0f, 1.0f, 0.0f);

glm::vec3 b = glm::dot(v, u) * u;

glm::vec3 a = v - b;

std::cout << glm::to_string(a) << std::endl;

std::cout << glm::to_string(b) << std::endl;

return 0;

}

5820658_전형진_벡터분할까지

2025-09-16 18:57:56 UTC

// main.cpp

// 5820658 전형진, 2025-09-15

#define GLM_ENABLE_EXPERIMENTAL

#include

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

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

glm::vec3 v, u, q2_uv, a, b, n, p, x;

float c, d, deg;

int main()

{

// Q1, DOT PRODUCT

v = glm::vec3(2.0f, -1.0f, 1.0f);

u = glm::vec3(1.0f, 1.0f, 2.0f);

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

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

deg = (glm::acos(c) *RAD_TO_DEG);

std::cout << "\nQ1 ANSWER : " << deg; // Q1 ANSWER

// Q2, DOT PRODUCT WITH UNIT VECTORS

v = glm::vec3(1.0f, 2.0f, -1.0f);

q2_uv = glm::normalize( glm::vec3(0.0f, 1.0f, 0.0f) ); // unit vector

b = glm::dot(v,q2_uv) *q2_uv; // get value of vector-b

a = v -b; // get value of vector-a

std::cout << "\nQ2 ANSWER, vector a : " << glm::to_string(a); // Q2 ANSWER, VECTOR A

std::cout << "\nQ2 ANSWER, vector b : " << glm::to_string(b); // Q2 ANSWER, VECTOR B

// Q3, VECTOR DECOMPOSITION

n = glm::normalize( glm::vec3(0.0f, 1.0f, 0.0f) );

p = glm::vec3(1.0f, 0.0f, 1.0f);

x = glm::vec3(-3.0f, 3.0f, 2.0f);

v = x -p; // get vector, pointing from p to x

d = glm::dot(v,n); // get shortest distance, between plane and x

std::cout << "\nQ3 ANSWER : " << d; // Q3 ANSWER

// END OF PROGRAM

std::cout << "\n5820658 전형진 과제 끝." << std::endl;

return 0; // end program

}