window-basic-preview.cpp 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718
  1. #include <QGuiApplication>
  2. #include <QMouseEvent>
  3. #include <cmath>
  4. #include <graphics/vec4.h>
  5. #include <graphics/matrix4.h>
  6. #include "window-basic-preview.hpp"
  7. #include "window-basic-main.hpp"
  8. #include "obs-app.hpp"
  9. #define HANDLE_RADIUS 4.0f
  10. #define HANDLE_SEL_RADIUS (HANDLE_RADIUS * 1.5f)
  11. #define CLAMP_DISTANCE 10.0f
  12. /* TODO: make C++ math classes and clean up code here later */
  13. OBSBasicPreview::OBSBasicPreview(QWidget *parent, Qt::WindowFlags flags)
  14. : OBSQTDisplay(parent, flags)
  15. {
  16. setMouseTracking(true);
  17. }
  18. vec2 OBSBasicPreview::GetMouseEventPos(QMouseEvent *event)
  19. {
  20. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  21. vec2 pos = {
  22. (float(event->x()) - main->previewX) / main->previewScale,
  23. (float(event->y()) - main->previewY) / main->previewScale
  24. };
  25. return pos;
  26. }
  27. struct SceneFindData {
  28. const vec2 &pos;
  29. OBSSceneItem item;
  30. bool selectBelow;
  31. inline SceneFindData(const vec2 &pos_, bool selectBelow_)
  32. : pos (pos_),
  33. selectBelow (selectBelow_)
  34. {}
  35. };
  36. static bool FindItemAtPos(obs_scene_t scene, obs_sceneitem_t item, void *param)
  37. {
  38. SceneFindData *data = reinterpret_cast<SceneFindData*>(param);
  39. matrix4 transform;
  40. vec3 transformedPos;
  41. vec3 pos3 = {data->pos.x, data->pos.y, 0.0f};
  42. obs_sceneitem_get_box_transform(item, &transform);
  43. matrix4_inv(&transform, &transform);
  44. vec3_transform(&transformedPos, &pos3, &transform);
  45. if (transformedPos.x >= 0.0f && transformedPos.x <= 1.0f &&
  46. transformedPos.y >= 0.0f && transformedPos.y <= 1.0f) {
  47. if (data->selectBelow && obs_sceneitem_selected(item)) {
  48. if (data->item)
  49. return false;
  50. else
  51. data->selectBelow = false;
  52. }
  53. data->item = item;
  54. }
  55. UNUSED_PARAMETER(scene);
  56. return true;
  57. }
  58. static vec3 GetTransformedPos(float x, float y, const matrix4 &mat)
  59. {
  60. vec3 result;
  61. vec3_set(&result, x, y, 0.0f);
  62. vec3_transform(&result, &result, &mat);
  63. return result;
  64. }
  65. static vec3 GetTransformedPosScaled(float x, float y, const matrix4 &mat,
  66. float scale)
  67. {
  68. vec3 result;
  69. vec3_set(&result, x, y, 0.0f);
  70. vec3_transform(&result, &result, &mat);
  71. vec3_mulf(&result, &result, scale);
  72. return result;
  73. }
  74. static inline vec2 GetOBSScreenSize()
  75. {
  76. obs_video_info ovi;
  77. vec2 size = {0.0f, 0.0f};
  78. if (obs_get_video_info(&ovi)) {
  79. size.x = float(ovi.base_width);
  80. size.y = float(ovi.base_height);
  81. }
  82. return size;
  83. }
  84. vec3 OBSBasicPreview::GetScreenSnapOffset(const vec3 &tl, const vec3 &br)
  85. {
  86. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  87. vec2 screenSize = GetOBSScreenSize();
  88. vec3 clampOffset;
  89. vec3_zero(&clampOffset);
  90. const float clampDist = CLAMP_DISTANCE / main->previewScale;
  91. if (fabsf(tl.x) < clampDist)
  92. clampOffset.x = -tl.x;
  93. if (fabsf(clampOffset.x) < EPSILON &&
  94. fabsf(screenSize.x - br.x) < clampDist)
  95. clampOffset.x = screenSize.x - br.x;
  96. if (fabsf(tl.y) < clampDist)
  97. clampOffset.y = -tl.y;
  98. if (fabsf(clampOffset.y) < EPSILON &&
  99. fabsf(screenSize.y - br.y) < clampDist)
  100. clampOffset.y = screenSize.y - br.y;
  101. return clampOffset;
  102. }
  103. OBSSceneItem OBSBasicPreview::GetItemAtPos(const vec2 &pos, bool selectBelow)
  104. {
  105. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  106. OBSScene scene = main->GetCurrentScene();
  107. if (!scene)
  108. return OBSSceneItem();
  109. SceneFindData data(pos, selectBelow);
  110. obs_scene_enum_items(scene, FindItemAtPos, &data);
  111. return data.item;
  112. }
  113. static bool CheckItemSelected(obs_scene_t scene, obs_sceneitem_t item,
  114. void *param)
  115. {
  116. SceneFindData *data = reinterpret_cast<SceneFindData*>(param);
  117. matrix4 transform;
  118. vec3 transformedPos;
  119. vec3 pos3 = {data->pos.x, data->pos.y, 0.0f};
  120. obs_sceneitem_get_box_transform(item, &transform);
  121. matrix4_inv(&transform, &transform);
  122. vec3_transform(&transformedPos, &pos3, &transform);
  123. if (transformedPos.x >= 0.0f && transformedPos.x <= 1.0f &&
  124. transformedPos.y >= 0.0f && transformedPos.y <= 1.0f) {
  125. if (obs_sceneitem_selected(item)) {
  126. data->item = item;
  127. return false;
  128. }
  129. }
  130. UNUSED_PARAMETER(scene);
  131. return true;
  132. }
  133. bool OBSBasicPreview::SelectedAtPos(const vec2 &pos)
  134. {
  135. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  136. OBSScene scene = main->GetCurrentScene();
  137. if (!scene)
  138. return false;
  139. SceneFindData data(pos, false);
  140. obs_scene_enum_items(scene, CheckItemSelected, &data);
  141. return !!data.item;
  142. }
  143. struct HandleFindData {
  144. const vec2 &pos;
  145. const float scale;
  146. OBSSceneItem item;
  147. ItemHandle handle = ItemHandle::None;
  148. inline HandleFindData(const vec2 &pos_, float scale_)
  149. : pos (pos_),
  150. scale (scale_)
  151. {}
  152. };
  153. static bool FindHandleAtPos(obs_scene_t scene, obs_sceneitem_t item,
  154. void *param)
  155. {
  156. if (!obs_sceneitem_selected(item))
  157. return true;
  158. HandleFindData *data = reinterpret_cast<HandleFindData*>(param);
  159. matrix4 transform;
  160. vec3 pos3 = {data->pos.x, data->pos.y, 0.0f};
  161. float closestHandle = HANDLE_SEL_RADIUS;
  162. obs_sceneitem_get_box_transform(item, &transform);
  163. auto TestHandle = [&] (float x, float y, ItemHandle handle)
  164. {
  165. vec3 handlePos = GetTransformedPosScaled(x, y, transform,
  166. data->scale);
  167. float dist = vec3_dist(&handlePos, &pos3);
  168. if (dist < HANDLE_SEL_RADIUS) {
  169. if (dist < closestHandle) {
  170. closestHandle = dist;
  171. data->handle = handle;
  172. data->item = item;
  173. }
  174. }
  175. };
  176. TestHandle(0.0f, 0.0f, ItemHandle::TopLeft);
  177. TestHandle(0.5f, 0.0f, ItemHandle::TopCenter);
  178. TestHandle(1.0f, 0.0f, ItemHandle::TopRight);
  179. TestHandle(0.0f, 0.5f, ItemHandle::CenterLeft);
  180. TestHandle(1.0f, 0.5f, ItemHandle::CenterRight);
  181. TestHandle(0.0f, 1.0f, ItemHandle::BottomLeft);
  182. TestHandle(0.5f, 1.0f, ItemHandle::BottomCenter);
  183. TestHandle(1.0f, 1.0f, ItemHandle::BottomRight);
  184. UNUSED_PARAMETER(scene);
  185. return true;
  186. }
  187. static vec2 GetItemSize(obs_sceneitem_t item)
  188. {
  189. obs_bounds_type boundsType = obs_sceneitem_get_bounds_type(item);
  190. vec2 size;
  191. if (boundsType != OBS_BOUNDS_NONE) {
  192. obs_sceneitem_get_bounds(item, &size);
  193. } else {
  194. obs_source_t source = obs_sceneitem_getsource(item);
  195. vec2 scale;
  196. obs_sceneitem_getscale(item, &scale);
  197. size.x = float(obs_source_getwidth(source)) * scale.x;
  198. size.y = float(obs_source_getheight(source)) * scale.y;
  199. }
  200. return size;
  201. }
  202. void OBSBasicPreview::GetStretchHandleData(const vec2 &pos)
  203. {
  204. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  205. OBSScene scene = main->GetCurrentScene();
  206. if (!scene)
  207. return;
  208. HandleFindData data(pos, main->previewScale);
  209. obs_scene_enum_items(scene, FindHandleAtPos, &data);
  210. stretchItem = std::move(data.item);
  211. stretchHandle = data.handle;
  212. if (stretchHandle != ItemHandle::None) {
  213. matrix4 boxTransform;
  214. vec3 itemUL;
  215. float itemRot;
  216. stretchItemSize = GetItemSize(stretchItem);
  217. obs_sceneitem_get_box_transform(stretchItem, &boxTransform);
  218. itemRot = obs_sceneitem_getrot(stretchItem);
  219. vec3_from_vec4(&itemUL, &boxTransform.t);
  220. /* build the item space conversion matrices */
  221. matrix4_identity(&itemToScreen);
  222. matrix4_rotate_aa4f(&itemToScreen, &itemToScreen,
  223. 0.0f, 0.0f, 1.0f, RAD(itemRot));
  224. matrix4_translate3f(&itemToScreen, &itemToScreen,
  225. itemUL.x, itemUL.y, 0.0f);
  226. matrix4_identity(&screenToItem);
  227. matrix4_translate3f(&screenToItem, &screenToItem,
  228. -itemUL.x, -itemUL.y, 0.0f);
  229. matrix4_rotate_aa4f(&screenToItem, &screenToItem,
  230. 0.0f, 0.0f, 1.0f, RAD(-itemRot));
  231. }
  232. }
  233. void OBSBasicPreview::mousePressEvent(QMouseEvent *event)
  234. {
  235. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  236. float x = float(event->x()) - main->previewX;
  237. float y = float(event->y()) - main->previewY;
  238. if (event->button() != Qt::LeftButton ||
  239. x < 0.0f || y < 0.0f || x > main->previewCX || y > main->previewCY)
  240. return;
  241. mouseDown = true;
  242. vec2_set(&startPos, x, y);
  243. GetStretchHandleData(startPos);
  244. vec2_divf(&startPos, &startPos, main->previewScale);
  245. startPos.x = std::round(startPos.x);
  246. startPos.y = std::round(startPos.y);
  247. mouseOverItems = SelectedAtPos(startPos);
  248. vec2_zero(&lastMoveOffset);
  249. }
  250. static bool select_one(obs_scene_t scene, obs_sceneitem_t item, void *param)
  251. {
  252. obs_sceneitem_t selectedItem = reinterpret_cast<obs_sceneitem_t>(param);
  253. obs_sceneitem_select(item, (selectedItem == item));
  254. UNUSED_PARAMETER(scene);
  255. return true;
  256. }
  257. void OBSBasicPreview::DoSelect(const vec2 &pos)
  258. {
  259. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  260. OBSScene scene = main->GetCurrentScene();
  261. OBSSceneItem item = GetItemAtPos(pos, true);
  262. obs_scene_enum_items(scene, select_one, (obs_sceneitem_t)item);
  263. }
  264. void OBSBasicPreview::DoCtrlSelect(const vec2 &pos)
  265. {
  266. OBSSceneItem item = GetItemAtPos(pos, false);
  267. if (!item)
  268. return;
  269. bool selected = obs_sceneitem_selected(item);
  270. obs_sceneitem_select(item, !selected);
  271. }
  272. void OBSBasicPreview::ProcessClick(const vec2 &pos)
  273. {
  274. Qt::KeyboardModifiers modifiers = QGuiApplication::keyboardModifiers();
  275. if (modifiers & Qt::ControlModifier)
  276. DoCtrlSelect(pos);
  277. else
  278. DoSelect(pos);
  279. }
  280. void OBSBasicPreview::mouseReleaseEvent(QMouseEvent *event)
  281. {
  282. if (mouseDown) {
  283. vec2 pos = GetMouseEventPos(event);
  284. if (!mouseMoved)
  285. ProcessClick(pos);
  286. stretchItem = nullptr;
  287. mouseDown = false;
  288. mouseMoved = false;
  289. }
  290. }
  291. struct SelectedItemBounds {
  292. bool first = true;
  293. vec3 tl, br;
  294. };
  295. static bool AddItemBounds(obs_scene_t scene, obs_sceneitem_t item,
  296. void *param)
  297. {
  298. SelectedItemBounds *data = reinterpret_cast<SelectedItemBounds*>(param);
  299. if (!obs_sceneitem_selected(item))
  300. return true;
  301. matrix4 boxTransform;
  302. obs_sceneitem_get_box_transform(item, &boxTransform);
  303. vec3 t[4] = {
  304. GetTransformedPos(0.0f, 0.0f, boxTransform),
  305. GetTransformedPos(1.0f, 0.0f, boxTransform),
  306. GetTransformedPos(0.0f, 1.0f, boxTransform),
  307. GetTransformedPos(1.0f, 1.0f, boxTransform)
  308. };
  309. for (const vec3 &v : t) {
  310. if (data->first) {
  311. vec3_copy(&data->tl, &v);
  312. vec3_copy(&data->br, &v);
  313. data->first = false;
  314. } else {
  315. vec3_min(&data->tl, &data->tl, &v);
  316. vec3_max(&data->br, &data->br, &v);
  317. }
  318. }
  319. UNUSED_PARAMETER(scene);
  320. return true;
  321. }
  322. void OBSBasicPreview::SnapItemMovement(vec2 &offset)
  323. {
  324. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  325. OBSScene scene = main->GetCurrentScene();
  326. SelectedItemBounds data;
  327. obs_scene_enum_items(scene, AddItemBounds, &data);
  328. data.tl.x += offset.x;
  329. data.tl.y += offset.y;
  330. data.br.x += offset.x;
  331. data.br.y += offset.y;
  332. vec3 snapOffset = GetScreenSnapOffset(data.tl, data.br);
  333. offset.x += snapOffset.x;
  334. offset.y += snapOffset.y;
  335. }
  336. static bool move_items(obs_scene_t scene, obs_sceneitem_t item, void *param)
  337. {
  338. vec2 *offset = reinterpret_cast<vec2*>(param);
  339. if (obs_sceneitem_selected(item)) {
  340. vec2 pos;
  341. obs_sceneitem_getpos(item, &pos);
  342. vec2_add(&pos, &pos, offset);
  343. obs_sceneitem_setpos(item, &pos);
  344. }
  345. UNUSED_PARAMETER(scene);
  346. return true;
  347. }
  348. void OBSBasicPreview::MoveItems(const vec2 &pos)
  349. {
  350. Qt::KeyboardModifiers modifiers = QGuiApplication::keyboardModifiers();
  351. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  352. OBSScene scene = main->GetCurrentScene();
  353. vec2 offset, moveOffset;
  354. vec2_sub(&offset, &pos, &startPos);
  355. vec2_sub(&moveOffset, &offset, &lastMoveOffset);
  356. if (!(modifiers & Qt::ControlModifier))
  357. SnapItemMovement(moveOffset);
  358. vec2_add(&lastMoveOffset, &lastMoveOffset, &moveOffset);
  359. obs_scene_enum_items(scene, move_items, &moveOffset);
  360. }
  361. vec3 OBSBasicPreview::CalculateStretchPos(const vec3 &tl, const vec3 &br)
  362. {
  363. uint32_t alignment = obs_sceneitem_getalignment(stretchItem);
  364. vec3 pos;
  365. vec3_zero(&pos);
  366. if (alignment & OBS_ALIGN_LEFT)
  367. pos.x = tl.x;
  368. else if (alignment & OBS_ALIGN_RIGHT)
  369. pos.x = br.x;
  370. else
  371. pos.x = (br.x - tl.x) * 0.5f + tl.x;
  372. if (alignment & OBS_ALIGN_TOP)
  373. pos.y = tl.y;
  374. else if (alignment & OBS_ALIGN_BOTTOM)
  375. pos.y = br.y;
  376. else
  377. pos.y = (br.y - tl.y) * 0.5f + tl.y;
  378. return pos;
  379. }
  380. void OBSBasicPreview::ClampAspect(vec3 &tl, vec3 &br, vec2 &size,
  381. const vec2 &baseSize)
  382. {
  383. float baseAspect = baseSize.x / baseSize.y;
  384. float aspect = size.x / size.y;
  385. uint32_t stretchFlags = (uint32_t)stretchHandle;
  386. if (stretchHandle == ItemHandle::TopLeft ||
  387. stretchHandle == ItemHandle::TopRight ||
  388. stretchHandle == ItemHandle::BottomLeft ||
  389. stretchHandle == ItemHandle::BottomRight) {
  390. if (aspect < baseAspect)
  391. size.x = size.y * baseAspect;
  392. else
  393. size.y = size.x / baseAspect;
  394. } else if (stretchHandle == ItemHandle::TopCenter ||
  395. stretchHandle == ItemHandle::BottomCenter) {
  396. size.x = size.y * baseAspect;
  397. } else if (stretchHandle == ItemHandle::CenterLeft ||
  398. stretchHandle == ItemHandle::CenterRight) {
  399. size.y = size.x / baseAspect;
  400. }
  401. size.x = std::round(size.x);
  402. size.y = std::round(size.y);
  403. if (stretchFlags & ITEM_LEFT)
  404. tl.x = br.x - size.x;
  405. else if (stretchFlags & ITEM_RIGHT)
  406. br.x = tl.x + size.x;
  407. if (stretchFlags & ITEM_TOP)
  408. tl.y = br.y - size.y;
  409. else if (stretchFlags & ITEM_BOTTOM)
  410. br.y = tl.y + size.y;
  411. }
  412. void OBSBasicPreview::SnapStretchingToScreen(vec3 &tl, vec3 &br)
  413. {
  414. uint32_t stretchFlags = (uint32_t)stretchHandle;
  415. vec3 newTL = GetTransformedPos(tl.x, tl.y, itemToScreen);
  416. vec3 newTR = GetTransformedPos(br.x, tl.y, itemToScreen);
  417. vec3 newBL = GetTransformedPos(tl.x, br.y, itemToScreen);
  418. vec3 newBR = GetTransformedPos(br.x, br.y, itemToScreen);
  419. vec3 boundingTL;
  420. vec3 boundingBR;
  421. vec3_copy(&boundingTL, &newTL);
  422. vec3_min(&boundingTL, &boundingTL, &newTR);
  423. vec3_min(&boundingTL, &boundingTL, &newBL);
  424. vec3_min(&boundingTL, &boundingTL, &newBR);
  425. vec3_copy(&boundingBR, &newTL);
  426. vec3_max(&boundingBR, &boundingBR, &newTR);
  427. vec3_max(&boundingBR, &boundingBR, &newBL);
  428. vec3_max(&boundingBR, &boundingBR, &newBR);
  429. vec3 offset = GetScreenSnapOffset(boundingTL, boundingBR);
  430. vec3_add(&offset, &offset, &newTL);
  431. vec3_transform(&offset, &offset, &screenToItem);
  432. vec3_sub(&offset, &offset, &tl);
  433. if (stretchFlags & ITEM_LEFT)
  434. tl.x += offset.x;
  435. else if (stretchFlags & ITEM_RIGHT)
  436. br.x += offset.x;
  437. if (stretchFlags & ITEM_TOP)
  438. tl.y += offset.y;
  439. else if (stretchFlags & ITEM_BOTTOM)
  440. br.y += offset.y;
  441. }
  442. void OBSBasicPreview::StretchItem(const vec2 &pos)
  443. {
  444. Qt::KeyboardModifiers modifiers = QGuiApplication::keyboardModifiers();
  445. obs_bounds_type boundsType = obs_sceneitem_get_bounds_type(stretchItem);
  446. uint32_t stretchFlags = (uint32_t)stretchHandle;
  447. bool shiftDown = (modifiers & Qt::ShiftModifier);
  448. vec3 tl, br, pos3;
  449. vec3_zero(&tl);
  450. vec3_set(&br, stretchItemSize.x, stretchItemSize.y, 0.0f);
  451. vec3_set(&pos3, pos.x, pos.y, 0.0f);
  452. vec3_transform(&pos3, &pos3, &screenToItem);
  453. if (stretchFlags & ITEM_LEFT)
  454. tl.x = pos3.x;
  455. else if (stretchFlags & ITEM_RIGHT)
  456. br.x = pos3.x;
  457. if (stretchFlags & ITEM_TOP)
  458. tl.y = pos3.y;
  459. else if (stretchFlags & ITEM_BOTTOM)
  460. br.y = pos3.y;
  461. if (!(modifiers & Qt::ControlModifier))
  462. SnapStretchingToScreen(tl, br);
  463. obs_source_t source = obs_sceneitem_getsource(stretchItem);
  464. vec2 baseSize = {
  465. float(obs_source_getwidth(source)),
  466. float(obs_source_getheight(source))
  467. };
  468. vec2 size = {br.x - tl.x, br.y - tl.y};
  469. if (boundsType != OBS_BOUNDS_NONE) {
  470. if (boundsType == OBS_BOUNDS_STRETCH && !shiftDown)
  471. ClampAspect(tl, br, size, baseSize);
  472. if (tl.x > br.x) std::swap(tl.x, br.x);
  473. if (tl.y > br.y) std::swap(tl.y, br.y);
  474. vec2_abs(&size, &size);
  475. obs_sceneitem_set_bounds(stretchItem, &size);
  476. } else {
  477. if (!shiftDown)
  478. ClampAspect(tl, br, size, baseSize);
  479. vec2_div(&size, &size, &baseSize);
  480. obs_sceneitem_setscale(stretchItem, &size);
  481. }
  482. pos3 = CalculateStretchPos(tl, br);
  483. vec3_transform(&pos3, &pos3, &itemToScreen);
  484. vec2 newPos = {pos3.x, pos3.y};
  485. newPos.x = std::round(newPos.x);
  486. newPos.y = std::round(newPos.y);
  487. obs_sceneitem_setpos(stretchItem, &newPos);
  488. }
  489. void OBSBasicPreview::mouseMoveEvent(QMouseEvent *event)
  490. {
  491. if (mouseDown) {
  492. vec2 pos = GetMouseEventPos(event);
  493. if (!mouseMoved && !mouseOverItems &&
  494. stretchHandle == ItemHandle::None) {
  495. ProcessClick(startPos);
  496. mouseOverItems = SelectedAtPos(startPos);
  497. }
  498. pos.x = std::round(pos.x);
  499. pos.y = std::round(pos.y);
  500. if (stretchHandle != ItemHandle::None)
  501. StretchItem(pos);
  502. else if (mouseOverItems)
  503. MoveItems(pos);
  504. mouseMoved = true;
  505. }
  506. }
  507. static void DrawCircleAtPos(float x, float y, matrix4 &matrix,
  508. float previewScale)
  509. {
  510. struct vec3 pos;
  511. vec3_set(&pos, x, y, 0.0f);
  512. vec3_transform(&pos, &pos, &matrix);
  513. vec3_mulf(&pos, &pos, previewScale);
  514. gs_matrix_push();
  515. gs_matrix_translate(&pos);
  516. gs_draw(GS_LINESTRIP, 0, 0);
  517. gs_matrix_pop();
  518. }
  519. bool OBSBasicPreview::DrawSelectedItem(obs_scene_t scene, obs_sceneitem_t item,
  520. void *param)
  521. {
  522. if (!obs_sceneitem_selected(item))
  523. return true;
  524. OBSBasicPreview *preview = reinterpret_cast<OBSBasicPreview*>(param);
  525. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  526. gs_load_vertexbuffer(main->circle);
  527. matrix4 boxTransform;
  528. obs_sceneitem_get_box_transform(item, &boxTransform);
  529. gs_matrix_push();
  530. gs_matrix_scale3f(HANDLE_RADIUS, HANDLE_RADIUS, 1.0f);
  531. DrawCircleAtPos(0.0f, 0.0f, boxTransform, main->previewScale);
  532. DrawCircleAtPos(0.0f, 1.0f, boxTransform, main->previewScale);
  533. DrawCircleAtPos(1.0f, 0.0f, boxTransform, main->previewScale);
  534. DrawCircleAtPos(1.0f, 1.0f, boxTransform, main->previewScale);
  535. DrawCircleAtPos(0.5f, 0.0f, boxTransform, main->previewScale);
  536. DrawCircleAtPos(0.0f, 0.5f, boxTransform, main->previewScale);
  537. DrawCircleAtPos(0.5f, 1.0f, boxTransform, main->previewScale);
  538. DrawCircleAtPos(1.0f, 0.5f, boxTransform, main->previewScale);
  539. gs_matrix_pop();
  540. gs_load_vertexbuffer(main->box);
  541. gs_matrix_push();
  542. gs_matrix_set(&boxTransform);
  543. gs_matrix_scale3f(main->previewScale, main->previewScale, 1.0f);
  544. gs_draw(GS_LINESTRIP, 0, 0);
  545. gs_matrix_pop();
  546. UNUSED_PARAMETER(scene);
  547. return true;
  548. }
  549. void OBSBasicPreview::DrawSceneEditing()
  550. {
  551. OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
  552. effect_t solid = obs_get_solid_effect();
  553. technique_t tech = effect_gettechnique(solid, "Solid");
  554. vec4 color;
  555. vec4_set(&color, 1.0f, 0.0f, 0.0f, 1.0f);
  556. effect_setvec4(solid, effect_getparambyname(solid, "color"), &color);
  557. technique_begin(tech);
  558. technique_beginpass(tech, 0);
  559. OBSScene scene = main->GetCurrentScene();
  560. if (scene)
  561. obs_scene_enum_items(scene, DrawSelectedItem, this);
  562. gs_load_vertexbuffer(nullptr);
  563. technique_endpass(tech);
  564. technique_end(tech);
  565. }