devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【开发日志】2022.09.09 ZENO viewportwidge---raycast---sphere&AABB Box_sphere raycast

作者：凡人多烦事01 | 2024-05-01 20:31:09

赞

踩

sphere raycast

RAYCAST

vdoc.pub_game-physics-cookbook.pdf

76a428ddde414a77a460da0a856d5d94.png

Linetest  Sphere

0d9b430d2c464f428a45c474769c67bb.png

 b57450e9f367471aa82ef4a965a31990.png

6f7e7bcee00d4df995d6aaeacc98f2d5.png  

  1. bool Raycast(const Sphere& sphere, const Ray& ray, RaycastResult* outResult) {
  2. 	ResetRaycastResult(outResult);
  3.  
  4. 	vec3 e = sphere.position - ray.origin;
  5. 	float rSq = sphere.radius * sphere.radius;
  6.  
  7. 	float eSq = MagnitudeSq(e);
  8. 	float a = Dot(e, ray.direction); // ray.direction is assumed to be normalized
  9. 	float bSq = /*sqrtf(*/eSq - (a * a)/*)*/;
  10. 	float f = sqrt(fabsf((rSq)- /*(b * b)*/bSq));
  11.  
  12. 	// Assume normal intersection!
  13. 	float t = a - f;
  14.  
  15. 	// No collision has happened
  16. 	if (rSq - (eSq - a * a) < 0.0f) {
  17. 		return false;
  18. 	}
  19. 	// Ray starts inside the sphere
  20. 	else if (eSq < rSq) {
  21. 		// Just reverse direction
  22. 		t = a + f;
  23. 	}
  24. 	if (outResult != 0) {
  25. 		outResult->t = t;
  26. 		outResult->hit = true;
  27. 		outResult->point = ray.origin + ray.direction * t;
  28. 		outResult->normal = Normalized(outResult->point - sphere.position);
  29. 	}
  30. 	return true;
  31. }
  1. bool Linetest(const Sphere& sphere, const Line& line) {
  2. 	Point closest = ClosestPoint(line, sphere.position);
  3. 	float distSq = MagnitudeSq(sphere.position - closest);
  4. 	return distSq <= (sphere.radius * sphere.radius);
  5. }

ZENO

  1. static std::optional<float> ray_sphere_intersect(
  2.     zeno::vec3f const &ray_pos,
  3.     zeno::vec3f const &ray_dir,
  4.     zeno::vec3f const &sphere_center,
  5.     float sphere_radius
  6. ) {
  7.     auto &p = ray_pos;
  8.     auto &d = ray_dir;
  9.     auto &c = sphere_center;
  10.     auto &r = sphere_radius;
  11.     float t = zeno::dot(c - p, d);
  12.     if (t < 0) {
  13.         return std::nullopt;
  14.     }
  15.     zeno::vec3f dist = t * d + p - c;
  16.     float l = zeno::length(dist);
  17.     if (l > r) {
  18.         return std::nullopt;
  19.     }
  20.     float t_diff = std::sqrt(r * r - l * l);
  21.     float final_t = t - t_diff;
  22.     return final_t;
  23. }
  1. if (zeno::objectGetFocusCenterRadius(ptr, center, radius)) {
  2.     if (auto ret = ray_sphere_intersect(ro, rd, center, radius)) {
  3.         float t = *ret;
  4.         if (t < min_t) {
  5.             min_t = t;
  6.             name = key;
  7.         }
  8.     }
  9. }
objectGetFocusCenterRadius（）在ObjectGeometryInfo.cpp 里，见后文 

98cda641a5ca47a090c6b9986ba65762.png

ff1143c3e14e414fbc926737040eb7b3.png

  1. bool Raycast(const AABB& aabb, const Ray& ray, RaycastResult* outResult) {
  2. 	ResetRaycastResult(outResult);
  3.  
  4. 	vec3 min = GetMin(aabb);
  5. 	vec3 max = GetMax(aabb);
  6.  
  7. 	// Any component of direction could be 0!
  8. 	// Address this by using a small number, close to
  9. 	// 0 in case any of directions components are 0
  10. 	float t1 = (min.x - ray.origin.x) / (CMP(ray.direction.x, 0.0f) ? 0.00001f : ray.direction.x);
  11. 	float t2 = (max.x - ray.origin.x) / (CMP(ray.direction.x, 0.0f) ? 0.00001f : ray.direction.x);
  12. 	float t3 = (min.y - ray.origin.y) / (CMP(ray.direction.y, 0.0f) ? 0.00001f : ray.direction.y);
  13. 	float t4 = (max.y - ray.origin.y) / (CMP(ray.direction.y, 0.0f) ? 0.00001f : ray.direction.y);
  14. 	float t5 = (min.z - ray.origin.z) / (CMP(ray.direction.z, 0.0f) ? 0.00001f : ray.direction.z);
  15. 	float t6 = (max.z - ray.origin.z) / (CMP(ray.direction.z, 0.0f) ? 0.00001f : ray.direction.z);
  16.  
  17. 	float tmin = fmaxf(fmaxf(fminf(t1, t2), fminf(t3, t4)), fminf(t5, t6));
  18. 	float tmax = fminf(fminf(fmaxf(t1, t2), fmaxf(t3, t4)), fmaxf(t5, t6));
  19.  
  20. 	// if tmax < 0, ray is intersecting AABB
  21. 	// but entire AABB is behing it's origin
  22. 	if (tmax < 0) {
  23. 		return false;
  24. 	}
  25.  
  26. 	// if tmin > tmax, ray doesn't intersect AABB
  27. 	if (tmin > tmax) {
  28. 		return false;
  29. 	}
  30.  
  31. 	float t_result = tmin;
  32.  
  33. 	// If tmin is < 0, tmax is closer
  34. 	if (tmin < 0.0f) {
  35. 		t_result = tmax;
  36. 	}
  37.  
  38. 	if (outResult != 0) {
  39. 		outResult->t = t_result;
  40. 		outResult->hit = true;
  41. 		outResult->point = ray.origin + ray.direction * t_result;
  42.  
  43. 		vec3 normals[] = {
  44. 			vec3(-1, 0, 0),
  45. 			vec3(1, 0, 0),
  46. 			vec3(0, -1, 0),
  47. 			vec3(0, 1, 0),
  48. 			vec3(0, 0, -1),
  49. 			vec3(0, 0, 1)
  50. 		};
  51. 		float t[] = { t1, t2, t3, t4, t5, t6 };
  52.  
  53. 		for (int i = 0; i < 6; ++i) {
  54. 			if (CMP(t_result, t[i])) {
  55. 				outResult->normal = normals[i];
  56. 			}
  57. 		}
  58. 	}
  59.  
  60. 	return true;
  61. }
  1. bool Linetest(const AABB& aabb, const Line& line) {
  2. 	Ray ray;
  3. 	ray.origin = line.start;
  4. 	ray.direction = Normalized(line.end - line.start);
  5. 	RaycastResult raycast;
  6. 	if (!Raycast(aabb, ray, &raycast)) {
  7. 		return false;
  8. 	}
  9. 	float t = raycast.t;
  10.  
  11. 	return t >= 0 && t * t <= LengthSq(line);
  12. }

