immibis
/
colobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactored Math::Vector in CCamera, CLightManager, CLightning, CMainMovie, glutil.h and geometry.h

dev
Tomasz Kapuściński 2021-12-29 00:08:02 +01:00
parent d25d6124a9
commit 47ad390f1d
10 changed files with 147 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
src/graphics/engine/camera.cpp
View File

@ -90,15 +90,15 @@ CCamera::CCamera()
m_initDelay = 0.0f; m_initDelay = 0.0f;
m_actualEye = Math::Vector(0.0f, 0.0f, 0.0f); m_actualEye = glm::vec3(0.0f, 0.0f, 0.0f);
m_actualLookat = Math::Vector(0.0f, 0.0f, 0.0f); m_actualLookat = glm::vec3(0.0f, 0.0f, 0.0f);
m_finalEye = Math::Vector(0.0f, 0.0f, 0.0f); m_finalEye = glm::vec3(0.0f, 0.0f, 0.0f);
m_finalLookat = Math::Vector(0.0f, 0.0f, 0.0f); m_finalLookat = glm::vec3(0.0f, 0.0f, 0.0f);
m_prevEye = Math::Vector(0.0f, 0.0f, 0.0f); m_prevEye = glm::vec3(0.0f, 0.0f, 0.0f);
m_prevLookat = Math::Vector(0.0f, 0.0f, 0.0f); m_prevLookat = glm::vec3(0.0f, 0.0f, 0.0f);
m_focus = 1.0f; m_focus = 1.0f;
m_eyePt = Math::Vector(0.0f, 0.0f, 0.0f); m_eyePt = glm::vec3(0.0f, 0.0f, 0.0f);
m_directionH = 0.0f; m_directionH = 0.0f;
m_directionV = 0.0f; m_directionV = 0.0f;
m_heightEye = 40.0f; m_heightEye = 40.0f;
@ -114,7 +114,7 @@ CCamera::CCamera()
m_fixDirectionH = 0.0f; m_fixDirectionH = 0.0f;
m_fixDirectionV = 0.0f; m_fixDirectionV = 0.0f;
m_visitGoal = Math::Vector(0.0f, 0.0f, 0.0f); m_visitGoal = glm::vec3(0.0f, 0.0f, 0.0f);
m_visitDist = 0.0f; m_visitDist = 0.0f;
m_visitTime = 0.0f; m_visitTime = 0.0f;
m_visitType = CAM_TYPE_NULL; m_visitType = CAM_TYPE_NULL;
@ -130,10 +130,10 @@ CCamera::CCamera()
m_centeringProgress = 0.0f; m_centeringProgress = 0.0f;
m_effectType = CAM_EFFECT_NULL; m_effectType = CAM_EFFECT_NULL;
m_effectPos = Math::Vector(0.0f, 0.0f, 0.0f); m_effectPos = glm::vec3(0.0f, 0.0f, 0.0f);
m_effectForce = 0.0f; m_effectForce = 0.0f;
m_effectProgress = 0.0f; m_effectProgress = 0.0f;
m_effectOffset = Math::Vector(0.0f, 0.0f, 0.0f); m_effectOffset = glm::vec3(0.0f, 0.0f, 0.0f);
m_overType = CAM_OVER_EFFECT_NULL; m_overType = CAM_OVER_EFFECT_NULL;
m_overForce = 0.0f; m_overForce = 0.0f;
@ -142,8 +142,8 @@ CCamera::CCamera()
m_overFadeIn = 0.0f; m_overFadeIn = 0.0f;
m_overFadeOut = 0.0f; m_overFadeOut = 0.0f;
m_scriptEye = Math::Vector(0.0f, 0.0f, 0.0f); m_scriptEye = glm::vec3(0.0f, 0.0f, 0.0f);
m_scriptLookat = Math::Vector(0.0f, 0.0f, 0.0f); m_scriptLookat = glm::vec3(0.0f, 0.0f, 0.0f);
m_effect = true; m_effect = true;
m_blood = true; m_blood = true;
@ -206,7 +206,7 @@ bool CCamera::GetCameraInvertY()
return m_cameraInvertY; return m_cameraInvertY;
} }
void CCamera::Init(Math::Vector eye, Math::Vector lookat, float delay) void CCamera::Init(glm::vec3 eye, glm::vec3 lookat, float delay)
{ {
m_initDelay = delay; m_initDelay = delay;
@ -280,7 +280,7 @@ void CCamera::SetType(CameraType type)
m_engine->SetFocus(m_focus); // gives initial focus m_engine->SetFocus(m_focus); // gives initial focus
m_type = type; m_type = type;
Math::Vector upVec = Math::Vector(0.0f, 1.0f, 0.0f); glm::vec3 upVec = glm::vec3(0.0f, 1.0f, 0.0f);
SetViewParams(m_prevEye, m_prevLookat, upVec); SetViewParams(m_prevEye, m_prevLookat, upVec);
return; return;
} }
@ -377,7 +377,7 @@ CameraSmooth CCamera::GetSmooth()
return m_smooth; return m_smooth;
} }
void CCamera::StartVisit(Math::Vector goal, float dist) void CCamera::StartVisit(glm::vec3 goal, float dist)
{ {
m_visitType = m_type; m_visitType = m_type;
SetType(CAM_TYPE_VISIT); SetType(CAM_TYPE_VISIT);
@ -392,7 +392,7 @@ void CCamera::StopVisit()
SetType(m_visitType); // presents the initial type SetType(m_visitType); // presents the initial type
} }
void CCamera::GetCamera(Math::Vector &eye, Math::Vector &lookat) void CCamera::GetCamera(glm::vec3 &eye, glm::vec3 &lookat)
{ {
eye = m_eyePt; eye = m_eyePt;
lookat = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f); lookat = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f);
@ -471,12 +471,12 @@ void CCamera::FlushEffect()
m_effectType = CAM_EFFECT_NULL; m_effectType = CAM_EFFECT_NULL;
m_effectForce = 0.0f; m_effectForce = 0.0f;
m_effectProgress = 0.0f; m_effectProgress = 0.0f;
m_effectOffset = Math::Vector(0.0f, 0.0f, 0.0f); m_effectOffset = glm::vec3(0.0f, 0.0f, 0.0f);
CApplication::GetInstancePointer()->StopForceFeedbackEffect(); CApplication::GetInstancePointer()->StopForceFeedbackEffect();
} }
void CCamera::StartEffect(CameraEffect effect, Math::Vector pos, float force) void CCamera::StartEffect(CameraEffect effect, glm::vec3 pos, float force)
{ {
if ( !m_effect ) return; if ( !m_effect ) return;
@ -494,7 +494,7 @@ void CCamera::EffectFrame(const Event &event)
if (m_effectType == CAM_EFFECT_NULL) if (m_effectType == CAM_EFFECT_NULL)
return; return;
m_effectOffset = Math::Vector(0.0f, 0.0f, 0.0f); m_effectOffset = glm::vec3(0.0f, 0.0f, 0.0f);
float force = m_effectForce; float force = m_effectForce;
@ -593,7 +593,7 @@ void CCamera::SetOverBaseColor(Color color)
m_overColorBase = color; m_overColorBase = color;
} }
void CCamera::StartOver(CameraOverEffect effect, Math::Vector pos, float force) void CCamera::StartOver(CameraOverEffect effect, glm::vec3 pos, float force)
{ {
m_overType = effect; m_overType = effect;
m_overTime = 0.0f; m_overTime = 0.0f;
@ -748,8 +748,8 @@ void CCamera::OverFrame(const Event &event)
} }
} }
void CCamera::UpdateCameraAnimation(const Math::Vector &eyePt, void CCamera::UpdateCameraAnimation(const glm::vec3 &eyePt,
const Math::Vector &lookatPt, const glm::vec3 &lookatPt,
float rTime) float rTime)
{ {
if (m_initDelay > 0.0f) if (m_initDelay > 0.0f)
@ -796,19 +796,19 @@ void CCamera::UpdateCameraAnimation(const Math::Vector &eyePt,
m_actualLookat = (m_finalLookat - m_actualLookat) / dist * prog + m_actualLookat; m_actualLookat = (m_finalLookat - m_actualLookat) / dist * prog + m_actualLookat;
} }
Math::Vector eye = m_effectOffset+m_actualEye; glm::vec3 eye = m_effectOffset+m_actualEye;
m_water->AdjustEye(eye); m_water->AdjustEye(eye);
float h = m_terrain->GetFloorLevel(eye); float h = m_terrain->GetFloorLevel(eye);
if (eye.y < h + 4.0f) if (eye.y < h + 4.0f)
eye.y = h + 4.0f; eye.y = h + 4.0f;
Math::Vector lookat = m_effectOffset+m_actualLookat; glm::vec3 lookat = m_effectOffset+m_actualLookat;
SetViewParams(eye, lookat); SetViewParams(eye, lookat);
} }
void CCamera::IsCollision(Math::Vector &eye, Math::Vector lookat) void CCamera::IsCollision(glm::vec3 &eye, glm::vec3 lookat)
{ {
if (m_type == CAM_TYPE_BACK ) IsCollisionBack(); if (m_type == CAM_TYPE_BACK ) IsCollisionBack();
if (m_type == CAM_TYPE_FIX ) IsCollisionFix (eye, lookat); if (m_type == CAM_TYPE_FIX ) IsCollisionFix (eye, lookat);
@ -823,12 +823,12 @@ void CCamera::IsCollisionBack()
else else
iType = m_cameraObj->GetType(); iType = m_cameraObj->GetType();
Math::Vector min{}; glm::vec3 min{};
min.x = Math::Min(m_actualEye.x, m_actualLookat.x); min.x = Math::Min(m_actualEye.x, m_actualLookat.x);
min.y = Math::Min(m_actualEye.y, m_actualLookat.y); min.y = Math::Min(m_actualEye.y, m_actualLookat.y);
min.z = Math::Min(m_actualEye.z, m_actualLookat.z); min.z = Math::Min(m_actualEye.z, m_actualLookat.z);
Math::Vector max{}; glm::vec3 max{};
max.x = Math::Max(m_actualEye.x, m_actualLookat.x); max.x = Math::Max(m_actualEye.x, m_actualLookat.x);
max.y = Math::Max(m_actualEye.y, m_actualLookat.y); max.y = Math::Max(m_actualEye.y, m_actualLookat.y);
max.z = Math::Max(m_actualEye.z, m_actualLookat.z); max.z = Math::Max(m_actualEye.z, m_actualLookat.z);
@ -869,7 +869,7 @@ void CCamera::IsCollisionBack()
oType == OBJECT_WORM ) continue; oType == OBJECT_WORM ) continue;
Math::Sphere objSphere = obj->GetCameraCollisionSphere(); Math::Sphere objSphere = obj->GetCameraCollisionSphere();
Math::Vector oPos = objSphere.pos; glm::vec3 oPos = objSphere.pos;
float oRadius = objSphere.radius; float oRadius = objSphere.radius;
if ( oRadius <= 2.0f ) continue; // ignores small objects if ( oRadius <= 2.0f ) continue; // ignores small objects
@ -880,7 +880,7 @@ void CCamera::IsCollisionBack()
oPos.y-oRadius > max.y || oPos.y-oRadius > max.y ||
oPos.z-oRadius > max.z ) continue; oPos.z-oRadius > max.z ) continue;
Math::Vector proj = Math::Projection(m_actualEye, m_actualLookat, oPos); glm::vec3 proj = Math::Projection(m_actualEye, m_actualLookat, oPos);
float dpp = Math::Distance(proj, oPos); float dpp = Math::Distance(proj, oPos);
if ( dpp > oRadius ) continue; if ( dpp > oRadius ) continue;
@ -902,7 +902,7 @@ void CCamera::IsCollisionBack()
} }
} }
void CCamera::IsCollisionFix(Math::Vector &eye, Math::Vector lookat) void CCamera::IsCollisionFix(glm::vec3 &eye, glm::vec3 lookat)
{ {
for (CObject* obj : CObjectManager::GetInstancePointer()->GetAllObjects()) for (CObject* obj : CObjectManager::GetInstancePointer()->GetAllObjects())
{ {
@ -927,7 +927,7 @@ void CCamera::IsCollisionFix(Math::Vector &eye, Math::Vector lookat)
type == OBJECT_WORM ) continue; type == OBJECT_WORM ) continue;
Math::Sphere objSphere = obj->GetCameraCollisionSphere(); Math::Sphere objSphere = obj->GetCameraCollisionSphere();
Math::Vector objPos = objSphere.pos; glm::vec3 objPos = objSphere.pos;
float objRadius = objSphere.radius; float objRadius = objSphere.radius;
if (objRadius == 0.0f) continue; if (objRadius == 0.0f) continue;
@ -935,7 +935,7 @@ void CCamera::IsCollisionFix(Math::Vector &eye, Math::Vector lookat)
if (dist < objRadius) if (dist < objRadius)
{ {
dist = Math::Distance(eye, lookat); dist = Math::Distance(eye, lookat);
Math::Vector proj = Math::Projection(eye, lookat, objPos); glm::vec3 proj = Math::Projection(eye, lookat, objPos);
eye = (lookat - eye) * objRadius / dist + proj; eye = (lookat - eye) * objRadius / dist + proj;
return; return;
} }
@ -1069,7 +1069,7 @@ bool CCamera::EventProcess(const Event &event)
bool CCamera::EventFrameFree(const Event &event, bool keysAllowed) bool CCamera::EventFrameFree(const Event &event, bool keysAllowed)
{ {
Math::Vector cameraMove = CalculateCameraMovement(event, keysAllowed); glm::vec3 cameraMove = CalculateCameraMovement(event, keysAllowed);
float factor = m_heightEye * 0.5f + 30.0f; float factor = m_heightEye * 0.5f + 30.0f;
bool secondary = m_input->GetKeyState(INPUT_SLOT_CAM_ALT) || event.mouseButtonsState & MOUSE_BUTTON_MIDDLE; // TODO: make mouse button a keybinding bool secondary = m_input->GetKeyState(INPUT_SLOT_CAM_ALT) || event.mouseButtonsState & MOUSE_BUTTON_MIDDLE; // TODO: make mouse button a keybinding
@ -1104,7 +1104,7 @@ bool CCamera::EventFrameFree(const Event &event, bool keysAllowed)
{ {
m_eyePt.y += m_heightEye; m_eyePt.y += m_heightEye;
Math::Vector pos = m_eyePt; glm::vec3 pos = m_eyePt;
if (m_terrain->AdjustToFloor(pos, true)) if (m_terrain->AdjustToFloor(pos, true))
{ {
pos.y -= 2.0f; pos.y -= 2.0f;
@ -1114,7 +1114,7 @@ bool CCamera::EventFrameFree(const Event &event, bool keysAllowed)
} }
Math::Vector lookatPt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f); glm::vec3 lookatPt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f);
if (m_terrain->AdjustToFloor(lookatPt, true)) if (m_terrain->AdjustToFloor(lookatPt, true))
lookatPt.y += m_heightLookat; lookatPt.y += m_heightLookat;
@ -1126,7 +1126,7 @@ bool CCamera::EventFrameFree(const Event &event, bool keysAllowed)
bool CCamera::EventFrameBack(const Event &event) bool CCamera::EventFrameBack(const Event &event)
{ {
Math::Vector cameraMove = CalculateCameraMovement(event); glm::vec3 cameraMove = CalculateCameraMovement(event);
m_addDirectionH += cameraMove.x; m_addDirectionH += cameraMove.x;
m_addDirectionV += cameraMove.y; m_addDirectionV += cameraMove.y;
m_backDist += cameraMove.z; m_backDist += cameraMove.z;
@ -1178,7 +1178,7 @@ bool CCamera::EventFrameBack(const Event &event)
{ {
ObjectType type = m_cameraObj->GetType(); ObjectType type = m_cameraObj->GetType();
Math::Vector lookatPt = m_cameraObj->GetPosition(); glm::vec3 lookatPt = m_cameraObj->GetPosition();
if (type == OBJECT_BASE ) lookatPt.y += 40.0f; if (type == OBJECT_BASE ) lookatPt.y += 40.0f;
else if (type == OBJECT_HUMAN) lookatPt.y += 1.0f; else if (type == OBJECT_HUMAN) lookatPt.y += 1.0f;
else if (type == OBJECT_TECH ) lookatPt.y += 1.0f; else if (type == OBJECT_TECH ) lookatPt.y += 1.0f;
@ -1237,7 +1237,7 @@ bool CCamera::EventFrameBack(const Event &event)
ground = dynamic_cast<CMovableObject&>(*m_cameraObj).GetPhysics()->GetLand(); ground = dynamic_cast<CMovableObject&>(*m_cameraObj).GetPhysics()->GetLand();
if ( ground ) // ground? if ( ground ) // ground?
{ {
Math::Vector pos = lookatPt + (lookatPt - m_eyePt); glm::vec3 pos = lookatPt + (lookatPt - m_eyePt);
float floor = m_terrain->GetHeightToFloor(pos) - 4.0f; float floor = m_terrain->GetHeightToFloor(pos) - 4.0f;
if (floor > 0.0f) if (floor > 0.0f)
m_eyePt.y += floor; // shows the descent in front m_eyePt.y += floor; // shows the descent in front
@ -1257,7 +1257,7 @@ bool CCamera::EventFrameBack(const Event &event)
bool CCamera::EventFrameFix(const Event &event) bool CCamera::EventFrameFix(const Event &event)
{ {
Math::Vector cameraMove = CalculateCameraMovement(event); glm::vec3 cameraMove = CalculateCameraMovement(event);
m_fixDirectionH += cameraMove.x; m_fixDirectionH += cameraMove.x;
m_fixDirectionV += cameraMove.y; m_fixDirectionV += cameraMove.y;
m_fixDist += cameraMove.z; m_fixDist += cameraMove.z;
@ -1269,7 +1269,7 @@ bool CCamera::EventFrameFix(const Event &event)
if (m_cameraObj != nullptr) if (m_cameraObj != nullptr)
{ {
Math::Vector lookatPt = m_cameraObj->GetPosition(); glm::vec3 lookatPt = m_cameraObj->GetPosition();
float h = m_fixDirectionH; float h = m_fixDirectionH;
float v = m_fixDirectionV; float v = m_fixDirectionV;
@ -1291,7 +1291,7 @@ bool CCamera::EventFrameFix(const Event &event)
bool CCamera::EventFrameExplo(const Event &event) bool CCamera::EventFrameExplo(const Event &event)
{ {
Math::Vector cameraMove = CalculateCameraMovement(event); glm::vec3 cameraMove = CalculateCameraMovement(event);
m_directionH += cameraMove.x; m_directionH += cameraMove.x;
m_directionH = Math::NormAngle(m_directionH); m_directionH = Math::NormAngle(m_directionH);
@ -1301,7 +1301,7 @@ bool CCamera::EventFrameExplo(const Event &event)
{ {
m_eyePt.y += m_heightEye; m_eyePt.y += m_heightEye;
Math::Vector pos = m_eyePt; glm::vec3 pos = m_eyePt;
if ( m_terrain->AdjustToFloor(pos, false) ) if ( m_terrain->AdjustToFloor(pos, false) )
{ {
pos.y += 2.0f; pos.y += 2.0f;
@ -1311,7 +1311,7 @@ bool CCamera::EventFrameExplo(const Event &event)
} }
Math::Vector lookatPt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f); glm::vec3 lookatPt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f);
if (m_terrain->AdjustToFloor(lookatPt, true)) if (m_terrain->AdjustToFloor(lookatPt, true))
lookatPt.y += m_heightLookat; lookatPt.y += m_heightLookat;
@ -1326,10 +1326,10 @@ bool CCamera::EventFrameOnBoard(const Event &event)
if (m_cameraObj != nullptr) if (m_cameraObj != nullptr)
{ {
assert(m_cameraObj->Implements(ObjectInterfaceType::Controllable)); assert(m_cameraObj->Implements(ObjectInterfaceType::Controllable));
Math::Vector lookatPt, upVec; glm::vec3 lookatPt, upVec;
dynamic_cast<CControllableObject&>(*m_cameraObj).AdjustCamera(m_eyePt, m_directionH, m_directionV, lookatPt, upVec, m_type); dynamic_cast<CControllableObject&>(*m_cameraObj).AdjustCamera(m_eyePt, m_directionH, m_directionV, lookatPt, upVec, m_type);
Math::Vector eye = m_effectOffset * 0.3f + m_eyePt; glm::vec3 eye = m_effectOffset * 0.3f + m_eyePt;
Math::Vector lookat = m_effectOffset * 0.3f + lookatPt; glm::vec3 lookat = m_effectOffset * 0.3f + lookatPt;
SetViewParams(eye, lookat, upVec); SetViewParams(eye, lookat, upVec);
m_actualEye = eye; m_actualEye = eye;
@ -1342,7 +1342,7 @@ bool CCamera::EventFrameVisit(const Event &event)
{ {
m_visitTime += event.rTime; m_visitTime += event.rTime;
Math::Vector cameraMove = CalculateCameraMovement(event); glm::vec3 cameraMove = CalculateCameraMovement(event);
// ZoomIn/ZoomOut // ZoomIn/ZoomOut
m_visitDist += cameraMove.z; m_visitDist += cameraMove.z;
@ -1354,7 +1354,7 @@ bool CCamera::EventFrameVisit(const Event &event)
float angleH = (m_visitTime / 10.0f) * (Math::PI * 2.0f); float angleH = (m_visitTime / 10.0f) * (Math::PI * 2.0f);
float angleV = m_visitDirectionV; float angleV = m_visitDirectionV;
Math::Vector eye = Math::RotateView(m_visitGoal, angleH, angleV, m_visitDist); glm::vec3 eye = Math::RotateView(m_visitGoal, angleH, angleV, m_visitDist);
eye = ExcludeTerrain(eye, m_visitGoal, angleH, angleV); eye = ExcludeTerrain(eye, m_visitGoal, angleH, angleV);
eye = ExcludeObject(eye, m_visitGoal, angleH, angleV); eye = ExcludeObject(eye, m_visitGoal, angleH, angleV);
UpdateCameraAnimation(eye, m_visitGoal, event.rTime); UpdateCameraAnimation(eye, m_visitGoal, event.rTime);
@ -1369,17 +1369,17 @@ bool CCamera::EventFrameScript(const Event &event)
return true; return true;
} }
void CCamera::SetScriptCameraAnimateEye(Math::Vector eye) void CCamera::SetScriptCameraAnimateEye(glm::vec3 eye)
{ {
m_scriptEye = eye; m_scriptEye = eye;
} }
void CCamera::SetScriptCameraAnimateLookat(Math::Vector lookat) void CCamera::SetScriptCameraAnimateLookat(glm::vec3 lookat)
{ {
m_scriptLookat = lookat; m_scriptLookat = lookat;
} }
void CCamera::SetScriptCamera(Math::Vector eye, Math::Vector lookat) void CCamera::SetScriptCamera(glm::vec3 eye, glm::vec3 lookat)
{ {
SetScriptCameraAnimate(eye, lookat); SetScriptCameraAnimate(eye, lookat);
@ -1388,14 +1388,14 @@ void CCamera::SetScriptCamera(Math::Vector eye, Math::Vector lookat)
m_actualLookat = m_finalLookat = m_scriptLookat; m_actualLookat = m_finalLookat = m_scriptLookat;
} }
void CCamera::SetScriptCameraAnimate(Math::Vector eye, Math::Vector lookat) void CCamera::SetScriptCameraAnimate(glm::vec3 eye, glm::vec3 lookat)
{ {
m_scriptEye = eye; m_scriptEye = eye;
m_scriptLookat = lookat; m_scriptLookat = lookat;
} }
void CCamera::SetViewParams(const Math::Vector &eye, const Math::Vector &lookat, void CCamera::SetViewParams(const glm::vec3 &eye, const glm::vec3 &lookat,
const Math::Vector &up) const glm::vec3 &up)
{ {
m_engine->SetViewParams(eye, lookat, up); m_engine->SetViewParams(eye, lookat, up);
@ -1403,10 +1403,10 @@ void CCamera::SetViewParams(const Math::Vector &eye, const Math::Vector &lookat,
m_engine->SetRankView(under ? 1 : 0); m_engine->SetRankView(under ? 1 : 0);
} }
Math::Vector CCamera::ExcludeTerrain(Math::Vector eye, Math::Vector lookat, glm::vec3 CCamera::ExcludeTerrain(glm::vec3 eye, glm::vec3 lookat,
float &angleH, float &angleV) float &angleH, float &angleV)
{ {
Math::Vector pos = eye; glm::vec3 pos = eye;
if (m_terrain->AdjustToFloor(pos)) if (m_terrain->AdjustToFloor(pos))
{ {
float dist = Math::DistanceProjected(lookat, pos); float dist = Math::DistanceProjected(lookat, pos);
@ -1420,7 +1420,7 @@ Math::Vector CCamera::ExcludeTerrain(Math::Vector eye, Math::Vector lookat,
return eye; return eye;
} }
Math::Vector CCamera::ExcludeObject(Math::Vector eye, Math::Vector lookat, glm::vec3 CCamera::ExcludeObject(glm::vec3 eye, glm::vec3 lookat,
float &angleH, float &angleV) float &angleH, float &angleV)
{ {
return eye; return eye;
@ -1434,7 +1434,7 @@ Math::Vector CCamera::ExcludeObject(Math::Vector eye, Math::Vector lookat,
break; break;
int j = 0; int j = 0;
Math::Vector oPos; glm::vec3 oPos;
float oRad; float oRad;
while (obj->GetCrashSphere(j++, oPos, oRad)) while (obj->GetCrashSphere(j++, oPos, oRad))
{ {
@ -1452,9 +1452,9 @@ void CCamera::SetCameraSpeed(float speed)
m_speed = speed; m_speed = speed;
} }
Math::Vector CCamera::CalculateCameraMovement(const Event &event, bool keysAllowed) glm::vec3 CCamera::CalculateCameraMovement(const Event &event, bool keysAllowed)
{ {
Math::Vector delta{}; glm::vec3 delta{};
delta.x += m_mouseDelta.x * 2*Math::PI; delta.x += m_mouseDelta.x * 2*Math::PI;
delta.y -= m_mouseDelta.y * Math::PI; delta.y -= m_mouseDelta.y * Math::PI;

20
src/graphics/engine/lightman.cpp
View File

@ -177,8 +177,8 @@ int CLightManager::CreateLight(LightPriority priority)
m_dynLights[index].light.type = LIGHT_DIRECTIONAL; m_dynLights[index].light.type = LIGHT_DIRECTIONAL;
m_dynLights[index].light.diffuse = Color(0.5f, 0.5f, 0.5f); m_dynLights[index].light.diffuse = Color(0.5f, 0.5f, 0.5f);
m_dynLights[index].light.ambient = Color(0.0f, 0.0f, 0.0f); m_dynLights[index].light.ambient = Color(0.0f, 0.0f, 0.0f);
m_dynLights[index].light.position = Math::Vector(-100.0f, 100.0f, -100.0f); m_dynLights[index].light.position = glm::vec3(-100.0f, 100.0f, -100.0f);
m_dynLights[index].light.direction = Math::Vector( 1.0f, -1.0f, 1.0f); m_dynLights[index].light.direction = glm::vec3( 1.0f, -1.0f, 1.0f);
m_dynLights[index].intensity.Init(1.0f); // maximum m_dynLights[index].intensity.Init(1.0f); // maximum
m_dynLights[index].colorRed.Init(0.5f); m_dynLights[index].colorRed.Init(0.5f);
@ -256,7 +256,7 @@ bool CLightManager::SetLightExcludeType(int lightRank, EngineObjectType type)
return true; return true;
} }
bool CLightManager::SetLightPos(int lightRank, const Math::Vector &pos) bool CLightManager::SetLightPos(int lightRank, const glm::vec3 &pos)
{ {
if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) ) if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
return false; return false;
@ -265,15 +265,15 @@ bool CLightManager::SetLightPos(int lightRank, const Math::Vector &pos)
return true; return true;
} }
Math::Vector CLightManager::GetLightPos(int lightRank) glm::vec3 CLightManager::GetLightPos(int lightRank)
{ {
if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) ) if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
return Math::Vector(0.0f, 0.0f, 0.0f); return glm::vec3(0.0f, 0.0f, 0.0f);
return m_dynLights[lightRank].light.position; return m_dynLights[lightRank].light.position;
} }
bool CLightManager::SetLightDir(int lightRank, const Math::Vector &dir) bool CLightManager::SetLightDir(int lightRank, const glm::vec3 &dir)
{ {
if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) ) if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
return false; return false;
@ -282,10 +282,10 @@ bool CLightManager::SetLightDir(int lightRank, const Math::Vector &dir)
return true; return true;
} }
Math::Vector CLightManager::GetLightDir(int lightRank) glm::vec3 CLightManager::GetLightDir(int lightRank)
{ {
if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) ) if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
return Math::Vector(0.0f, 0.0f, 0.0f); return glm::vec3(0.0f, 0.0f, 0.0f);
return m_dynLights[lightRank].light.direction; return m_dynLights[lightRank].light.direction;
} }
@ -401,7 +401,7 @@ void CLightManager::UpdateProgression(float rTime)
if (m_dynLights[i].includeType == ENG_OBJTYPE_METAL) if (m_dynLights[i].includeType == ENG_OBJTYPE_METAL)
{ {
Math::Vector dir = m_engine->GetEyePt() - m_engine->GetLookatPt(); glm::vec3 dir = m_engine->GetEyePt() - m_engine->GetLookatPt();
float angle = Math::RotateAngle(dir.x, dir.z); float angle = Math::RotateAngle(dir.x, dir.z);
angle += Math::PI * 0.5f * i; angle += Math::PI * 0.5f * i;
m_dynLights[i].light.direction.x = sinf(2.0f * angle); m_dynLights[i].light.direction.x = sinf(2.0f * angle);
@ -496,7 +496,7 @@ void CLightManager::UpdateDeviceLights(EngineObjectType type)
// ----------- // -----------
CLightManager::CLightsComparator::CLightsComparator(Math::Vector eyePos, EngineObjectType objectType) CLightManager::CLightsComparator::CLightsComparator(glm::vec3 eyePos, EngineObjectType objectType)
{ {
m_eyePos = eyePos; m_eyePos = eyePos;
m_objectType = objectType; m_objectType = objectType;

12
src/graphics/engine/lightman.h
View File

@ -178,14 +178,14 @@ public:
bool SetLightExcludeType(int lightRank, EngineObjectType type); bool SetLightExcludeType(int lightRank, EngineObjectType type);
//! Sets the position of dynamic light //! Sets the position of dynamic light
bool SetLightPos(int lightRank, const Math::Vector &pos); bool SetLightPos(int lightRank, const glm::vec3 &pos);
//! Returns the position of dynamic light //! Returns the position of dynamic light
Math::Vector GetLightPos(int lightRank); glm::vec3 GetLightPos(int lightRank);
//! Sets the direction of dynamic light //! Sets the direction of dynamic light
bool SetLightDir(int lightRank, const Math::Vector &dir); bool SetLightDir(int lightRank, const glm::vec3 &dir);
//! Returns the direction of dynamic light //! Returns the direction of dynamic light
Math::Vector GetLightDir(int lightRank); glm::vec3 GetLightDir(int lightRank);
//! Sets the destination intensity for dynamic light's intensity progression //! Sets the destination intensity for dynamic light's intensity progression
bool SetLightIntensity(int lightRank, float value); bool SetLightIntensity(int lightRank, float value);
@ -215,14 +215,14 @@ protected:
class CLightsComparator class CLightsComparator
{ {
public: public:
CLightsComparator(Math::Vector eyePos, EngineObjectType objectType); CLightsComparator(glm::vec3 eyePos, EngineObjectType objectType);
bool operator()(const DynamicLight& left, const DynamicLight& right); bool operator()(const DynamicLight& left, const DynamicLight& right);
private: private:
float GetLightWeight(const DynamicLight& dynLight); float GetLightWeight(const DynamicLight& dynLight);
Math::Vector m_eyePos; glm::vec3 m_eyePos = { 0, 0, 0 };
EngineObjectType m_objectType; EngineObjectType m_objectType;
}; };

26
src/graphics/engine/lightning.cpp
View File

@ -236,22 +236,22 @@ void CLightning::Draw()
texSup.x = 95.5f/256.0f; texSup.x = 95.5f/256.0f;
texSup.y = 34.0f/256.0f; // blank texSup.y = 34.0f/256.0f; // blank
Math::Vector p1 = m_pos; glm::vec3 p1 = m_pos;
Math::Vector eye = m_engine->GetEyePt(); glm::vec3 eye = m_engine->GetEyePt();
float a = Math::RotateAngle(eye.x-p1.x, eye.z-p1.z); float a = Math::RotateAngle(eye.x-p1.x, eye.z-p1.z);
Math::Vector n = Math::Normalize(p1-eye); glm::vec3 n = Math::Normalize(p1-eye);
Math::Vector corner[4]; glm::vec3 corner[4];
Vertex vertex[4]; Vertex vertex[4];
for (std::size_t i = 0; i < m_segments.size() - 1; i++) for (std::size_t i = 0; i < m_segments.size() - 1; i++)
{ {
Math::Vector p2 = p1; glm::vec3 p2 = p1;
p2.y += 8.0f+0.2f*i; p2.y += 8.0f+0.2f*i;
glm::vec2 rot; glm::vec2 rot;
Math::Vector p = p1; glm::vec3 p = p1;
p.x += m_segments[i].width; p.x += m_segments[i].width;
rot = Math::RotatePoint({ p1.x, p1.z }, a + Math::PI / 2.0f, { p.x, p.z }); rot = Math::RotatePoint({ p1.x, p1.z }, a + Math::PI / 2.0f, { p.x, p.z });
corner[0].x = rot.x+m_segments[i].shift.x; corner[0].x = rot.x+m_segments[i].shift.x;
@ -295,12 +295,12 @@ void CLightning::Draw()
} }
} }
CObject* CLightning::SearchObject(Math::Vector pos) CObject* CLightning::SearchObject(glm::vec3 pos)
{ {
// Lightning conductors // Lightning conductors
std::vector<CObject*> paraObj; std::vector<CObject*> paraObj;
paraObj.reserve(100); paraObj.reserve(100);
std::vector<Math::Vector> paraObjPos; std::vector<glm::vec3> paraObjPos;
paraObjPos.reserve(100); paraObjPos.reserve(100);
// Seeking the object closest to the point of impact of lightning. // Seeking the object closest to the point of impact of lightning.
@ -326,7 +326,7 @@ CObject* CLightning::SearchObject(Math::Vector pos)
float detect = m_magnetic * dynamic_cast<CDestroyableObject&>(*obj).GetLightningHitProbability(); float detect = m_magnetic * dynamic_cast<CDestroyableObject&>(*obj).GetLightningHitProbability();
if (detect == 0.0f) continue; if (detect == 0.0f) continue;
Math::Vector oPos = obj->GetPosition(); glm::vec3 oPos = obj->GetPosition();
float dist = Math::DistanceProjected(oPos, pos); float dist = Math::DistanceProjected(oPos, pos);
if (dist > detect) continue; if (dist > detect) continue;
if (dist < min) if (dist < min)
@ -340,7 +340,7 @@ CObject* CLightning::SearchObject(Math::Vector pos)
return nullptr; // nothing found return nullptr; // nothing found
// Under the protection of a lightning conductor? // Under the protection of a lightning conductor?
Math::Vector oPos = bestObj->GetPosition(); glm::vec3 oPos = bestObj->GetPosition();
for (int i = paraObj.size()-1; i >= 0; i--) for (int i = paraObj.size()-1; i >= 0; i--)
{ {
float dist = Math::DistanceProjected(oPos, paraObjPos[i]); float dist = Math::DistanceProjected(oPos, paraObjPos[i]);
@ -352,17 +352,17 @@ CObject* CLightning::SearchObject(Math::Vector pos)
} }
void CLightning::StrikeAtPos(Math::Vector pos) void CLightning::StrikeAtPos(glm::vec3 pos)
{ {
m_pos = pos; m_pos = pos;
Math::Vector eye = m_engine->GetEyePt(); glm::vec3 eye = m_engine->GetEyePt();
float dist = Math::Distance(m_pos, eye); float dist = Math::Distance(m_pos, eye);
float deep = m_engine->GetDeepView(); float deep = m_engine->GetDeepView();
if (dist < deep) if (dist < deep)
{ {
Math::Vector pos = eye+((m_pos-eye)*0.2f); // like so close! glm::vec3 pos = eye+((m_pos-eye)*0.2f); // like so close!
m_sound->Play(SOUND_BLITZ, pos); m_sound->Play(SOUND_BLITZ, pos);
m_camera->StartOver(CAM_OVER_EFFECT_LIGHTNING, m_pos, 1.0f); m_camera->StartOver(CAM_OVER_EFFECT_LIGHTNING, m_pos, 1.0f);

6
src/graphics/engine/lightning.h
View File

@ -77,13 +77,13 @@ public:
void Draw(); void Draw();
//! Shoots lightning strike at given position //! Shoots lightning strike at given position
void StrikeAtPos(Math::Vector pos); void StrikeAtPos(glm::vec3 pos);
protected: protected:
//! Updates lightning //! Updates lightning
bool EventFrame(const Event &event); bool EventFrame(const Event &event);
//! Seeks for the object closest to the lightning //! Seeks for the object closest to the lightning
CObject* SearchObject(Math::Vector pos); CObject* SearchObject(glm::vec3 pos);
protected: protected:
CEngine* m_engine = nullptr; CEngine* m_engine = nullptr;
@ -98,7 +98,7 @@ protected:
float m_speed = 0.0f; float m_speed = 0.0f;
float m_progress = 0.0f; float m_progress = 0.0f;
Math::Vector m_pos; glm::vec3 m_pos = { 0, 0, 0 };
enum class LightningPhase enum class LightningPhase
{ {

2
src/graphics/opengl/glutil.cpp
View File

@ -413,7 +413,7 @@ GLenum TranslateGfxBlendFunc(BlendFunc func)
return 0; return 0;
} }
bool InPlane(Math::Vector normal, float originPlane, Math::Vector center, float radius) bool InPlane(glm::vec3 normal, float originPlane, glm::vec3 center, float radius)
{ {
float distance = originPlane + Math::DotProduct(normal, center); float distance = originPlane + Math::DotProduct(normal, center);

2
src/graphics/opengl/glutil.h
View File

@ -88,7 +88,7 @@ BlendFunc TranslateGLBlendFunc(GLenum flag);
GLenum TranslateGfxBlendFunc(BlendFunc func); GLenum TranslateGfxBlendFunc(BlendFunc func);
bool InPlane(Math::Vector normal, float originPlane, Math::Vector center, float radius); bool InPlane(glm::vec3 normal, float originPlane, glm::vec3 center, float radius);
GLenum TranslateTextureCoordinate(int index); GLenum TranslateTextureCoordinate(int index);

18
src/level/mainmovie.cpp
View File

@ -73,7 +73,7 @@ void CMainMovie::Flush()
bool CMainMovie::Start(MainMovieType type, float time) bool CMainMovie::Start(MainMovieType type, float time)
{ {
Math::Matrix* mat; Math::Matrix* mat;
Math::Vector pos; glm::vec3 pos{ 0, 0, 0 };
CObject* pObj; CObject* pObj;
m_type = type; m_type = type;
@ -98,10 +98,10 @@ bool CMainMovie::Start(MainMovieType type, float time)
m_camera->SetScriptCamera(m_initialEye, m_initialLookat); m_camera->SetScriptCamera(m_initialEye, m_initialLookat);
mat = pObj->GetWorldMatrix(0); mat = pObj->GetWorldMatrix(0);
m_finalLookat[0] = Math::Transform(*mat, Math::Vector( 1.6f, 1.0f, 1.2f)); m_finalLookat[0] = Math::Transform(*mat, glm::vec3( 1.6f, 1.0f, 1.2f));
m_finalEye[0] = Math::Transform(*mat, Math::Vector(-1.5f, 5.0f, 3.0f)); m_finalEye[0] = Math::Transform(*mat, glm::vec3(-1.5f, 5.0f, 3.0f));
m_finalLookat[1] = Math::Transform(*mat, Math::Vector( 1.6f, 1.0f, 1.2f)); m_finalLookat[1] = Math::Transform(*mat, glm::vec3( 1.6f, 1.0f, 1.2f));
m_finalEye[1] = Math::Transform(*mat, Math::Vector( 0.8f, 3.0f, 0.8f)); m_finalEye[1] = Math::Transform(*mat, glm::vec3( 0.8f, 3.0f, 0.8f));
} }
if ( m_type == MM_SATCOMclose ) if ( m_type == MM_SATCOMclose )
@ -152,9 +152,6 @@ bool CMainMovie::IsExist()
bool CMainMovie::EventProcess(const Event &event) bool CMainMovie::EventProcess(const Event &event)
{ {
Math::Vector initialEye, initialLookat, finalEye, finalLookat, eye, lookat;
float progress;
if ( m_type == MM_NONE ) return true; if ( m_type == MM_NONE ) return true;
m_progress += event.rTime*m_speed; m_progress += event.rTime*m_speed;
@ -163,7 +160,10 @@ bool CMainMovie::EventProcess(const Event &event)
{ {
if ( m_progress < 1.0f ) if ( m_progress < 1.0f )
{ {
progress = 1.0f-powf(1.0f-m_progress, 3.0f); glm::vec3 initialEye, initialLookat;
glm::vec3 finalEye, finalLookat, eye, lookat;
float progress = 1.0f-powf(1.0f-m_progress, 3.0f);
if ( progress < 0.6f ) if ( progress < 0.6f )
{ {

10
src/level/mainmovie.h
View File

@ -24,7 +24,7 @@
#pragma once #pragma once
#include "math/vector.h" #include <glm/glm.hpp>
class CRobotMain; class CRobotMain;
@ -70,9 +70,9 @@ protected:
MainMovieType m_stopType; MainMovieType m_stopType;
float m_speed; float m_speed;
float m_progress; float m_progress;
Math::Vector m_initialEye; glm::vec3 m_initialEye;
Math::Vector m_initialLookat; glm::vec3 m_initialLookat;
Math::Vector m_finalEye[2]; glm::vec3 m_finalEye[2];
Math::Vector m_finalLookat[2]; glm::vec3 m_finalLookat[2];
}; };

78
src/math/geometry.h
View File

@ -156,13 +156,13 @@ inline void RotatePoint(float cx, float cy, float angle, float &px, float &py)
* \param angleH,angleV rotation angles [radians] (positive is CCW) * \param angleH,angleV rotation angles [radians] (positive is CCW)
* \param p the point to be rotated * \param p the point to be rotated
*/ */
inline void RotatePoint(const Math::Vector &center, float angleH, float angleV, Math::Vector &p) inline void RotatePoint(const glm::vec3 &center, float angleH, float angleV, glm::vec3 &p)
{ {
p.x -= center.x; p.x -= center.x;
p.y -= center.y; p.y -= center.y;
p.z -= center.z; p.z -= center.z;
Math::Vector b; glm::vec3 b{};
b.x = p.x*cosf(angleH) - p.z*sinf(angleH); b.x = p.x*cosf(angleH) - p.z*sinf(angleH);
b.y = p.z*sinf(angleV) + p.y*cosf(angleV); b.y = p.z*sinf(angleV) + p.y*cosf(angleV);
b.z = p.x*sinf(angleH) + p.z*cosf(angleH); b.z = p.x*sinf(angleH) + p.z*cosf(angleH);
@ -178,18 +178,18 @@ inline void RotatePoint(const Math::Vector &center, float angleH, float angleV,
* \param angleH,angleV rotation angles [radians] (positive is CCW) * \param angleH,angleV rotation angles [radians] (positive is CCW)
* \param p the point to be rotated * \param p the point to be rotated
*/ */
inline void RotatePoint2(const Math::Vector center, float angleH, float angleV, Math::Vector &p) inline void RotatePoint2(const glm::vec3 center, float angleH, float angleV, glm::vec3 &p)
{ {
p.x -= center.x; p.x -= center.x;
p.y -= center.y; p.y -= center.y;
p.z -= center.z; p.z -= center.z;
Math::Vector a; glm::vec3 a{};
a.x = p.x*cosf(angleH) - p.z*sinf(angleH); a.x = p.x*cosf(angleH) - p.z*sinf(angleH);
a.y = p.y; a.y = p.y;
a.z = p.x*sinf(angleH) + p.z*cosf(angleH); a.z = p.x*sinf(angleH) + p.z*cosf(angleH);
Math::Vector b; glm::vec3 b{};
b.x = a.x; b.x = a.x;
b.y = a.z*sinf(angleV) + a.y*cosf(angleV); b.y = a.z*sinf(angleV) + a.y*cosf(angleV);
b.z = a.z*cosf(angleV) - a.y*sinf(angleV); b.z = a.z*cosf(angleV) - a.y*sinf(angleV);
@ -264,12 +264,12 @@ inline float RotateAngle(const glm::vec2&center, const glm::vec2&p1, const glm::
* \param at view direction * \param at view direction
* \param worldUp up vector * \param worldUp up vector
*/ */
inline void LoadViewMatrix(Math::Matrix &mat, const Math::Vector &from, inline void LoadViewMatrix(Math::Matrix &mat, const glm::vec3 &from,
const Math::Vector &at, const Math::Vector &worldUp) const glm::vec3 &at, const glm::vec3 &worldUp)
{ {
// Get the z basis vector, which points straight ahead. This is the // Get the z basis vector, which points straight ahead. This is the
// difference from the eyepoint to the lookat point. // difference from the eyepoint to the lookat point.
Math::Vector view = at - from; glm::vec3 view = at - from;
float length = glm::length(view); float length = glm::length(view);
assert(! IsZero(length) ); assert(! IsZero(length) );
@ -281,18 +281,18 @@ inline void LoadViewMatrix(Math::Matrix &mat, const Math::Vector &from,
// vector onto the up vector. The projection is the y basis vector. // vector onto the up vector. The projection is the y basis vector.
float dotProduct = DotProduct(worldUp, view); float dotProduct = DotProduct(worldUp, view);
Math::Vector up = worldUp - dotProduct * view; glm::vec3 up = worldUp - dotProduct * view;
// If this vector has near-zero length because the input specified a // If this vector has near-zero length because the input specified a
// bogus up vector, let's try a default up vector // bogus up vector, let's try a default up vector
if ( IsZero(length = glm::length(up)) ) if ( IsZero(length = glm::length(up)) )
{ {
up = Math::Vector(0.0f, 1.0f, 0.0f) - view.y * view; up = glm::vec3(0.0f, 1.0f, 0.0f) - view.y * view;
// If we still have near-zero length, resort to a different axis. // If we still have near-zero length, resort to a different axis.
if ( IsZero(length = glm::length(up)) ) if ( IsZero(length = glm::length(up)) )
{ {
up = Math::Vector(0.0f, 0.0f, 1.0f) - view.z * view; up = glm::vec3(0.0f, 0.0f, 1.0f) - view.z * view;
assert(! IsZero(glm::length(up)) ); assert(! IsZero(glm::length(up)) );
} }
@ -303,7 +303,7 @@ inline void LoadViewMatrix(Math::Matrix &mat, const Math::Vector &from,
// The x basis vector is found simply with the cross product of the y // The x basis vector is found simply with the cross product of the y
// and z basis vectors // and z basis vectors
Math::Vector right = CrossProduct(up, view); glm::vec3 right = CrossProduct(up, view);
// Start building the matrix. The first three rows contains the basis // Start building the matrix. The first three rows contains the basis
// vectors used to rotate the view to point at the lookat point // vectors used to rotate the view to point at the lookat point
@ -376,7 +376,7 @@ inline void LoadOrthoProjectionMatrix(Math::Matrix &mat, float left, float right
* \param mat result matrix * \param mat result matrix
* \param trans vector of translation * \param trans vector of translation
*/ */
inline void LoadTranslationMatrix(Math::Matrix &mat, const Math::Vector &trans) inline void LoadTranslationMatrix(Math::Matrix &mat, const glm::vec3 &trans)
{ {
mat.LoadIdentity(); mat.LoadIdentity();
/* (1,4) */ mat.m[12] = trans.x; /* (1,4) */ mat.m[12] = trans.x;
@ -389,7 +389,7 @@ inline void LoadTranslationMatrix(Math::Matrix &mat, const Math::Vector &trans)
* \param mat result matrix * \param mat result matrix
* \param scale vector with scaling factors for X, Y, Z * \param scale vector with scaling factors for X, Y, Z
*/ */
inline void LoadScaleMatrix(Math::Matrix &mat, const Math::Vector &scale) inline void LoadScaleMatrix(Math::Matrix &mat, const glm::vec3 &scale)
{ {
mat.LoadIdentity(); mat.LoadIdentity();
/* (1,1) */ mat.m[0 ] = scale.x; /* (1,1) */ mat.m[0 ] = scale.x;
@ -445,11 +445,11 @@ inline void LoadRotationZMatrix(Math::Matrix &mat, float angle)
* \param dir axis of rotation * \param dir axis of rotation
* \param angle angle [radians] * \param angle angle [radians]
*/ */
inline void LoadRotationMatrix(Math::Matrix &mat, const Math::Vector &dir, float angle) inline void LoadRotationMatrix(Math::Matrix &mat, const glm::vec3 &dir, float angle)
{ {
float cos = cosf(angle); float cos = cosf(angle);
float sin = sinf(angle); float sin = sinf(angle);
Math::Vector v = Normalize(dir); glm::vec3 v = Normalize(dir);
mat.LoadIdentity(); mat.LoadIdentity();
@ -467,7 +467,7 @@ inline void LoadRotationMatrix(Math::Matrix &mat, const Math::Vector &dir, float
} }
//! Calculates the matrix to make three rotations in the order X, Z and Y //! Calculates the matrix to make three rotations in the order X, Z and Y
inline void LoadRotationXZYMatrix(Math::Matrix &mat, const Math::Vector &angles) inline void LoadRotationXZYMatrix(Math::Matrix &mat, const glm::vec3 &angles)
{ {
Math::Matrix temp; Math::Matrix temp;
LoadRotationXMatrix(temp, angles.x); LoadRotationXMatrix(temp, angles.x);
@ -480,7 +480,7 @@ inline void LoadRotationXZYMatrix(Math::Matrix &mat, const Math::Vector &angles)
} }
//! Calculates the matrix to make three rotations in the order Z, X and Y //! Calculates the matrix to make three rotations in the order Z, X and Y
inline void LoadRotationZXYMatrix(Math::Matrix &mat, const Math::Vector &angles) inline void LoadRotationZXYMatrix(Math::Matrix &mat, const glm::vec3 &angles)
{ {
Math::Matrix temp; Math::Matrix temp;
LoadRotationZMatrix(temp, angles.z); LoadRotationZMatrix(temp, angles.z);
@ -493,7 +493,7 @@ inline void LoadRotationZXYMatrix(Math::Matrix &mat, const Math::Vector &angles)
} }
//! Returns the distance between projections on XZ plane of two vectors //! Returns the distance between projections on XZ plane of two vectors
inline float DistanceProjected(const Math::Vector &a, const Math::Vector &b) inline float DistanceProjected(const glm::vec3 &a, const glm::vec3 &b)
{ {
return sqrtf( (a.x-b.x)*(a.x-b.x) + return sqrtf( (a.x-b.x)*(a.x-b.x) +
(a.z-b.z)*(a.z-b.z) ); (a.z-b.z)*(a.z-b.z) );
@ -503,10 +503,10 @@ inline float DistanceProjected(const Math::Vector &a, const Math::Vector &b)
/** /**
* \param p1,p2,p3 points defining the plane * \param p1,p2,p3 points defining the plane
*/ */
inline Math::Vector NormalToPlane(const Math::Vector &p1, const Math::Vector &p2, const Math::Vector &p3) inline glm::vec3 NormalToPlane(const glm::vec3 &p1, const glm::vec3 &p2, const glm::vec3 &p3)
{ {
Math::Vector u = p3 - p1; glm::vec3 u = p3 - p1;
Math::Vector v = p2 - p1; glm::vec3 v = p2 - p1;
return Normalize(CrossProduct(u, v)); return Normalize(CrossProduct(u, v));
} }
@ -516,9 +516,9 @@ inline Math::Vector NormalToPlane(const Math::Vector &p1, const Math::Vector &p2
* \param p1,p2 line start and end * \param p1,p2 line start and end
* \param dist scaling factor from \a p1, relative to distance between \a p1 and \a p2 * \param dist scaling factor from \a p1, relative to distance between \a p1 and \a p2
*/ */
inline Math::Vector SegmentPoint(const Math::Vector &p1, const Math::Vector &p2, float dist) inline glm::vec3 SegmentPoint(const glm::vec3 &p1, const glm::vec3 &p2, float dist)
{ {
Math::Vector direction = glm::normalize(p2 - p1); glm::vec3 direction = glm::normalize(p2 - p1);
return p1 + direction * dist; return p1 + direction * dist;
} }
@ -528,10 +528,10 @@ inline Math::Vector SegmentPoint(const Math::Vector &p1, const Math::Vector &p2,
* \param p the point * \param p the point
* \param a,b,c points defining the plane * \param a,b,c points defining the plane
*/ */
inline float DistanceToPlane(const Math::Vector &a, const Math::Vector &b, inline float DistanceToPlane(const glm::vec3 &a, const glm::vec3 &b,
const Math::Vector &c, const Math::Vector &p) const glm::vec3 &c, const glm::vec3 &p)
{ {
Math::Vector n = NormalToPlane(a, b, c); glm::vec3 n = NormalToPlane(a, b, c);
float d = -(n.x*a.x + n.y*a.y + n.z*a.z); float d = -(n.x*a.x + n.y*a.y + n.z*a.z);
return fabs(n.x*p.x + n.y*p.y + n.z*p.z + d); return fabs(n.x*p.x + n.y*p.y + n.z*p.z + d);
@ -542,10 +542,10 @@ inline float DistanceToPlane(const Math::Vector &a, const Math::Vector &b,
* \param plane1 array of three vectors defining the first plane * \param plane1 array of three vectors defining the first plane
* \param plane2 array of three vectors defining the second plane * \param plane2 array of three vectors defining the second plane
*/ */
inline bool IsSamePlane(const Math::Vector (&plane1)[3], const Math::Vector (&plane2)[3]) inline bool IsSamePlane(const glm::vec3 (&plane1)[3], const glm::vec3 (&plane2)[3])
{ {
Math::Vector n1 = NormalToPlane(plane1[0], plane1[1], plane1[2]); glm::vec3 n1 = NormalToPlane(plane1[0], plane1[1], plane1[2]);
Math::Vector n2 = NormalToPlane(plane2[0], plane2[1], plane2[2]); glm::vec3 n2 = NormalToPlane(plane2[0], plane2[1], plane2[2]);
if ( fabs(n1.x-n2.x) > 0.1f || if ( fabs(n1.x-n2.x) > 0.1f ||
fabs(n1.y-n2.y) > 0.1f || fabs(n1.y-n2.y) > 0.1f ||
@ -560,8 +560,8 @@ inline bool IsSamePlane(const Math::Vector (&plane1)[3], const Math::Vector (&pl
} }
//! Calculates the intersection "i" right "of" the plane "abc" (TODO: ?) //! Calculates the intersection "i" right "of" the plane "abc" (TODO: ?)
inline bool Intersect(const Math::Vector &a, const Math::Vector &b, const Math::Vector &c, inline bool Intersect(const glm::vec3 &a, const glm::vec3 &b, const glm::vec3 &c,
const Math::Vector &d, const Math::Vector &e, Math::Vector &i) const glm::vec3 &d, const glm::vec3 &e, glm::vec3 &i)
{ {
float d1 = (d.x-a.x)*((b.y-a.y)*(c.z-a.z)-(c.y-a.y)*(b.z-a.z)) - float d1 = (d.x-a.x)*((b.y-a.y)*(c.z-a.z)-(c.y-a.y)*(b.z-a.z)) -
(d.y-a.y)*((b.x-a.x)*(c.z-a.z)-(c.x-a.x)*(b.z-a.z)) + (d.y-a.y)*((b.x-a.x)*(c.z-a.z)-(c.x-a.x)*(b.z-a.z)) +
@ -583,7 +583,7 @@ inline bool Intersect(const Math::Vector &a, const Math::Vector &b, const Math::
//! Calculates the intersection of the straight line passing through p (x, z) //! Calculates the intersection of the straight line passing through p (x, z)
/** Line is parallel to the y axis, with the plane abc. Returns p.y. (TODO: ?) */ /** Line is parallel to the y axis, with the plane abc. Returns p.y. (TODO: ?) */
inline bool IntersectY(const Math::Vector &a, const Math::Vector &b, const Math::Vector &c, Math::Vector &p) inline bool IntersectY(const glm::vec3 &a, const glm::vec3 &b, const glm::vec3 &c, glm::vec3 &p)
{ {
float d = (b.x-a.x)*(c.z-a.z) - (c.x-a.x)*(b.z-a.z); float d = (b.x-a.x)*(c.z-a.z) - (c.x-a.x)*(b.z-a.z);
float d1 = (p.x-a.x)*(c.z-a.z) - (c.x-a.x)*(p.z-a.z); float d1 = (p.x-a.x)*(c.z-a.z) - (c.x-a.x)*(p.z-a.z);
@ -598,9 +598,9 @@ inline bool IntersectY(const Math::Vector &a, const Math::Vector &b, const Math:
} }
//! Calculates the end point //! Calculates the end point
inline Math::Vector LookatPoint(const Math::Vector &eye, float angleH, float angleV, float length) inline glm::vec3 LookatPoint(const glm::vec3 &eye, float angleH, float angleV, float length)
{ {
Math::Vector lookat = eye; glm::vec3 lookat = eye;
lookat.z += length; lookat.z += length;
RotatePoint(eye, angleH, angleV, lookat); RotatePoint(eye, angleH, angleV, lookat);
@ -610,7 +610,7 @@ inline Math::Vector LookatPoint(const Math::Vector &eye, float angleH, float ang
//! Transforms the point \a p by matrix \a m //! Transforms the point \a p by matrix \a m
/** Is equal to multiplying the matrix by the vector (of course without perspective divide). */ /** Is equal to multiplying the matrix by the vector (of course without perspective divide). */
inline Math::Vector Transform(const Math::Matrix &m, const Math::Vector &p) inline glm::vec3 Transform(const Math::Matrix &m, const glm::vec3 &p)
{ {
return MatrixVectorMultiply(m, p); return MatrixVectorMultiply(m, p);
} }
@ -620,7 +620,7 @@ inline Math::Vector Transform(const Math::Matrix &m, const Math::Vector &p)
* \param p point to project * \param p point to project
* \param a,b two ends of the line * \param a,b two ends of the line
*/ */
inline Math::Vector Projection(const Math::Vector &a, const Math::Vector &b, const Math::Vector &p) inline glm::vec3 Projection(const glm::vec3 &a, const glm::vec3 &b, const glm::vec3 &p)
{ {
float k = DotProduct(b - a, p - a); float k = DotProduct(b - a, p - a);
k /= DotProduct(b - a, b - a); k /= DotProduct(b - a, b - a);
@ -629,7 +629,7 @@ inline Math::Vector Projection(const Math::Vector &a, const Math::Vector &b, con
} }
//! Calculates point of view to look at a center two angles and a distance //! Calculates point of view to look at a center two angles and a distance
inline Math::Vector RotateView(Math::Vector center, float angleH, float angleV, float dist) inline glm::vec3 RotateView(glm::vec3 center, float angleH, float angleV, float dist)
{ {
Math::Matrix mat1, mat2; Math::Matrix mat1, mat2;
LoadRotationZMatrix(mat1, -angleV); LoadRotationZMatrix(mat1, -angleV);
@ -637,7 +637,7 @@ inline Math::Vector RotateView(Math::Vector center, float angleH, float angleV,
Math::Matrix mat = MultiplyMatrices(mat2, mat1); Math::Matrix mat = MultiplyMatrices(mat2, mat1);
Math::Vector eye; glm::vec3 eye{};
eye.x = 0.0f+dist; eye.x = 0.0f+dist;
eye.y = 0.0f; eye.y = 0.0f;
eye.z = 0.0f; eye.z = 0.0f;