From 2409443c4cf18c98afa97f2f9e02aec46e2dd646 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20=C5=A0toura=C4=8D?= <525032@mail.muni.cz>
Date: Mon, 18 Sep 2023 19:28:41 +0200
Subject: [PATCH] added name conv. to simulator variables
---
src/studio/include/studio/simulator.hpp | 10 +--
src/studio/src/simulator.cpp | 96 ++++++++++++-------------
2 files changed, 53 insertions(+), 53 deletions(-)
diff --git a/src/studio/include/studio/simulator.hpp b/src/studio/include/studio/simulator.hpp
index c455bdd..939bc29 100644
--- a/src/studio/include/studio/simulator.hpp
+++ b/src/studio/include/studio/simulator.hpp
@@ -42,7 +42,7 @@ enum class state { select, move, rotate, plus };
struct Simulator : public osi::Simulator
{
- // TODO: Non-void methods to functions with extra parameters
+ // TO DO: Non-void methods to functions with extra parameters
Simulator();
~Simulator();
@@ -58,12 +58,12 @@ struct Simulator : public osi::Simulator
void processInput();
- void addRay(glm::vec3 rayPosition, glm::vec3 rayDirection);
+ void addRay(glm::vec3 ray_position, glm::vec3 ray_direction);
void addSelectionAABB(node_ptr node);
void addPreAddAABB(node_ptr node, Frame position);
//findIntersection uses functions 'intersect_axis' and 'intersect'
- node_ptr findIntersection(glm::vec3 rayPosition, glm::vec3 rayDirection); // Not node tree compatible
+ node_ptr findIntersection(glm::vec3 ray_position, glm::vec3 ray_direction); // Not node tree compatible
std::pair<glm::vec3, glm::vec3> get_pick_ray();
void manageSelection(node_ptr nearest_node); // Not node tree compatible
@@ -106,8 +106,8 @@ private:
std::map<std::string, shader_ptr> my_shaders;
};
-std::pair<float, float> intersect_axis(float rayDirection_a, float rayPosition_a, float LH_first_a, float LH_second_a);
-std::pair<float, float> intersect(glm::vec3 rayPosition, glm::vec3 rayDirection, std::pair<glm::vec3, glm::vec3> LH);
+std::pair<float, float> intersect_axis(float ray_direction_a, float ray_position_a, float LH_first_a, float LH_second_a);
+std::pair<float, float> intersect(glm::vec3 ray_position, glm::vec3 ray_direction, std::pair<glm::vec3, glm::vec3> LH);
}
diff --git a/src/studio/src/simulator.cpp b/src/studio/src/simulator.cpp
index e724b20..ebb6d84 100644
--- a/src/studio/src/simulator.cpp
+++ b/src/studio/src/simulator.cpp
@@ -77,7 +77,7 @@ std::vector<float> lit_cube_normals =
0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f
};
-std::vector<float> getnormals(std::vector<unsigned int> &indices, std::vector<float> &vertices)
+std::vector<float> get_normals(std::vector<unsigned int> &indices, std::vector<float> &vertices)
{
std::vector<float> normals;
for (int i = 0; i < indices.size(); i += 3)
@@ -342,14 +342,14 @@ void Simulator::processInput()
ASSUMPTION(glGetError() == GL_NO_ERROR);
}
-void Simulator::addRay(glm::vec3 rayPosition, glm::vec3 rayDirection)
+void Simulator::addRay(glm::vec3 ray_position, glm::vec3 ray_direction)
{
- object_ptr ray = std::make_shared<Object>(Object{{0, 0, 0, rayDirection.x, rayDirection.y, rayDirection.z},
+ object_ptr ray = std::make_shared<Object>(Object{{0, 0, 0, ray_direction.x, ray_direction.y, ray_direction.z},
{0, 1}, {}, glm::vec3(0.5f, 1, 0.31f), "basic"});
ray->setDrawMode(GL_LINES);
ray->setSelectability(false);
- frame_ptr ray_frame = std::make_shared<Frame>(rayPosition);
+ frame_ptr ray_frame = std::make_shared<Frame>(ray_position);
scene.emplace_back(std::make_shared<Node>(ray_frame));
scene.back()->addObject(std::move(ray));
}
@@ -391,7 +391,7 @@ void Simulator::addPreAddAABB(node_ptr node, Frame position)
scene.erase(scene.end() - 2);
}
-node_ptr Simulator::findIntersection(glm::vec3 rayPosition, glm::vec3 rayDirection)
+node_ptr Simulator::findIntersection(glm::vec3 ray_position, glm::vec3 ray_direction)
{
node_ptr nearest_node = nullptr;
float nearest_t = std::numeric_limits<float>::infinity();
@@ -404,7 +404,7 @@ node_ptr Simulator::findIntersection(glm::vec3 rayPosition, glm::vec3 rayDirecti
continue;
auto LH_world = obj->getAABB().getLHWorld(node);
- auto [ t0, t1 ] = intersect(rayPosition, rayDirection, LH_world);
+ auto [ t0, t1 ] = intersect(ray_position, ray_direction, LH_world);
if ( t1 < t0 || t1 < 0)
continue;
@@ -432,42 +432,42 @@ std::pair<glm::vec3, glm::vec3> Simulator::get_pick_ray()
// https://gamedev.stackexchange.com/questions/12360/how-do-you-determine-which-object-surface-the-users-pointing-at-with-lwjgl/12370#12370
//get the mouse position in screenSpace coords
- float aspectRatio = camera->getWindowSize().x / camera->getWindowSize().y;
- float screenSpaceX = ((float) mouse().pos().x / (window().size().x / 2) - 1.0f) * aspectRatio;
- float screenSpaceY = (1.0f - (float) mouse().pos().y / (window().size().y / 2));
+ float aspect_ratio = camera->getWindowSize().x / camera->getWindowSize().y;
+ float screen_space_X = ((float) mouse().pos().x / (window().size().x / 2) - 1.0f) * aspect_ratio;
+ float screen_space_Y = (1.0f - (float) mouse().pos().y / (window().size().y / 2));
- float viewRatio = glm::tan((glm::pi<float>() / (180.f/camera->getFOV()) / 2.0f)); // * zoomFactor;
+ float view_ratio = glm::tan((glm::pi<float>() / (180.f/camera->getFOV()) / 2.0f)); // * zoomFactor;
- screenSpaceX = screenSpaceX * viewRatio;
- screenSpaceY = screenSpaceY * viewRatio;
+ screen_space_X = screen_space_X * view_ratio;
+ screen_space_Y = screen_space_Y * view_ratio;
//Find the far and near camera spaces
- float nearPlane = 0.1f;
- float farPlane = 100.0f;
- glm::vec4 cameraSpaceNear = glm::vec4(screenSpaceX * nearPlane, screenSpaceY * nearPlane, -nearPlane, 1);
- glm::vec4 cameraSpaceFar = glm::vec4(screenSpaceX * farPlane, screenSpaceY * farPlane, -farPlane, 1);
+ float near_plane = 0.1f;
+ float far_plane = 100.0f;
+ glm::vec4 camera_space_near = glm::vec4(screen_space_X * near_plane, screen_space_Y * near_plane, -near_plane, 1);
+ glm::vec4 camera_space_far = glm::vec4(screen_space_X * far_plane, screen_space_Y * far_plane, -far_plane, 1);
//Unproject the 2D window into 3D to see where in 3D we're actually clicking
- glm::mat4 invView = glm::inverse(view);
- // Matrix4f.transform(invView, cameraSpaceNear, worldSpaceNear); ??????????????
- glm::vec4 worldSpaceNear = invView * cameraSpaceNear;
- // Matrix4f.transform(invView, cameraSpaceFar, worldSpaceFar); ???????????????
- glm::vec4 worldSpaceFar = cameraSpaceFar * worldSpaceFar;
+ glm::mat4 inv_view = glm::inverse(view);
+ // Matrix4f.transform(invView, cameraSpaceNear, world_space_near); ??????????????
+ glm::vec4 world_space_near = inv_view * camera_space_near;
+ // Matrix4f.transform(invView, cameraSpaceFar, world_space_far); ???????????????
+ glm::vec4 world_space_far = camera_space_far * world_space_far;
//calculate the ray position and direction
- glm::vec3 rayPosition = glm::vec3(worldSpaceNear.x, worldSpaceNear.y, worldSpaceNear.z);
- glm::vec3 rayDirection = -glm::vec3(worldSpaceFar.x - worldSpaceNear.x,
- worldSpaceFar.y - worldSpaceNear.y,
- worldSpaceFar.z - worldSpaceNear.z);
+ glm::vec3 ray_position = glm::vec3(world_space_near.x, world_space_near.y, world_space_near.z);
+ glm::vec3 ray_direction = -glm::vec3(world_space_far.x - world_space_near.x,
+ world_space_far.y - world_space_near.y,
+ world_space_far.z - world_space_near.z);
- rayDirection = camera->getFrame()->getRotation() * rayDirection;
+ ray_direction = camera->getFrame()->getRotation() * ray_direction;
/* VISUAL REPRESENTATION OF RAY */
- // addRay(rayPosition, rayDirection);
+ // addRay(ray_position, ray_direction);
- rayDirection = glm::normalize(rayDirection);
+ ray_direction = glm::normalize(ray_direction);
- return {rayPosition, rayDirection};
+ return {ray_position, ray_direction};
}
void Simulator::removeNode(node_ptr node)
@@ -509,9 +509,9 @@ void Simulator::selectObject()
if (!mouse().just_released().contains("MouseLeft"))
return;
- auto [ rayPosition, rayDirection ] = get_pick_ray();
+ auto [ ray_position, ray_direction ] = get_pick_ray();
- auto nearest_node = findIntersection(rayPosition, rayDirection);
+ auto nearest_node = findIntersection(ray_position, ray_direction);
manageSelection(nearest_node);
}
@@ -532,10 +532,10 @@ void Simulator::moveObject()
return;
}
- auto [ rayPosition, rayDirection ] = get_pick_ray();
+ auto [ ray_position, ray_direction ] = get_pick_ray();
// Initial click not onto the selected object
- if (!object_moving && findIntersection(rayPosition, rayDirection) != selection)
+ if (!object_moving && findIntersection(ray_position, ray_direction) != selection)
return;
/* Controller setup */
@@ -543,11 +543,11 @@ void Simulator::moveObject()
controller->setup(timer().dt(), selection->getFrame());
if (keyboard().down().contains("LeftShift"))
- controller->mouseElevationMove(rayPosition, rayDirection,
+ controller->mouseElevationMove(ray_position, ray_direction,
active_cameras[0]->getFrame()->getRotation(),
prev_plane_intersect, object_moving);
else
- controller->mouseHorizontalMove(rayPosition, rayDirection, prev_plane_intersect, object_moving);
+ controller->mouseHorizontalMove(ray_position, ray_direction, prev_plane_intersect, object_moving);
}
void Simulator::rotateObject()
@@ -570,11 +570,11 @@ void Simulator::addObject()
glm::quat rotation = selection->getFrame()->getRotation();
glm::vec3 scale = selection->getFrame()->getScale();
- auto [ rayPosition , rayDirection ] = get_pick_ray();
+ auto [ ray_position , ray_direction ] = get_pick_ray();
- float distance = glm::length(rayPosition - position);
+ float distance = glm::length(ray_position - position);
- auto new_item_pos = rayPosition + distance * rayDirection;
+ auto new_item_pos = ray_position + distance * ray_direction;
Frame new_item_frame(new_item_pos, rotation, scale);
scene.emplace_back(std::make_shared<Node>(std::make_shared<Frame>(new_item_frame)));
@@ -618,33 +618,33 @@ void Simulator::processMouse()
/* INDEPENDENT FUNCTIONS */
-std::pair<float, float> intersect_axis(float rayDirection_a, float rayPosition_a,
+std::pair<float, float> intersect_axis(float ray_direction_a, float ray_position_a,
float LH_first_a, float LH_second_a)
{
float t_low;
float t_high;
- if (rayDirection_a == 0 && LH_first_a <= rayPosition_a && rayPosition_a <= LH_second_a)
+ if (ray_direction_a == 0 && LH_first_a <= ray_position_a && ray_position_a <= LH_second_a)
{
t_low = -std::numeric_limits<float>::infinity();
t_high = std::numeric_limits<float>::infinity();
}
else
{
- t_low = glm::min((LH_first_a - rayPosition_a) / rayDirection_a,
- (LH_second_a - rayPosition_a) / rayDirection_a);
- t_high = glm::max((LH_first_a - rayPosition_a) / rayDirection_a,
- (LH_second_a - rayPosition_a) / rayDirection_a);
+ t_low = glm::min((LH_first_a - ray_position_a) / ray_direction_a,
+ (LH_second_a - ray_position_a) / ray_direction_a);
+ t_high = glm::max((LH_first_a - ray_position_a) / ray_direction_a,
+ (LH_second_a - ray_position_a) / ray_direction_a);
}
return { t_low, t_high };
}
-std::pair<float, float> intersect(glm::vec3 rayPosition, glm::vec3 rayDirection,
+std::pair<float, float> intersect(glm::vec3 ray_position, glm::vec3 ray_direction,
std::pair<glm::vec3, glm::vec3> LH)
{
- auto [ tx, tX ] = intersect_axis(rayDirection.x, rayPosition.x, LH.first.x, LH.second.x);
- auto [ ty, tY ] = intersect_axis(rayDirection.y, rayPosition.y, LH.first.y, LH.second.y);
- auto [ tz, tZ ] = intersect_axis(rayDirection.z, rayPosition.z, LH.first.z, LH.second.z);
+ auto [ tx, tX ] = intersect_axis(ray_direction.x, ray_position.x, LH.first.x, LH.second.x);
+ auto [ ty, tY ] = intersect_axis(ray_direction.y, ray_position.y, LH.first.y, LH.second.y);
+ auto [ tz, tZ ] = intersect_axis(ray_direction.z, ray_position.z, LH.first.z, LH.second.z);
float t0 = glm::max(tx, glm::max(ty, tz));
float t1 = glm::min(tX, glm::min(tY, tZ));
--
GitLab