ZENO 

  1. static std::optional<float> ray_box_intersect(
  2.     zeno::vec3f const &bmin,
  3.     zeno::vec3f const &bmax,
  4.     zeno::vec3f const &ray_pos,
  5.     zeno::vec3f const &ray_dir
  6. ) {
  7.     //objectGetBoundingBox(IObject *ptr, vec3f &bmin, vec3f &bmax);
  8.  
  9.     auto &min = bmin;
  10.     auto &max = bmax;
  11.     auto &p = ray_pos;
  12.     auto &d = ray_dir;
  13.     //auto &t = t;
  14.  
  15.     float t1 = (min[0] - p[0]) / (CMP(d[0], 0.0f) ? 0.00001f : d[0]);
  16.     float t2 = (max[0] - p[0]) / (CMP(d[0], 0.0f) ? 0.00001f : d[0]);
  17.     float t3 = (min[1] - p[1]) / (CMP(d[1], 0.0f) ? 0.00001f : d[1]);
  18.     float t4 = (max[1] - p[1]) / (CMP(d[1], 0.0f) ? 0.00001f : d[1]);
  19.     float t5 = (min[2] - p[2]) / (CMP(d[2], 0.0f) ? 0.00001f : d[2]);
  20.     float t6 = (max[2] - p[2]) / (CMP(d[2], 0.0f) ? 0.00001f : d[2]);
  21.  
  22.     float tmin = fmaxf(fmaxf(fminf(t1, t2), fminf(t3, t4)), fminf(t5, t6));
  23.     float tmax = fminf(fminf(fmaxf(t1, t2), fmaxf(t3, t4)), fmaxf(t5, t6));
  24.  
  25.     // if tmax < 0, ray is intersecting AABB
  26.     // but entire AABB is behing it's origin
  27.     if (tmax < 0) {
  28.         return std::nullopt;
  29.     }
  30.  
  31.     // if tmin > tmax, ray doesn't intersect AABB
  32.     if (tmin > tmax) {
  33.         return std::nullopt;
  34.     }
  35.  
  36.     float t_result = tmin;
  37.  
  38.     // If tmin is < 0, tmax is closer
  39.     if (tmin < 0.0f) {
  40.         t_result = tmax;
  41.     }
  42.     //zeno::vec3f  final_t = p + d * t_result;
  43.     return t_result;
  44. }
  1. zeno::vec3f bmin,bmax;
  2.     if (zeno::objectGetBoundingBox(ptr,bmin,bmax) ){
  3.         if (auto ret = ray_box_intersect(bmin, bmax, ro, rd)) {
  4.             float t = *ret;
  5.             if (t < min_t) {
  6.                 min_t = t;
  7.                 name = key;
  8.             }
  9.         }
  10.     }
  11. }

ObjectGeometryInfo.cpp 

/zeno/zeno/src/funcs

  1. #include <zeno/funcs/ObjectGeometryInfo.h>
  2. #include <zeno/types/PrimitiveObject.h>
  3. #include <zeno/funcs/PrimitiveTools.h>
  4. #include <zeno/types/UserData.h>
  5.  
  6. namespace zeno {
  7.  
  8. ZENO_API bool objectGetBoundingBox(IObject *ptr, vec3f &bmin, vec3f &bmax) {
  9.     auto &ud = ptr->userData();
  10.     if (ud.has("_bboxMin") && ud.has("_bboxMax")) {
  11.         bmin = ud.getLiterial<vec3f>("_bboxMin");
  12.         bmax = ud.getLiterial<vec3f>("_bboxMax");
  13.         return true;
  14.     } else {
  15.         if (auto obj = dynamic_cast<PrimitiveObject *>(ptr)) {
  16.             std::tie(bmin, bmax) = primBoundingBox(obj);
  17.             ud.setLiterial("_bboxMin", bmin);
  18.             ud.setLiterial("_bboxMax", bmax);
  19.             return true;
  20.         }
  21.         else {
  22.             return false;
  23.         }
  24.     }
  25. }
  26.  
  27.  
  28. ZENO_API bool objectGetFocusCenterRadius(IObject *ptr, vec3f &center, float &radius) {
  29.     vec3f bmin, bmax;
  30.     if (!objectGetBoundingBox(ptr, bmin, bmax))
  31.         return false;
  32.     auto delta = bmax - bmin;
  33.     radius = std::max(std::max(delta[0], delta[1]), delta[2]) * 0.5f;
  34.     center = (bmin + bmax) * 0.5f;
  35.     return true;
  36. }
  37.  
  38. }
  1. for (auto const &[key, ptr] : scene->objectsMan->pairs()) {
  2.     zeno::vec3f center;
  3.     float radius;
  4.     zeno::vec3f ro(cam_pos[0], cam_pos[1], cam_pos[2]);
  5.     zeno::vec3f rd(rdir[0], rdir[1], rdir[2]);
  6.     if (zeno::objectGetFocusCenterRadius(ptr, center, radius)) {
  7.         if (auto ret = ray_sphere_intersect(ro, rd, center, radius)) {
  8.             float t = *ret;
  9.             if (t < min_t) {
  10.                 min_t = t;
  11.                 name = key;
  12.             }
  13.         }
  14.     }
  15. }

viewportwidget.cpp

