mirror/obs-studio
0
0
Fork 0
mirror of https://github.com/obsproject/obs-studio.git synced 2024-09-20 04:42:18 +02:00
Code

Merge pull request #2212 from VodBox/group-edit-mode

Browse Source 
UI: Add various preview improvements
This commit is contained in:
Ryan Foster 2022-07-28 10:40:43 -04:00 committed by GitHub
commit 2741b8c885
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 260 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

294
UI/window-basic-preview.cpp
View File

@ -30,6 +30,8 @@ OBSBasicPreview::~OBSBasicPreview()
gs_texture_destroy(overflow);
if (rectFill)
gs_vertexbuffer_destroy(rectFill);
if (circleFill)
gs_vertexbuffer_destroy(circleFill);
obs_leave_graphics();
}
@ -47,6 +49,19 @@ vec2 OBSBasicPreview::GetMouseEventPos(QMouseEvent *event)
return pos;
}
static void RotatePos(vec2 *pos, float rot)
{
float cosR = cos(rot);
float sinR = sin(rot);
vec2 newPos;
newPos.x = cosR * pos->x - sinR * pos->y;
newPos.y = sinR * pos->x + cosR * pos->y;
vec2_copy(pos, &newPos);
}
struct SceneFindData {
const vec2 &pos;
OBSSceneItem item;
@ -287,6 +302,11 @@ struct HandleFindData {
OBSSceneItem item;
ItemHandle handle = ItemHandle::None;
float angle = 0.0f;
vec2 rotatePoint;
vec2 offsetPoint;
float angleOffset = 0.0f;
HandleFindData(const HandleFindData &) = delete;
HandleFindData(HandleFindData &&) = delete;
@ -304,7 +324,10 @@ struct HandleFindData {
: pos(hfd.pos),
radius(hfd.radius),
item(hfd.item),
handle(hfd.handle)
handle(hfd.handle),
angle(hfd.angle),
rotatePoint(hfd.rotatePoint),
offsetPoint(hfd.offsetPoint)
{
obs_sceneitem_get_draw_transform(parent, &parent_xform);
}
@ -318,10 +341,16 @@ static bool FindHandleAtPos(obs_scene_t *scene, obs_sceneitem_t *item,
if (!obs_sceneitem_selected(item)) {
if (obs_sceneitem_is_group(item)) {
HandleFindData newData(data, item);
newData.angleOffset = obs_sceneitem_get_rot(item);
obs_sceneitem_group_enum_items(item, FindHandleAtPos,
&newData);
data.item = newData.item;
data.handle = newData.handle;
data.angle = newData.angle;
data.rotatePoint = newData.rotatePoint;
data.offsetPoint = newData.offsetPoint;
}
return true;
@ -358,6 +387,40 @@ static bool FindHandleAtPos(obs_scene_t *scene, obs_sceneitem_t *item,
TestHandle(0.5f, 1.0f, ItemHandle::BottomCenter);
TestHandle(1.0f, 1.0f, ItemHandle::BottomRight);
vec2 rotHandleOffset;
vec2_set(&rotHandleOffset, 0.0f,
HANDLE_RADIUS * data.radius * 1.5 - data.radius);
RotatePos(&rotHandleOffset, atan2(transform.x.y, transform.x.x));
RotatePos(&rotHandleOffset, RAD(data.angleOffset));
vec3 handlePos = GetTransformedPos(0.5f, 0.0f, transform);
vec3_transform(&handlePos, &handlePos, &data.parent_xform);
handlePos.x -= rotHandleOffset.x;
handlePos.y -= rotHandleOffset.y;
float dist = vec3_dist(&handlePos, &pos3);
if (dist < data.radius) {
if (dist < closestHandle) {
closestHandle = dist;
data.item = item;
data.angle = obs_sceneitem_get_rot(item);
data.handle = ItemHandle::Rot;
vec2_set(&data.rotatePoint,
transform.t.x + transform.x.x / 2 +
transform.y.x / 2,
transform.t.y + transform.x.y / 2 +
transform.y.y / 2);
obs_sceneitem_get_pos(item, &data.offsetPoint);
data.offsetPoint.x -= data.rotatePoint.x;
data.offsetPoint.y -= data.rotatePoint.y;
RotatePos(&data.offsetPoint,
-RAD(obs_sceneitem_get_rot(item)));
}
}
UNUSED_PARAMETER(scene);
return true;
}
@ -404,6 +467,10 @@ void OBSBasicPreview::GetStretchHandleData(const vec2 &pos, bool ignoreGroup)
stretchItem = std::move(data.item);
stretchHandle = data.handle;
rotateAngle = data.angle;
rotatePoint = data.rotatePoint;
offsetPoint = data.offsetPoint;
if (stretchHandle != ItemHandle::None) {
matrix4 boxTransform;
vec3 itemUL;
@ -583,7 +650,7 @@ void OBSBasicPreview::UpdateCursor(uint32_t &flags)
return;
}
if (!flags && cursor().shape() != Qt::OpenHandCursor)
if (!flags && (cursor().shape() != Qt::OpenHandCursor || !scrollMode))
unsetCursor();
if (cursor().shape() != Qt::ArrowCursor)
return;
@ -598,6 +665,8 @@ void OBSBasicPreview::UpdateCursor(uint32_t &flags)
setCursor(Qt::SizeHorCursor);
else if (flags & ITEM_TOP || flags & ITEM_BOTTOM)
setCursor(Qt::SizeVerCursor);
else if (flags & ITEM_ROT)
setCursor(Qt::OpenHandCursor);
}
static bool select_one(obs_scene_t *scene, obs_sceneitem_t *item, void *param)
@ -1461,8 +1530,58 @@ void OBSBasicPreview::StretchItem(const vec2 &pos)
obs_sceneitem_set_pos(stretchItem, &newPos);
}
void OBSBasicPreview::RotateItem(const vec2 &pos)
{
OBSBasic *main = reinterpret_cast<OBSBasic *>(App()->GetMainWindow());
OBSScene scene = main->GetCurrentScene();
Qt::KeyboardModifiers modifiers = QGuiApplication::keyboardModifiers();
bool shiftDown = (modifiers & Qt::ShiftModifier);
bool ctrlDown = (modifiers & Qt::ControlModifier);
vec2 pos2;
vec2_copy(&pos2, &pos);
float angle =
atan2(pos2.y - rotatePoint.y, pos2.x - rotatePoint.x) + RAD(90);
#define ROT_SNAP(rot, thresh) \
if (abs(angle - RAD(rot)) < RAD(thresh)) { \
angle = RAD(rot); \
}
if (shiftDown) {
for (int i = 0; i <= 360 / 15; i++) {
ROT_SNAP(i * 15 - 90, 7.5);
}
} else if (!ctrlDown) {
ROT_SNAP(rotateAngle, 5)
ROT_SNAP(-90, 5)
ROT_SNAP(-45, 5)
ROT_SNAP(0, 5)
ROT_SNAP(45, 5)
ROT_SNAP(90, 5)
ROT_SNAP(135, 5)
ROT_SNAP(180, 5)
ROT_SNAP(225, 5)
ROT_SNAP(270, 5)
ROT_SNAP(315, 5)
}
#undef ROT_SNAP
vec2 pos3;
vec2_copy(&pos3, &offsetPoint);
RotatePos(&pos3, angle);
pos3.x += rotatePoint.x;
pos3.y += rotatePoint.y;
obs_sceneitem_set_rot(stretchItem, DEG(angle));
obs_sceneitem_set_pos(stretchItem, &pos3);
}
void OBSBasicPreview::mouseMoveEvent(QMouseEvent *event)
{
OBSBasic *main = reinterpret_cast<OBSBasic *>(App()->GetMainWindow());
changed = true;
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
@ -1471,9 +1590,11 @@ void OBSBasicPreview::mouseMoveEvent(QMouseEvent *event)
QPointF qtPos = event->localPos();
#endif
float pixelRatio = main->devicePixelRatioF();
if (scrollMode && event->buttons() == Qt::LeftButton) {
scrollingOffset.x += qtPos.x() - scrollingFrom.x;
scrollingOffset.y += qtPos.y() - scrollingFrom.y;
scrollingOffset.x += pixelRatio * (qtPos.x() - scrollingFrom.x);
scrollingOffset.y += pixelRatio * (qtPos.y() - scrollingFrom.y);
scrollingFrom.x = qtPos.x();
scrollingFrom.y = qtPos.y();
emit DisplayResized();
@ -1503,8 +1624,6 @@ void OBSBasicPreview::mouseMoveEvent(QMouseEvent *event)
selectionBox = false;
OBSBasic *main = reinterpret_cast<OBSBasic *>(
App()->GetMainWindow());
OBSScene scene = main->GetCurrentScene();
obs_sceneitem_t *group =
obs_sceneitem_get_group(scene, stretchItem);
@ -1517,7 +1636,10 @@ void OBSBasicPreview::mouseMoveEvent(QMouseEvent *event)
pos.y = group_pos.y;
}
if (cropping)
if (stretchHandle == ItemHandle::Rot) {
RotateItem(pos);
setCursor(Qt::ClosedHandCursor);
} else if (cropping)
CropItem(pos);
else
StretchItem(pos);
@ -1570,25 +1692,6 @@ void OBSBasicPreview::leaveEvent(QEvent *)
hoveredPreviewItems.clear();
}
static void DrawSquareAtPos(float x, float y)
{
struct vec3 pos;
vec3_set(&pos, x, y, 0.0f);
struct matrix4 matrix;
gs_matrix_get(&matrix);
vec3_transform(&pos, &pos, &matrix);
gs_matrix_push();
gs_matrix_identity();
gs_matrix_translate(&pos);
gs_matrix_translate3f(-HANDLE_RADIUS, -HANDLE_RADIUS, 0.0f);
gs_matrix_scale3f(HANDLE_RADIUS * 2, HANDLE_RADIUS * 2, 1.0f);
gs_draw(GS_TRISTRIP, 0, 0);
gs_matrix_pop();
}
static void DrawLine(float x1, float y1, float x2, float y2, float thickness,
vec2 scale)
{
@ -1600,9 +1703,10 @@ static void DrawLine(float x1, float y1, float x2, float y2, float thickness,
gs_vertex2f(x1, y1);
gs_vertex2f(x1 + (xSide * (thickness / scale.x)),
y1 + (ySide * (thickness / scale.y)));
gs_vertex2f(x2, y2);
gs_vertex2f(x2 + (xSide * (thickness / scale.x)),
y2 + (ySide * (thickness / scale.y)));
gs_vertex2f(x2, y2);
gs_vertex2f(x1, y1);
gs_vertbuffer_t *line = gs_render_save();
@ -1611,6 +1715,78 @@ static void DrawLine(float x1, float y1, float x2, float y2, float thickness,
gs_vertexbuffer_destroy(line);
}
static void DrawSquareAtPos(float x, float y)
{
OBSBasic *main = OBSBasic::Get();
float pixelRatio = main->devicePixelRatioF();
struct vec3 pos;
vec3_set(&pos, x, y, 0.0f);
struct matrix4 matrix;
gs_matrix_get(&matrix);
vec3_transform(&pos, &pos, &matrix);
gs_matrix_push();
gs_matrix_identity();
gs_matrix_translate(&pos);
gs_matrix_translate3f(-HANDLE_RADIUS * pixelRatio,
-HANDLE_RADIUS * pixelRatio, 0.0f);
gs_matrix_scale3f(HANDLE_RADIUS * pixelRatio * 2,
HANDLE_RADIUS * pixelRatio * 2, 1.0f);
gs_draw(GS_TRISTRIP, 0, 0);
gs_matrix_pop();
}
static void DrawRotationHandle(gs_vertbuffer_t *circle, float rot)
{
OBSBasic *main = OBSBasic::Get();
float pixelRatio = main->devicePixelRatioF();
struct vec3 pos;
vec3_set(&pos, 0.5f, 0.0f, 0.0f);
struct matrix4 matrix;
gs_matrix_get(&matrix);
vec3_transform(&pos, &pos, &matrix);
gs_render_start(true);
gs_vertex2f(0.5f - 0.34f / HANDLE_RADIUS, 0.5f);
gs_vertex2f(0.5f - 0.34f / HANDLE_RADIUS, -2.0f);
gs_vertex2f(0.5f + 0.34f / HANDLE_RADIUS, -2.0f);
gs_vertex2f(0.5f + 0.34f / HANDLE_RADIUS, 0.5f);
gs_vertex2f(0.5f - 0.34f / HANDLE_RADIUS, 0.5f);
gs_vertbuffer_t *line = gs_render_save();
gs_load_vertexbuffer(line);
gs_matrix_push();
gs_matrix_identity();
gs_matrix_translate(&pos);
gs_matrix_rotaa4f(0.0f, 0.0f, 1.0f, RAD(rot));
gs_matrix_translate3f(-HANDLE_RADIUS * 1.5 * pixelRatio,
-HANDLE_RADIUS * 1.5 * pixelRatio, 0.0f);
gs_matrix_scale3f(HANDLE_RADIUS * 3 * pixelRatio,
HANDLE_RADIUS * 3 * pixelRatio, 1.0f);
gs_draw(GS_TRISTRIP, 0, 0);
gs_matrix_translate3f(0.0f, -HANDLE_RADIUS * 2 / 3, 0.0f);
gs_load_vertexbuffer(circle);
gs_draw(GS_TRISTRIP, 0, 0);
gs_matrix_pop();
gs_vertexbuffer_destroy(line);
}
static void DrawStripedLine(float x1, float y1, float x2, float y2,
float thickness, vec2 scale)
{
@ -1788,19 +1964,28 @@ bool OBSBasicPreview::DrawSelectedItem(obs_scene_t *scene,
if (!SceneItemHasVideo(item))
return true;
OBSBasicPreview *prev = reinterpret_cast<OBSBasicPreview *>(param);
if (obs_sceneitem_is_group(item)) {
matrix4 mat;
obs_transform_info groupInfo;
obs_sceneitem_get_draw_transform(item, &mat);
obs_sceneitem_get_info(item, &groupInfo);
prev->groupRot = groupInfo.rot;
gs_matrix_push();
gs_matrix_mul(&mat);
obs_sceneitem_group_enum_items(item, DrawSelectedItem, param);
obs_sceneitem_group_enum_items(item, DrawSelectedItem, prev);
gs_matrix_pop();
prev->groupRot = 0.0f;
}
OBSBasicPreview *prev = reinterpret_cast<OBSBasicPreview *>(param);
OBSBasic *main = OBSBasic::Get();
float pixelRatio = main->devicePixelRatioF();
bool hovered = false;
{
std::lock_guard<std::mutex> lock(prev->selectMutex);
@ -1881,16 +2066,19 @@ bool OBSBasicPreview::DrawSelectedItem(obs_scene_t *scene,
gs_effect_set_vec4(colParam, &red);
if (info.bounds_type == OBS_BOUNDS_NONE && crop_enabled(&crop)) {
#define DRAW_SIDE(side, x1, y1, x2, y2) \
if (hovered && !selected) { \
gs_effect_set_vec4(colParam, &blue); \
DrawLine(x1, y1, x2, y2, HANDLE_RADIUS / 2, boxScale); \
} else if (crop.side > 0) { \
gs_effect_set_vec4(colParam, &green); \
DrawStripedLine(x1, y1, x2, y2, HANDLE_RADIUS / 2, boxScale); \
} else { \
DrawLine(x1, y1, x2, y2, HANDLE_RADIUS / 2, boxScale); \
} \
#define DRAW_SIDE(side, x1, y1, x2, y2) \
if (hovered && !selected) { \
gs_effect_set_vec4(colParam, &blue); \
DrawLine(x1, y1, x2, y2, HANDLE_RADIUS *pixelRatio / 2, \
boxScale); \
} else if (crop.side > 0) { \
gs_effect_set_vec4(colParam, &green); \
DrawStripedLine(x1, y1, x2, y2, HANDLE_RADIUS *pixelRatio / 2, \
boxScale); \
} else { \
DrawLine(x1, y1, x2, y2, HANDLE_RADIUS *pixelRatio / 2, \
boxScale); \
} \
gs_effect_set_vec4(colParam, &red);
DRAW_SIDE(left, 0.0f, 0.0f, 0.0f, 1.0f);
@ -1901,9 +2089,9 @@ bool OBSBasicPreview::DrawSelectedItem(obs_scene_t *scene,
} else {
if (!selected) {
gs_effect_set_vec4(colParam, &blue);
DrawRect(HANDLE_RADIUS / 2, boxScale);
DrawRect(HANDLE_RADIUS * pixelRatio / 2, boxScale);
} else {
DrawRect(HANDLE_RADIUS / 2, boxScale);
DrawRect(HANDLE_RADIUS * pixelRatio / 2, boxScale);
}
}
@ -1919,6 +2107,24 @@ bool OBSBasicPreview::DrawSelectedItem(obs_scene_t *scene,
DrawSquareAtPos(0.0f, 0.5f);
DrawSquareAtPos(0.5f, 1.0f);
DrawSquareAtPos(1.0f, 0.5f);
if (!prev->circleFill) {
gs_render_start(true);
float angle = 180;
for (int i = 0, l = 40; i < l; i++) {
gs_vertex2f(sin(RAD(angle)) / 2 + 0.5f,
cos(RAD(angle)) / 2 + 0.5f);
angle += 360 / l;
gs_vertex2f(sin(RAD(angle)) / 2 + 0.5f,
cos(RAD(angle)) / 2 + 0.5f);
gs_vertex2f(0.5f, 1.0f);
}
prev->circleFill = gs_render_save();
}
DrawRotationHandle(prev->circleFill, info.rot + prev->groupRot);
}
gs_matrix_pop();
@ -1932,6 +2138,10 @@ bool OBSBasicPreview::DrawSelectedItem(obs_scene_t *scene,
bool OBSBasicPreview::DrawSelectionBox(float x1, float y1, float x2, float y2,
gs_vertbuffer_t *rectFill)
{
OBSBasic *main = OBSBasic::Get();
float pixelRatio = main->devicePixelRatioF();
x1 = std::round(x1);
x2 = std::round(x2);
y1 = std::round(y1);
@ -1960,7 +2170,7 @@ bool OBSBasicPreview::DrawSelectionBox(float x1, float y1, float x2, float y2,
gs_draw(GS_TRISTRIP, 0, 0);
gs_effect_set_vec4(colParam, &borderColor);
DrawRect(HANDLE_RADIUS / 2, scale);
DrawRect(HANDLE_RADIUS * pixelRatio / 2, scale);
gs_matrix_pop();

8
UI/window-basic-preview.hpp
View File

@ -16,6 +16,7 @@ class QMouseEvent;
#define ITEM_RIGHT (1 << 1)
#define ITEM_TOP (1 << 2)
#define ITEM_BOTTOM (1 << 3)
#define ITEM_ROT (1 << 4)
#define ZOOM_SENSITIVITY 1.125f
@ -29,6 +30,7 @@ enum class ItemHandle : uint32_t {
BottomLeft = ITEM_BOTTOM | ITEM_LEFT,
BottomCenter = ITEM_BOTTOM,
BottomRight = ITEM_BOTTOM | ITEM_RIGHT,
Rot = ITEM_ROT
};
class OBSBasicPreview : public OBSQTDisplay {
@ -44,6 +46,9 @@ private:
OBSSceneItem stretchGroup;
OBSSceneItem stretchItem;
ItemHandle stretchHandle = ItemHandle::None;
float rotateAngle;
vec2 rotatePoint;
vec2 offsetPoint;
vec2 stretchItemSize;
matrix4 screenToItem;
matrix4 itemToScreen;
@ -51,6 +56,7 @@ private:
gs_texture_t *overflow = nullptr;
gs_vertbuffer_t *rectFill = nullptr;
gs_vertbuffer_t *circleFill = nullptr;
vec2 startPos;
vec2 mousePos;
@ -67,6 +73,7 @@ private:
bool selectionBox = false;
int32_t scalingLevel = 0;
float scalingAmount = 1.0f;
float groupRot = 0.0f;
std::vector<obs_sceneitem_t *> hoveredPreviewItems;
std::vector<obs_sceneitem_t *> selectedItems;
@ -99,6 +106,7 @@ private:
vec3 CalculateStretchPos(const vec3 &tl, const vec3 &br);
void CropItem(const vec2 &pos);
void StretchItem(const vec2 &pos);
void RotateItem(const vec2 &pos);
static void SnapItemMovement(vec2 &offset);
void MoveItems(const vec2 &pos);