/zeno/ui/zenoedit/viewport

  1. #include <zenovis/RenderEngine.h>
  2. #include "viewportwidget.h"
  3. #include "zenovis.h"
  4. #include "camerakeyframe.h"
  5. #include "timeline/ztimeline.h"
  6. #include "graphsmanagment.h"
  7. #include "model/graphsmodel.h"
  8. #include "launch/corelaunch.h"
  9. #include "zenoapplication.h"
  10. #include "zenomainwindow.h"
  11. #include "dialog/zrecorddlg.h"
  12. #include "dialog/zrecprogressdlg.h"
  13. #include <zeno/utils/log.h>
  14. #include <zenovis/ObjectsManager.h>
  15. #include <zenovis/Scene.h>
  16. #include <zeno/funcs/ObjectGeometryInfo.h>
  17. #include <zeno/types/UserData.h>
  18. #include <viewport/zenovis.h>
  19. #include <util/log.h>
  20. #include <zenoui/style/zenostyle.h>
  21. //#include <zeno/utils/zeno_p.h>
  22. #include <nodesys/nodesmgr.h>
  23. #include <cmath>
  24. #include <algorithm>
  25. #include <optional>
  26. #include <zeno/core/Session.h>
  27. #include <zeno/extra/GlobalState.h>
  28. #include <zeno/extra/GlobalComm.h>
  29. #include <zenoui/util/uihelper.h>
  30. #include "recordvideomgr.h"
  31. #define CMP(x, y) \
  32. 	(fabsf(x - y) <= FLT_EPSILON * fmaxf(1.0f, fmaxf(fabsf(x), fabsf(y))))
  33.  
  34. static std::optional<float> ray_sphere_intersect(
  35.     zeno::vec3f const &ray_pos,
  36.     zeno::vec3f const &ray_dir,
  37.     zeno::vec3f const &sphere_center,
  38.     float sphere_radius
  39. ) {
  40.     auto &p = ray_pos;
  41.     auto &d = ray_dir;
  42.     auto &c = sphere_center;
  43.     auto &r = sphere_radius;
  44.     float t = zeno::dot(c - p, d);
  45.     if (t < 0) {
  46.         return std::nullopt;
  47.     }
  48.     zeno::vec3f dist = t * d + p - c;
  49.     float l = zeno::length(dist);
  50.     if (l > r) {
  51.         return std::nullopt;
  52.     }
  53.     float t_diff = std::sqrt(r * r - l * l);
  54.     float final_t = t - t_diff;
  55.     return final_t;
  56. }
  57.  
  58. static std::optional<float> ray_box_intersect(
  59.     zeno::vec3f const &bmin,
  60.     zeno::vec3f const &bmax,
  61.     zeno::vec3f const &ray_pos,
  62.     zeno::vec3f const &ray_dir
  63. ) {
  64.     //objectGetBoundingBox(IObject *ptr, vec3f &bmin, vec3f &bmax);
  65.  
  66.     auto &min = bmin;
  67.     auto &max = bmax;
  68.     auto &p = ray_pos;
  69.     auto &d = ray_dir;
  70.     //auto &t = t;
  71.  
  72.     float t1 = (min[0] - p[0]) / (CMP(d[0], 0.0f) ? 0.00001f : d[0]);
  73.     float t2 = (max[0] - p[0]) / (CMP(d[0], 0.0f) ? 0.00001f : d[0]);
  74.     float t3 = (min[1] - p[1]) / (CMP(d[1], 0.0f) ? 0.00001f : d[1]);
  75.     float t4 = (max[1] - p[1]) / (CMP(d[1], 0.0f) ? 0.00001f : d[1]);
  76.     float t5 = (min[2] - p[2]) / (CMP(d[2], 0.0f) ? 0.00001f : d[2]);
  77.     float t6 = (max[2] - p[2]) / (CMP(d[2], 0.0f) ? 0.00001f : d[2]);
  78.  
  79.     float tmin = fmaxf(fmaxf(fminf(t1, t2), fminf(t3, t4)), fminf(t5, t6));
  80.     float tmax = fminf(fminf(fmaxf(t1, t2), fmaxf(t3, t4)), fmaxf(t5, t6));
  81.  
  82.     // if tmax < 0, ray is intersecting AABB
  83.     // but entire AABB is behing it's origin
  84.     if (tmax < 0) {
  85.         return std::nullopt;
  86.     }
  87.  
  88.     // if tmin > tmax, ray doesn't intersect AABB
  89.     if (tmin > tmax) {
  90.         return std::nullopt;
  91.     }
  92.  
  93.     float t_result = tmin;
  94.  
  95.     // If tmin is < 0, tmax is closer
  96.     if (tmin < 0.0f) {
  97.         t_result = tmax;
  98.     }
  99.     //zeno::vec3f  final_t = p + d * t_result;
  100.     return t_result;
  101. }
  102.  
  103.  
  104. static bool test_in_selected_bounding(
  105.     QVector3D centerWS,
  106.     QVector3D cam_posWS,
  107.     QVector3D left_normWS,
  108.     QVector3D right_normWS,
  109.     QVector3D up_normWS,
  110.     QVector3D down_normWS
  111. ) {
  112.     QVector3D dir =  centerWS - cam_posWS;
  113.     dir.normalize();
  114.     bool left_test = QVector3D::dotProduct(dir, left_normWS) > 0;
  115.     bool right_test = QVector3D::dotProduct(dir, right_normWS) > 0;
  116.     bool up_test = QVector3D::dotProduct(dir, up_normWS) > 0;
  117.     bool down_test = QVector3D::dotProduct(dir, down_normWS) > 0;
  118.     return left_test && right_test && up_test && down_test;
  119. }
  120.  
  121. CameraControl::CameraControl(QWidget* parent)
  122.     : m_mmb_pressed(false)
  123.     , m_theta(0.)
  124.     , m_phi(0.)
  125.     , m_ortho_mode(false)
  126.     , m_fov(45.)
  127.     , m_radius(5.0)
  128.     , m_res(1, 1)
  129.     , m_aperture(0.1f)
  130.     , m_focalPlaneDistance(2.0f)
  131. {
  132.     transformer = std::make_unique<zeno::FakeTransformer>();
  133.     updatePerspective();
  134. }
  135.  
  136. void CameraControl::setRes(QVector2D res)
  137. {
  138.     m_res = res;
  139. }
  140.  
  141. void CameraControl::setAperture(float aperture){
  142.     m_aperture = aperture;
  143. }
  144. void CameraControl::setDisPlane(float disPlane){
  145.     m_focalPlaneDistance = disPlane;
  146. }
  147.  
  148. void CameraControl::fakeMousePressEvent(QMouseEvent* event)
  149. {
  150.     if (event->buttons() & Qt::MiddleButton) {
  151.         m_lastPos = event->pos();
  152.     }
  153.     else if (event->buttons() & Qt::LeftButton) {
  154.         m_boundRectStartPos = event->pos();
  155.         m_lastMovePos = event->pos();
  156.         // check if clicked a selected object
  157.         auto scene = Zenovis::GetInstance().getSession()->get_scene();
  158.         if (!scene->selected.empty() && mouseEnteredRing(event->x(), event->y())) {
  159.             transformer->startTransform();
  160.         }
  161.     }
  162. }
  163.  
  164. QVector2D CameraControl::qtCoordToGLCoord(int x, int y) {
  165.     auto w = res()[0];
  166.     auto h = res()[1];
  167.     auto mx = x * 1.0f;
  168.     auto my = y * 1.0f;
  169.  
  170.     mx = (2 * mx / w) - 1;
  171.     my = 1 - (2 * my / h);
  172.     return {mx, my};
  173. }
  174.  
  175. bool CameraControl::mouseEnteredRing(int x, int y) {
  176.     auto scene = Zenovis::GetInstance().getSession()->get_scene();
  177.     auto world_coord = glm::vec4(transformer->getCenter(), 1.0);
  178.     auto screen_coord = scene->camera->m_proj * scene->camera->m_view * world_coord;
  179.     screen_coord /= screen_coord[3];
  180.  
  181.     auto cx = screen_coord[0];
  182.     auto cy = screen_coord[1];
  183.  
  184.     auto mp = qtCoordToGLCoord(x, y);
  185.     auto mx = mp.x();
  186.     auto my = mp.y();
  187.  
  188.     auto ar = res()[0] / res()[1];
  189.  
  190.     auto dis = sqrt(((cx - mx) * ar) * ((cx - mx) * ar) + (cy - my) * (cy - my));
  191.     // 0.1 is the bigger radius of ring
  192.     return dis < 0.1;
  193. }
  194.  
  195. void CameraControl::fakeMouseMoveEvent(QMouseEvent* event)
  196. {
  197.     auto session = Zenovis::GetInstance().getSession();
  198.     auto scene = session->get_scene();
  199.  
  200.     if (event->buttons() & Qt::MiddleButton) {
  201.         float ratio = QApplication::desktop()->devicePixelRatio();
  202.         float xpos = event->x(), ypos = event->y();
  203.         float dx = xpos - m_lastPos.x(), dy = ypos - m_lastPos.y();
  204.         dx *= ratio / m_res[0];
  205.         dy *= ratio / m_res[1];
  206.         bool shift_pressed = event->modifiers() & Qt::ShiftModifier;
  207.         if (shift_pressed)
  208.         {
  209.             float cos_t = cos(m_theta);
  210.             float sin_t = sin(m_theta);
  211.             float cos_p = cos(m_phi);
  212.             float sin_p = sin(m_phi);
  213.             QVector3D back(cos_t * sin_p, sin_t, -cos_t * cos_p);
  214.             QVector3D up(-sin_t * sin_p, cos_t, sin_t * cos_p);
  215.             QVector3D right = QVector3D::crossProduct(up, back);
  216.             up = QVector3D::crossProduct(back, right);
  217.             right.normalize();
  218.             up.normalize();
  219.             QVector3D delta = right * dx + up * dy;
  220.             m_center += delta * m_radius;
  221.         }
  222.         else
  223.         {
  224.             m_theta -= dy * M_PI;
  225.             m_phi += dx * M_PI;
  226.         }
  227.         m_lastPos = QPointF(xpos, ypos);
  228.     }
  229.     else if (event->buttons() & Qt::LeftButton) {
  230.         if (transformer->isTransforming()) {
  231.             bool alt_pressed = event->modifiers() & Qt::AltModifier;
  232.             bool ctrl_pressed = event->modifiers() & Qt::ControlModifier;
  233.             glm::mat4 transform_matrix(1.0f);
  234.  
  235.             auto transform_center = transformer->getCenter();
  236.             QVector3D center_qvec(transform_center[0], transform_center[1], transform_center[2]);
  237.             zeno::vec3f center_zvec(transform_center[0], transform_center[1], transform_center[2]);
  238.  
  239.             std::set<std::unique_ptr<zenovis::IGraphicDraw>> interactingGraphics;
  240.             QVector3D x_axis(1, 0, 0);
  241.             QVector3D y_axis(0, 1, 0);
  242.             QVector3D z_axis(0, 0, 1);
  243.  
  244.             QVariant start, end;
  245.             QVector3D start_vec, end_vec;
  246.             // get transform matrix
  247.             if (ctrl_pressed && alt_pressed) {
  248.                 // rotate
  249.                 if (m_pressedKeys.contains(Qt::Key_Z)) {
  250.                     // rotate along x=center_qvec.x plane
  251.                     start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  252.                                        x_axis, center_qvec);
  253.                     end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  254.                                      x_axis, center_qvec);
  255.                     if (start.isValid() && end.isValid()) {
  256.                         start_vec = start.value<QVector3D>() - center_qvec;
  257.                         end_vec = end.value<QVector3D>() - center_qvec;
  258.                         transformer->rotate(start_vec, end_vec, x_axis);
  259.                         interactingGraphics.insert(
  260.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {1, 0, 0}));
  261.                     }
  262.                 }
  263.                 else if (m_pressedKeys.contains(Qt::Key_X)) {
  264.                     // rotate along y=center_qvec.y plane
  265.                     start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  266.                                        y_axis, center_qvec);
  267.                     end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  268.                                      y_axis, center_qvec);
  269.                     if (start.isValid() && end.isValid()) {
  270.                         start_vec = start.value<QVector3D>() - center_qvec;
  271.                         end_vec = end.value<QVector3D>() - center_qvec;
  272.                         transformer->rotate(start_vec, end_vec, y_axis);
  273.                         interactingGraphics.insert(
  274.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {0, 1, 0}));
  275.                     }
  276.                 }
  277.                 else if (m_pressedKeys.contains(Qt::Key_C)) {
  278.                     // rotate along z=center_qvec.z plane
  279.                     start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  280.                                        z_axis, center_qvec);
  281.                     end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  282.                                      z_axis, center_qvec);
  283.                     if (start.isValid() && end.isValid()) {
  284.                         start_vec = start.value<QVector3D>() - center_qvec;
  285.                         end_vec = end.value<QVector3D>() - center_qvec;
  286.                         transformer->rotate(start_vec, end_vec, z_axis);
  287.                         interactingGraphics.insert(
  288.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {0, 0, 1}));
  289.                     }
  290.                 }
  291.             }
  292.             else if (alt_pressed) {
  293.                 // scale
  294.                 auto vp = scene->camera->m_proj * scene->camera->m_view;
  295.                 auto screen_center = vp * glm::vec4(transform_center, 1.0f);
  296.                 screen_center /= screen_center[3];
  297.                 QVector2D screen_center_2d(screen_center[0], screen_center[1]);
  298.                 QVector2D mouse_pos = qtCoordToGLCoord(event->x(), event->y());
  299.                 float scale_size = mouse_pos.distanceToPoint(screen_center_2d);
  300.  
  301.                 if (m_pressedKeys.contains(Qt::Key_A)) {
  302.                     // scale along a plane
  303.                     if (m_pressedKeys.contains(Qt::Key_Z)) {
  304.                         // scale along x=center_qvec.x plane
  305.                         auto cur = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  306.                                               y_axis, center_qvec);
  307.                         if (cur.isValid()) {
  308.                             transformer->scale(cur.value<QVector3D>() - center_qvec,{0, 1, 1}, scale_size);
  309.                         }
  310.                         interactingGraphics.insert(
  311.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec,{0, 1, 1}));
  312.                     }
  313.                     else if (m_pressedKeys.contains(Qt::Key_X)) {
  314.                         // scale along y=center_qvec.y plane
  315.                         auto cur = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  316.                                               y_axis, center_qvec);
  317.                         if (cur.isValid()) {
  318.                             transformer->scale(cur.value<QVector3D>() - center_qvec,{1, 0, 1}, scale_size);
  319.                         }
  320.                         interactingGraphics.insert(
  321.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {1, 0, 1}));
  322.                     }
  323.                     else if (m_pressedKeys.contains(Qt::Key_C)) {
  324.                         // scale along z=center_qvec.z plane
  325.                         auto cur = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  326.                                               z_axis, center_qvec);
  327.                         if (cur.isValid()) {
  328.                             transformer->scale(cur.value<QVector3D>() - center_qvec,{1, 1, 0}, scale_size);
  329.                         }
  330.                         interactingGraphics.insert(
  331.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {1, 1, 0}));
  332.                     }
  333.                 }
  334.                 else {
  335.                     // scale along an axis
  336.                     if (m_pressedKeys.contains(Qt::Key_Z)) {
  337.                         // scale along x axis
  338.                         auto cur = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  339.                                               y_axis, center_qvec);
  340.                         if (cur.isValid()) {
  341.                             transformer->scale(cur.value<QVector3D>() - center_qvec,{1, 0, 0}, scale_size);
  342.                         }
  343.                         interactingGraphics.insert(
  344.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {1, 0, 0}));
  345.                     }
  346.                     else if (m_pressedKeys.contains(Qt::Key_X)) {
  347.                         // scale along y=center_qvec.y plane
  348.                         auto cur = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  349.                                               y_axis, center_qvec);
  350.                         if (cur.isValid()) {
  351.                             transformer->scale(cur.value<QVector3D>() - center_qvec,{0, 1, 0}, scale_size);
  352.                         }
  353.                         interactingGraphics.insert(
  354.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {0, 1, 0}));
  355.                     }
  356.                     else if (m_pressedKeys.contains(Qt::Key_C)) {
  357.                         auto cur = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  358.                                               z_axis, center_qvec);
  359.                         if (cur.isValid()) {
  360.                             transformer->scale(cur.value<QVector3D>() - center_qvec,{0, 0, 1}, scale_size);
  361.                         }
  362.                         interactingGraphics.insert(
  363.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {0, 0, 1}));
  364.                     }
  365.                 }
  366.             }
  367.             else if (ctrl_pressed){
  368.                 // translate
  369.                 if (m_pressedKeys.contains(Qt::Key_A)) {
  370.                     // translate along a plane
  371.                     if (m_pressedKeys.contains(Qt::Key_Z)) {
  372.                         // translate along x=center_qvec.x plane
  373.                         start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  374.                                            x_axis, center_qvec);
  375.                         end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  376.                                          x_axis, center_qvec);
  377.                         if (start.isValid() && end.isValid()) {
  378.                             transformer->translate(start.value<QVector3D>(),
  379.                                                    end.value<QVector3D>(), {0, 1, 1});
  380.                         }
  381.                         interactingGraphics.insert(
  382.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec,{0, 1, 1}));
  383.                     }
  384.                     else if (m_pressedKeys.contains(Qt::Key_X)) {
  385.                         // translate along y=center_qvec.y plane
  386.                         start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  387.                                            y_axis, center_qvec);
  388.                         end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  389.                                          y_axis, center_qvec);
  390.                         if (start.isValid() && end.isValid()) {
  391.                             transformer->translate(start.value<QVector3D>(),
  392.                                                    end.value<QVector3D>(), {1, 0, 1});
  393.                         }
  394.                         interactingGraphics.insert(
  395.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {1, 0, 1}));
  396.                     }
  397.                     else if (m_pressedKeys.contains(Qt::Key_C)) {
  398.                         // translate along z=center_qvec.z plane
  399.                         start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  400.                                            z_axis, center_qvec);
  401.                         end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  402.                                          z_axis, center_qvec);
  403.                         if (start.isValid() && end.isValid()) {
  404.                             transformer->translate(start.value<QVector3D>(),
  405.                                                    end.value<QVector3D>(), {1, 1, 0});
  406.                         }
  407.                         interactingGraphics.insert(
  408.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {1, 1, 0}));
  409.                     }
  410.                 }
  411.                 else {
  412.                     // translate along an axis
  413.                     QVector3D translate_axis;
  414.                     if (m_pressedKeys.contains(Qt::Key_Z)) {
  415.                         // translate along x axis
  416.                         start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  417.                                            y_axis, center_qvec);
  418.                         end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  419.                                          y_axis, center_qvec);
  420.                         if (start.isValid() && end.isValid()) {
  421.                             transformer->translate(start.value<QVector3D>(),end.value<QVector3D>(), x_axis);
  422.                         }
  423.                         interactingGraphics.insert(
  424.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {1, 0, 0}));
  425.                     }
  426.                     else if (m_pressedKeys.contains(Qt::Key_X)) {
  427.                         // translate along y=center_qvec.y plane
  428.                         start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  429.                                            z_axis, center_qvec);
  430.                         end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  431.                                          z_axis, center_qvec);
  432.                         if (start.isValid() && end.isValid()) {
  433.                             transformer->translate(start.value<QVector3D>(),end.value<QVector3D>(), y_axis);
  434.                         }
  435.                         interactingGraphics.insert(
  436.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {0, 1, 0}));
  437.                     }
  438.                     else if (m_pressedKeys.contains(Qt::Key_C)) {
  439.                         // translate along z=center_qvec.z plane
  440.                         start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  441.                                            y_axis, center_qvec);
  442.                         end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  443.                                          y_axis, center_qvec);
  444.                         if (start.isValid() && end.isValid()) {
  445.                             transformer->translate(start.value<QVector3D>(),end.value<QVector3D>(), z_axis);
  446.                         }
  447.                         interactingGraphics.insert(
  448.                             zenovis::makeGraphicInteractingAxis(scene, center_zvec, {0, 0, 1}));
  449.                     }
  450.                 }
  451.             }
  452.             else {
  453.                 // free translate (along sight plane)
  454.                 QVector3D camera_front(scene->camera->m_lodfront[0],
  455.                                        scene->camera->m_lodfront[1],
  456.                                        scene->camera->m_lodfront[2]);
  457.                 start = hitOnPlane((float)m_lastMovePos.x() / res().x(), (float)m_lastMovePos.y() / res().y(),
  458.                                    camera_front, center_qvec);
  459.                 end = hitOnPlane((float)event->x() / res().x(), (float)event->y() / res().y(),
  460.                                  camera_front, center_qvec);
  461.                 if (start.isValid() && end.isValid()) {
  462.                     transformer->translate(start.value<QVector3D>(),end.value<QVector3D>(), {1, 1, 1});
  463.                 }
  464.             }
  465.             session->set_interacting_graphics(interactingGraphics);
  466.             m_lastMovePos = event->pos();
  467.             zenoApp->getMainWindow()->updateViewport();
  468.         }
  469.         else {
  470.             float min_x = std::min((float)m_boundRectStartPos.x(), (float)event->x()) / m_res.x();
  471.             float max_x = std::max((float)m_boundRectStartPos.x(), (float)event->x()) / m_res.x();
  472.             float min_y = std::min((float)m_boundRectStartPos.y(), (float)event->y()) / m_res.y();
  473.             float max_y = std::max((float)m_boundRectStartPos.y(), (float)event->y()) / m_res.y();
  474.             scene->select_box = zeno::vec4f(min_x, min_y, max_x, max_y);
  475.         }
  476.     }
  477.     else {
  478.         if (mouseEnteredRing(event->x(), event->y())) {
  479.             Zenovis::GetInstance().getSession()->set_hovered_graphic("ring");
  480.         }
  481.         else {
  482.             Zenovis::GetInstance().getSession()->set_hovered_graphic("");
  483.         }
  484.     }
  485.     updatePerspective();
  486. }
  487.  
  488. void CameraControl::updatePerspective()
  489. {
  490.     float cx = m_center[0], cy = m_center[1], cz = m_center[2];
  491.     Zenovis::GetInstance().updatePerspective(m_res, PerspectiveInfo(cx, cy, cz, m_theta, m_phi, m_radius, m_fov, m_ortho_mode, m_aperture, m_focalPlaneDistance));
  492. }
  493.  
  494. void CameraControl::fakeWheelEvent(QWheelEvent* event)
  495. {
  496.     int dy = event->angleDelta().y();
  497.     float scale = (dy >= 0) ? 0.89 : 1 / 0.89;
  498.     bool shift_pressed = (event->modifiers() & Qt::ShiftModifier) && !(event->modifiers() & Qt::ControlModifier);
  499.     bool aperture_pressed = (event->modifiers() & Qt::ControlModifier) && !(event->modifiers() & Qt::ShiftModifier);
  500.     bool focalPlaneDistance_pressed = (event->modifiers() & Qt::ControlModifier) && (event->modifiers() & Qt::ShiftModifier);
  501.     float delta = dy > 0? 1: -1;
  502.     if (shift_pressed){
  503.         float temp = m_fov / scale;
  504.         m_fov = temp < 170 ? temp : 170;
  505.  
  506.     }
  507.     else if (aperture_pressed) {
  508.         float temp = m_aperture += delta * 0.01;
  509.         m_aperture = temp >= 0 ? temp : 0;  
  510.  
  511.     }
  512.     else if (focalPlaneDistance_pressed) {
  513.         float temp = m_focalPlaneDistance + delta*0.05;
  514.         m_focalPlaneDistance = temp >= 0.05 ? temp : 0.05;
  515.     }
  516.     else {
  517.         m_radius *= scale;
  518.     }
  519.     updatePerspective();
  520.  
  521.     if(zenoApp->getMainWindow()->lightPanel != nullptr){
  522.         zenoApp->getMainWindow()->lightPanel->camApertureEdit->setText(QString::number(m_aperture));
  523.         zenoApp->getMainWindow()->lightPanel->camDisPlaneEdit->setText(QString::number(m_focalPlaneDistance));
  524.     }
  525. }
  526.  
  527. void CameraControl::setKeyFrame()
  528. {
  529.     //todo
  530. }
  531.  
  532. void CameraControl::focus(QVector3D center, float radius)
  533. {
  534.     m_center = center;
  535.     if (m_fov >= 1e-6)
  536.         radius /= (m_fov / 45.0f);
  537.     m_radius = radius;
  538.     updatePerspective();
  539. }
  540.  
  541. QVector3D CameraControl::realPos() const {
  542.     float cos_t = std::cos(m_theta);
  543.     float sin_t = std::sin(m_theta);
  544.     float cos_p = std::cos(m_phi);
  545.     float sin_p = std::sin(m_phi);
  546.     QVector3D back(cos_t * sin_p, sin_t, -cos_t * cos_p);
  547.     return m_center - back * m_radius;
  548. }
  549.  
  550. // x, y from [0, 1]
  551. QVector3D CameraControl::screenToWorldRay(float x, float y) const {
  552.     float cos_t = cos(m_theta);
  553.     float sin_t = sin(m_theta);
  554.     float cos_p = cos(m_phi);
  555.     float sin_p = sin(m_phi);
  556.     QVector3D back(cos_t * sin_p, sin_t, -cos_t * cos_p);
  557.     QVector3D up(-sin_t * sin_p, cos_t, sin_t * cos_p);
  558.     QVector3D right = QVector3D::crossProduct(up, back);
  559.     up = QVector3D::crossProduct(back, right);
  560.     right.normalize();
  561.     up.normalize();
  562.     QMatrix4x4 view;
  563.     view.setToIdentity();
  564.     view.lookAt(realPos(), m_center, up);
  565.     x = (x - 0.5) * 2;
  566.     y = (y - 0.5) * (-2);
  567.     float v = std::tan(m_fov * M_PI / 180.f * 0.5f);
  568.     float aspect = res().x() / res().y();
  569.     auto dir = QVector3D(v * x * aspect, v * y, -1);
  570.     dir = dir.normalized();
  571.     dir = view.inverted().mapVector(dir);
  572.     return dir;
  573. }
  574.  
  575. QVariant CameraControl::hitOnFloor(float x, float y) const {
  576.     auto dir = screenToWorldRay(x, y);
  577.     auto pos = realPos();
  578.     float t = (0 - pos.y()) / dir.y();
  579.     if (t > 0) {
  580.         auto p = pos + dir * t;
  581.         return p;
  582.     } else {
  583.         return {};
  584.     }
  585. }
  586.  
  587. QVariant CameraControl::hitOnPlane(float x, float y, QVector3D n, QVector3D p) const {
  588.     auto dir = screenToWorldRay(x, y);
  589.     auto pos = realPos();
  590.     float t = (n.x()*p.x() + n.y()*p.y() + n.z()*p.z() - n.x()*pos.x() - n.y()*pos.y() - n.z()*pos.z()) /
  591.               (n.x()*dir.x() + n.y()*dir.y() + n.z()*dir.z());
  592.     if (t > 0)
  593.         return pos + dir * t;
  594.     else
  595.         return {};
  596. }
  597.  
  598. void CameraControl::fakeMouseReleaseEvent(QMouseEvent *event) {
  599.     if (event->button() == Qt::LeftButton) {
  600.  
  601.         //if (Zenovis::GetInstance().m_bAddPoint == true) {
  602.         //float x = (float)event->x() / m_res.x();
  603.         //float y = (float)event->y() / m_res.y();
  604.         //auto rdir = screenToWorldRay(x, y);
  605.         //auto pos = realPos();
  606.         //float t = (0 - pos.y()) / rdir.y();
  607.         //auto p = pos + rdir * t;
  608.  
  609.         //float cos_t = std::cos(m_theta);
  610.         //float sin_t = std::sin(m_theta);
  611.         //float cos_p = std::cos(m_phi);
  612.         //float sin_p = std::sin(m_phi);
  613.         //QVector3D back(cos_t * sin_p, sin_t, -cos_t * cos_p);
  614.         //QVector3D up(-sin_t * sin_p, cos_t, sin_t * cos_p);
  615.         //QVector3D right = QVector3D::crossProduct(up, back).normalized();
  616.         //up = QVector3D::crossProduct(right, back).normalized();
  617.         //QVector3D delta = right * x + up * y;
  618.  
  619.         //zeno::log_info("create point at x={} y={}", p[0], p[1]);
  620.  
  621.         createPointNode(QPointF(p[0], p[1]));
  622.  
  623.         //Zenovis::GetInstance().m_bAddPoint = false;
  624.         //}
  625.  
  626.         auto scene = Zenovis::GetInstance().getSession()->get_scene();
  627.  
  628.         if (transformer->isTransforming()) {
  629.             bool moved = false;
  630.             if (m_boundRectStartPos != event->pos()) {
  631.                 // create/modify transform primitive node
  632.                 moved = true;
  633.             }
  634.             transformer->endTransform(moved);
  635.         }
  636.         else {
  637.             auto cam_pos = realPos();
  638.  
  639.             scene->select_box = std::nullopt;
  640.             bool shift_pressed = event->modifiers() & Qt::ShiftModifier;
  641.             if (!shift_pressed) {
  642.                 scene->selected.clear();
  643.                 transformer->clear();
  644.             }
  645.  
  646.             QPoint releasePos = event->pos();
  647.             if (m_boundRectStartPos == releasePos) {
  648.                 float x = (float)event->x() / m_res.x();
  649.                 float y = (float)event->y() / m_res.y();
  650.                 auto rdir = screenToWorldRay(x, y);
  651.                 float min_t = std::numeric_limits<float>::max();
  652.                 std::string name("");
  653.                 for (auto const &[key, ptr] : scene->objectsMan->pairs()) {
  654.                     zeno::vec3f center;
  655.                     float radius;
  656.                     zeno::vec3f ro(cam_pos[0], cam_pos[1], cam_pos[2]);
  657.                     zeno::vec3f rd(rdir[0], rdir[1], rdir[2]);
  658. //                    if (zeno::objectGetFocusCenterRadius(ptr, center, radius)) {
  659. //                        if (auto ret = ray_sphere_intersect(ro, rd, center, radius)) {
  660. //                            float t = *ret;
  661. //                            if (t < min_t) {
  662. //                                min_t = t;
  663. //                                name = key;
  664. //                            }
  665. //                        }
  666. //                    }
  667.  
  668.                     zeno::vec3f bmin,bmax;
  669.                     if (zeno::objectGetBoundingBox(ptr,bmin,bmax) ){
  670.                         if (auto ret = ray_box_intersect(bmin, bmax, ro, rd)) {
  671.                             float t = *ret;
  672.                             if (t < min_t) {
  673.                                 min_t = t;
  674.                                 name = key;
  675.                             }
  676.                         }
  677.                     }
  678.                 }
  679.                 if (!name.empty()) {
  680.                     if (scene->selected.count(name) > 0) {
  681.                         scene->selected.erase(name);
  682.                         transformer->removeObject(name);
  683.                     } else {
  684.                         scene->selected.insert(name);
  685.                         transformer->addObject(name);
  686.                         // printf("selected %s\n", name.c_str());
  687.                     }
  688.                 }
  689.             } else {
  690.                 float min_x = std::min((float)m_boundRectStartPos.x(), (float)releasePos.x());
  691.                 float max_x = std::max((float)m_boundRectStartPos.x(), (float)releasePos.x());
  692.                 float min_y = std::min((float)m_boundRectStartPos.y(), (float)releasePos.y());
  693.                 float max_y = std::max((float)m_boundRectStartPos.y(), (float)releasePos.y());
  694.                 auto left_up = screenToWorldRay(min_x / m_res.x(), min_y / m_res.y());
  695.                 auto left_down = screenToWorldRay(min_x / m_res.x(), max_y / m_res.y());
  696.                 auto right_up = screenToWorldRay(max_x / m_res.x(), min_y / m_res.y());
  697.                 auto right_down = screenToWorldRay(max_x / m_res.x(), max_y / m_res.y());
  698.                 auto cam_posWS = realPos();
  699.                 auto left_normWS = QVector3D::crossProduct(left_down, left_up);
  700.                 auto right_normWS = QVector3D::crossProduct(right_up, right_down);
  701.                 auto up_normWS = QVector3D::crossProduct(left_up, right_up);
  702.                 auto down_normWS = QVector3D::crossProduct(right_down, left_down);
  703.  
  704.                 std::vector<std::string> passed_prim;
  705.                 for (auto const &[key, ptr] : scene->objectsMan->pairs()) {
  706.                     zeno::vec3f c;
  707.                     float radius;
  708.                     if (zeno::objectGetFocusCenterRadius(ptr, c, radius)) {
  709.                         bool passed = test_in_selected_bounding(QVector3D(c[0], c[1], c[2]), cam_pos, left_normWS,
  710.                                                                 right_normWS, up_normWS, down_normWS);
  711.                         if (passed) {
  712.                             passed_prim.push_back(key);
  713.                             transformer->addObject(key);
  714.                         }
  715.                     }
  716.                 }
  717.                 scene->selected.insert(passed_prim.begin(), passed_prim.end());
  718.  
  719.             }
  720.         }
  721.  
  722.         if (!scene->selected.empty()) {
  723.             auto center = transformer->getCenter();
  724.             zeno::vec3f ring_center(center[0], center[1], center[2]);
  725.             std::map<std::string, std::unique_ptr<zenovis::IGraphicInteractDraw>> interactGraphics;
  726.             interactGraphics["ring"] = zenovis::makeGraphicRing(scene, ring_center);
  727.             interactGraphics["axis"] = zenovis::makeGraphicInteractAxis(scene, ring_center);
  728.             Zenovis::GetInstance().getSession()->set_interactive_graphics(interactGraphics);
  729.  
  730.             zenoApp->getMainWindow()->updateViewport();
  731.         }
  732.  
  733.         ZenoMainWindow* mainWin = zenoApp->getMainWindow();
  734.         mainWin->onPrimitiveSelected(scene->selected);
  735.     }
  736. }
  737.  
  738. void CameraControl::addPressedKey(int key) {
  739.     m_pressedKeys += key;
  740. }
  741.  
  742. void CameraControl::rmvPressedKey(int key) {
  743.     m_pressedKeys -= key;
  744. }
  745.  
  746. //void CameraControl::createPointNode(QPointF pnt) {
  747.     //auto pModel = zenoApp->graphsManagment()->currentModel();
  748. 	//ZASSERT_EXIT(pModel);
  749.     todo luzh: select specific subgraph to add node.
  750.     //const QModelIndex &subgIdx = pModel->index("main");
  751.     //NODE_DATA tmpNodeInfo = NodesMgr::createPointNode(pModel, subgIdx, "CreatePoint", {10, 10}, pnt);        
  752.  
  753.     //STATUS_UPDATE_INFO info;
  754.     //info.role = ROLE_OPTIONS;
  755.     //info.newValue = OPT_VIEW;
  756.     //pModel->updateNodeStatus(tmpNodeInfo[ROLE_OBJID].toString(), info, subgIdx, true);
  757. //}
  758.  
  759. ViewportWidget::ViewportWidget(QWidget* parent)
  760.     : QOpenGLWidget(parent)
  761.     , m_camera(nullptr)
  762.     , updateLightOnce(true)
  763. {
  764.     QSurfaceFormat fmt;
  765.     int nsamples = 16;  // TODO: adjust in a zhouhang-panel
  766.     fmt.setSamples(nsamples);
  767.     fmt.setVersion(3, 2);
  768.     fmt.setProfile(QSurfaceFormat::CoreProfile);
  769.     setFormat(fmt);
  770.  
  771.     m_camera = std::make_shared<CameraControl>();
  772.     Zenovis::GetInstance().m_camera_control = m_camera.get();
  773. }
  774.  
  775. ViewportWidget::~ViewportWidget()
  776. {
  777. }
  778.  
  779. namespace {
  780. struct OpenGLProcAddressHelper {
  781.     inline static QOpenGLContext *ctx;
  782.  
  783.     static void *getProcAddress(const char *name) {
  784.         return (void *)ctx->getProcAddress(name);
  785.     }
  786. };
  787. }
  788.  
  789. void ViewportWidget::initializeGL()
  790. {
  791.     OpenGLProcAddressHelper::ctx = context();
  792.     Zenovis::GetInstance().loadGLAPI((void *)OpenGLProcAddressHelper::getProcAddress);
  793.     Zenovis::GetInstance().initializeGL();
  794. }
  795.  
  796. void ViewportWidget::resizeGL(int nx, int ny)
  797. {
  798.     float ratio = devicePixelRatioF();
  799.     zeno::log_trace("nx={}, ny={}, dpr={}", nx, ny, ratio);
  800.     m_camera->setRes(QVector2D(nx * ratio, ny * ratio));
  801.     m_camera->updatePerspective();
  802. }
  803.  
  804. QVector2D ViewportWidget::cameraRes() const
  805. {
  806.     return m_camera->res();
  807. }
  808.  
  809. void ViewportWidget::setCameraRes(const QVector2D& res)
  810. {
  811.     m_camera->setRes(res);
  812. }
  813.  
  814. void ViewportWidget::updatePerspective()
  815. {
  816.     m_camera->updatePerspective();
  817. }
  818.  
  819. void ViewportWidget::paintGL()
  820. {
  821.     Zenovis::GetInstance().paintGL();
  822.     if(updateLightOnce){
  823.         auto scene = Zenovis::GetInstance().getSession()->get_scene();
  824.  
  825.         if(scene->objectsMan->lightObjects.size() > 0){
  826.             zenoApp->getMainWindow()->updateLightList();
  827.             updateLightOnce = false;
  828.         }
  829.     }
  830.  
  831.     if (!record_path.empty() /*&& f <= frame_end*/) //py has bug: frame_end not initialized.
  832.     {
  833.         int f = Zenovis::GetInstance().getCurrentFrameId();
  834.         auto record_file = zeno::format("{}/{:06d}.png", record_path, f);
  835.         checkRecord(record_file, record_res);
  836.     }
  837. }
  838.  
  839. void ViewportWidget::checkRecord(std::string a_record_file, QVector2D a_record_res)
  840. {
  841.     if (!record_path.empty() /*&& f <= frame_end*/) //py has bug: frame_end not initialized.
  842.     {
  843.         QVector2D oldRes = m_camera->res();
  844.         m_camera->setRes(a_record_res);
  845.         m_camera->updatePerspective();
  846.         auto extname = QFileInfo(QString::fromStdString(a_record_file)).suffix().toStdString();
  847.         Zenovis::GetInstance().getSession()->do_screenshot(a_record_file, extname);
  848.         m_camera->setRes(oldRes);
  849.         m_camera->updatePerspective();
  850.         //if f == self.frame_end:
  851.         //    self.parent_widget.record_video.finish_record()
  852.     }
  853. }
  854.  
  855. void ViewportWidget::mousePressEvent(QMouseEvent* event)
  856. {
  857.     _base::mousePressEvent(event);
  858.     m_camera->fakeMousePressEvent(event);
  859.     update();
  860. }
  861.  
  862. void ViewportWidget::mouseMoveEvent(QMouseEvent* event)
  863. {
  864.     _base::mouseMoveEvent(event);
  865.     m_camera->fakeMouseMoveEvent(event);
  866.     update();
  867. }
  868.  
  869. void ViewportWidget::wheelEvent(QWheelEvent* event)
  870. {
  871.     _base::wheelEvent(event);
  872.     m_camera->fakeWheelEvent(event);
  873.     update();
  874. }
  875.  
  876. void ViewportWidget::mouseReleaseEvent(QMouseEvent *event) {    
  877.     _base::mouseReleaseEvent(event);
  878.     m_camera->fakeMouseReleaseEvent(event); 
  879.     update();
  880. }
  881.  
  882. void ViewportWidget::addPressedKey(int key) {
  883.     m_camera->addPressedKey(key);
  884. }
  885.  
  886. void ViewportWidget::rmvPressedKey(int key) {
  887.     m_camera->rmvPressedKey(key);
  888. }
  889.  
  890. void ViewportWidget::updateCameraProp(float aperture, float disPlane) {
  891.     m_camera->setAperture(aperture);
  892.     m_camera->setDisPlane(disPlane);
  893.     updatePerspective();
  894. }
  895.  
  896. /*
  897. QDMDisplayMenu::QDMDisplayMenu()r("Show Grid")
  898. {
  899.     setTitle(tr("Display"));
  900.     QAction* pAction = new QAction(tr("Show Grid"), this);
  901.     pAction->setCheckable(true);
  902.     pAction->setChecked(true);
  903.     addAction(pAction);
  905.     pAction = new QAction(tr("Background Color"), this);
  906.     addAction(pAction);
  908.     addSeparator();
  910.     pAction = new QAction(tr("Smooth Shading"), this);
  911.     pAction->setCheckable(true);
  912.     pAction->setChecked(false);
  913.     addAction(pAction);
  915.     pAction = new QAction(tr("Wireframe"), this);
  916.     pAction->setCheckable(true);
  917.     pAction->setChecked(false);
  919.     addSeparator();
  921.     pAction = new QAction(tr("Enable PBR"), this);
  922.     pAction->setCheckable(true);
  923.     pAction->setChecked(false);
  924.     addAction(pAction);
  926.     pAction = new QAction(tr("Enable GI"), this);
  927.     pAction->setCheckable(true);
  928.     pAction->setChecked(false);
  929.     addAction(pAction);
  931.     addSeparator();
  933.     pAction = new QAction(tr("Camera Keyframe"), this);
  934.     addAction(pAction);
  936.     addSeparator();
  938.     pAction = new QAction(tr("English / Chinese"), this);
  939.     pAction->setCheckable(true);
  940.     pAction->setChecked(true);
  941.     addAction(pAction);
  942. }
  944. QDMRecordMenu::QDMRecordMenu()
  945. {
  946.     setTitle(tr("Record"));
  948.     QAction* pAction = new QAction(tr("Screenshot"), this);
  949.     pAction->setShortcut(QKeySequence("F12"));
  950.     addAction(pAction);
  952.     pAction = new QAction(tr("Record Video"), this);
  953.     pAction->setShortcut(QKeySequence(tr("Shift+F12")));
  954.     addAction(pAction);
  955. }
  956. */
  957.  
  958.  
  959. DisplayWidget::DisplayWidget(ZenoMainWindow* pMainWin)
  960.     : QWidget(pMainWin)
  961.     , m_view(nullptr)
  962.     , m_timeline(nullptr)
  963.     , m_mainWin(pMainWin)
  964.     , m_pTimer(nullptr)
  965. {
  966.     QVBoxLayout* pLayout = new QVBoxLayout;
  967.     pLayout->setContentsMargins(0, 0, 0, 0);
  968.     pLayout->setSpacing(0);
  969.  
  970.     setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
  971.  
  972.     /*
  973.     ZMenuBar* menuBar = new ZMenuBar;
  974.     menuBar->setMaximumHeight(26);
  976.     QDMDisplayMenu* menuDisplay = new QDMDisplayMenu;
  977.     menuBar->addMenu(menuDisplay);
  978.     QDMRecordMenu* recordDisplay = new QDMRecordMenu;
  979.     menuBar->addMenu(recordDisplay);
  981.     pLayout->addWidget(menuBar);
  982.     */
  983.  
  984.     m_view = new ViewportWidget;
  985.     // viewport interaction need to set mouse tracking true
  986.     // but it will lead to a light panel edit bug
  987.     // m_view->setMouseTracking(true);
  988.     pLayout->addWidget(m_view);
  989.  
  990.     m_timeline = new ZTimeline;
  991.     pLayout->addWidget(m_timeline);
  992.     setLayout(pLayout);
  993.  
  994.     //RecordVideoDialog
  995.     m_camera_keyframe = new CameraKeyframeWidget;
  996.     Zenovis::GetInstance().m_camera_keyframe = m_camera_keyframe;
  997.  
  998. 	connect(&Zenovis::GetInstance(), SIGNAL(frameUpdated(int)), m_timeline, SLOT(onTimelineUpdate(int)));
  999.     connect(m_timeline, SIGNAL(playForward(bool)), this, SLOT(onPlayClicked(bool)));
  1000. 	connect(m_timeline, SIGNAL(sliderValueChanged(int)), this, SLOT(onSliderValueChanged(int)));
  1001. 	connect(m_timeline, SIGNAL(run()), this, SLOT(onRun()));
  1002.     connect(m_timeline, SIGNAL(alwaysChecked()), this, SLOT(onRun()));
  1003.     connect(m_timeline, SIGNAL(kill()), this, SLOT(onKill()));
  1004.  
  1005.     //connect(m_view, SIGNAL(sig_Draw()), this, SLOT(onRun()));
  1006.  
  1007.     auto graphs = zenoApp->graphsManagment();
  1008.     connect(&*graphs, SIGNAL(modelDataChanged()), this, SLOT(onModelDataChanged()));
  1009.  
  1010. 	m_pTimer = new QTimer(this);
  1011.     connect(m_pTimer, SIGNAL(timeout()), this, SLOT(updateFrame()));
  1012. }
  1013.  
  1014. DisplayWidget::~DisplayWidget()
  1015. {
  1016.  
  1017. }
  1018.  
  1019. void DisplayWidget::init()
  1020. {
  1021.     //m_camera->installEventFilter(this);
  1022. }
  1023.  
  1024. TIMELINE_INFO DisplayWidget::timelineInfo()
  1025. {
  1026.     TIMELINE_INFO info;
  1027.     info.bAlways = m_timeline->isAlways();
  1028.     info.beginFrame = m_timeline->fromTo().first;
  1029.     info.endFrame = m_timeline->fromTo().second;
  1030.     return info;
  1031. }
  1032.  
  1033. void DisplayWidget::setTimelineInfo(TIMELINE_INFO info)
  1034. {
  1035.     m_timeline->setAlways(info.bAlways);
  1036.     m_timeline->setFromTo(info.beginFrame, info.endFrame);
  1037. }
  1038.  
  1039. ViewportWidget* DisplayWidget::getViewportWidget()
  1040. {
  1041.     return m_view;
  1042. }
  1043.  
  1044. QSize DisplayWidget::sizeHint() const
  1045. {
  1046.     return ZenoStyle::dpiScaledSize(QSize(12, 400));
  1047. }
  1048.  
  1049. void DisplayWidget::updateFrame(const QString &action) // cihou optix
  1050. {
  1051.     if (m_mainWin && m_mainWin->inDlgEventLoop())
  1052.         return;
  1053.  
  1054.     if (action == "newFrame") {
  1055.         m_pTimer->stop();
  1056.         //zeno::log_warn("stop");
  1057.         return;
  1058.     } else if (action == "finishFrame") {
  1059.         if (isOptxRendering()) {
  1060.             m_pTimer->start(m_updateFeq);
  1061.         }
  1062.     } else if (!action.isEmpty()) {
  1063.         if (action == "optx") {
  1064.             m_pTimer->start(m_updateFeq);
  1065.         } else {
  1066.             m_pTimer->stop();
  1067.         }
  1068.     }
  1069.     m_view->update();
  1070. }
  1071.  
  1072. void DisplayWidget::onFinished()
  1073. {
  1074.     int frameid_ui = m_timeline->value();
  1075.     if (frameid_ui != Zenovis::GetInstance().getCurrentFrameId())
  1076.     {
  1077.         Zenovis::GetInstance().setCurrentFrameId(frameid_ui);
  1078.         updateFrame();
  1079.         onPlayClicked(false);
  1080.         BlockSignalScope scope(m_timeline);
  1081.         m_timeline->setPlayButtonToggle(false);
  1082.     }
  1083. }
  1084.  
  1085. bool DisplayWidget::isOptxRendering() const
  1086. {
  1087.     auto& inst = Zenovis::GetInstance();
  1088.     auto sess = inst.getSession();
  1089.     if (!sess)
  1090.         return false;
  1091.     auto scene = sess->get_scene();
  1092.     if (!scene)
  1093.         return false;
  1094.  
  1095.     return (scene->renderMan && scene->renderMan->getDefaultEngineName() == "optx");
  1096. }
  1097.  
  1098. void DisplayWidget::onModelDataChanged()
  1099. {
  1100.     if (m_timeline->isAlways())
  1101.     {
  1102.         onRun();
  1103.     }
  1104. }
  1105.  
  1106. void DisplayWidget::onPlayClicked(bool bChecked)
  1107. {
  1108.     if (bChecked)
  1109.     {
  1110.         m_pTimer->start(m_sliderFeq);
  1111.     }
  1112.     else
  1113.     {
  1114.         if (!isOptxRendering())
  1115.             m_pTimer->stop();
  1116.     }
  1117.     Zenovis::GetInstance().startPlay(bChecked);
  1118. }
  1119.  
  1120. void DisplayWidget::onSliderValueChanged(int frame)
  1121. {
  1122.     m_mainWin->clearErrorMark();
  1123.  
  1124.     if (m_timeline->isAlways())
  1125.     {
  1126.         auto pGraphsMgr = zenoApp->graphsManagment();
  1127.         IGraphsModel* pModel = pGraphsMgr->currentModel();
  1128.         if (!pModel)
  1129.             return;
  1130.         launchProgram(pModel, frame, frame);
  1131.     }
  1132.     else
  1133.     {
  1134.         Zenovis::GetInstance().setCurrentFrameId(frame);
  1135.         updateFrame();
  1136.         onPlayClicked(false);
  1137.         BlockSignalScope scope(m_timeline);
  1138.         m_timeline->setPlayButtonToggle(false);
  1139.     }
  1140. }
  1141.  
  1142. void DisplayWidget::onRun()
  1143. {
  1144.     m_mainWin->clearErrorMark();
  1145.  
  1146.     Zenovis::GetInstance().getSession()->get_scene()->selected.clear();
  1147.  
  1148.     QPair<int, int> fromTo = m_timeline->fromTo();
  1149.     int beginFrame = fromTo.first;
  1150.     int endFrame = fromTo.second;
  1151.     if (endFrame >= beginFrame && beginFrame >= 0)
  1152.     {
  1153.         auto pGraphsMgr = zenoApp->graphsManagment();
  1154.         IGraphsModel* pModel = pGraphsMgr->currentModel();
  1155.         if (!pModel)
  1156.             return;
  1157.         launchProgram(pModel, beginFrame, endFrame);
  1158.     }
  1159.     else
  1160.     {
  1161.  
  1162.     }
  1163.  
  1164.     m_view->updateLightOnce = true;
  1165.     auto scene = Zenovis::GetInstance().getSession()->get_scene();
  1166.     scene->objectsMan->lightObjects.clear();
  1167. }
  1168.  
  1169. void DisplayWidget::keyPressEvent(QKeyEvent* event) {
  1170.     if (!event->isAutoRepeat())
  1171.         m_view->addPressedKey(event->key());
  1172. }
  1173.  
  1174. void DisplayWidget::keyReleaseEvent(QKeyEvent* event) {
  1175.     if (!event->isAutoRepeat())
  1176.         m_view->rmvPressedKey(event->key());
  1177. }
  1178.  
  1179.  
  1180. void DisplayWidget::onRecord()
  1181. {
  1182.     auto& inst = Zenovis::GetInstance();
  1183.  
  1184.     auto& ptr = zeno::getSession().globalComm;
  1185.     ZASSERT_EXIT(ptr);
  1186.  
  1187.     if (ptr->maxPlayFrames() == 0) {
  1188.         //run.
  1189.         QMessageBox::information(nullptr, "Zeno", tr("Run the graph before recording"), QMessageBox::Ok);
  1190.         return;
  1191.     }
  1192.  
  1193.     int frameLeft = ptr->beginFrameNumber;
  1194.     int frameRight = ptr->endFrameNumber;
  1195.  
  1196.     ZRecordVideoDlg dlg(frameLeft, frameRight, this);
  1197.     if (QDialog::Accepted == dlg.exec())
  1198.     {
  1199.         int frameStart = 0, frameEnd = 0, fps = 0, bitrate = 0, width = 0, height = 0;
  1200.         QString presets, path, filename;
  1201.         dlg.getInfo(frameStart, frameEnd, fps, bitrate, presets, width, height, path, filename);
  1202.         //validation.
  1203.  
  1204.         VideoRecInfo recInfo;
  1205.         recInfo.record_path = path;
  1206.         recInfo.frameRange = { frameStart, frameEnd };
  1207.         recInfo.res = { (float)width, (float)height };
  1208.         recInfo.bitrate = bitrate;
  1209.         recInfo.fps = fps;
  1210.         recInfo.videoname = filename;
  1211.  
  1212.         Zenovis::GetInstance().startPlay(true);
  1213.  
  1214.         RecordVideoMgr recordMgr(m_view, recInfo, nullptr);
  1215.         ZRecordProgressDlg dlgProc(recInfo);
  1216.         connect(&recordMgr, SIGNAL(frameFinished(int)), &dlgProc, SLOT(onFrameFinished(int)));
  1217.         connect(&recordMgr, SIGNAL(recordFinished()), &dlgProc, SLOT(onRecordFinished()));
  1218.         connect(&recordMgr, SIGNAL(recordFailed(QString)), &dlgProc, SLOT(onRecordFailed(QString)));
  1219.         if (QDialog::Accepted == dlgProc.exec())
  1220.         {
  1221.         }
  1222.         else
  1223.         {
  1224.             recordMgr.cancelRecord();
  1225.         }
  1226.     }
  1227. }
  1228.  
  1229. void DisplayWidget::onKill()
  1230. {
  1231.     killProgram();
  1232. }

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/520616
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号