eessppeelllloo/vimix
1
0
Fork 0
mirror of https://github.com/brunoherbelin/vimix.git synced 2025-12-09 01:09:59 +01:00
Code Issues Packages Projects Releases Wiki Activity

Improved Geometry view source manipulation; added cursor change and

Browse Source 
fixed-size handles on frame.
This commit is contained in:
brunoherbelin
2020-05-26 00:07:38 +02:00
parent 80b420e83e
commit aa6c12fd60
9 changed files with 93 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
Mesh.cpp
View File

@@ -9,6 +9,7 @@
#include <glad/glad.h>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/vector_angle.hpp>
#include "RenderingManager.h"
#include "Primitives.h"
@@ -474,8 +475,8 @@ Handles::Handles(Type type) : Node(), type_(type)
}
else {
// handle_ = new LineSquare(color, int ( 2.1f * Rendering::manager().DPIScale()) );
handle_ = new Mesh("mesh/border_handles_sharp.ply");
handle_->scale_ = glm::vec3( 0.05f, 0.05f, 1.f);
handle_ = new Mesh("mesh/border_handles_overlay.ply");
// handle_->scale_ = glm::vec3( 0.05f, 0.05f, 1.f);
}
}
@@ -506,35 +507,55 @@ void Handles::draw(glm::mat4 modelview, glm::mat4 projection)
handle_->shader()->color = color;
glm::mat4 ctm;
glm::vec3 rot(0.f);
glm::vec4 vec = modelview * glm::vec4(1.f, 0.f, 0.f, 0.f);
rot.z = glm::orientedAngle( glm::vec3(1.f, 0.f, 0.f), glm::normalize(glm::vec3(vec)), glm::vec3(0.f, 0.f, 1.f) );
if ( type_ == RESIZE ) {
// 4 corners
ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, -1.f, 0.f) ) ;
// ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, -1.f, 0.f));
vec = modelview * glm::vec4(1.f, -1.f, 0.f, 1.f);
ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
handle_->draw( ctm, projection );
ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, +1.f, 0.f));
// ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, +1.f, 0.f));
vec = modelview * glm::vec4(1.f, 1.f, 0.f, 1.f);
ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
handle_->draw( ctm, projection );
ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, -1.f, 0.f));
// ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, -1.f, 0.f));
vec = modelview * glm::vec4(-1.f, -1.f, 0.f, 1.f);
ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
handle_->draw( ctm, projection );
ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, +1.f, 0.f));
// ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, +1.f, 0.f));
vec = modelview * glm::vec4(-1.f, 1.f, 0.f, 1.f);
ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
handle_->draw( ctm, projection );
}
else if ( type_ == RESIZE_H ){
// left and right
ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, 0.f, 0.f) );
// ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, 0.f, 0.f));
vec = modelview * glm::vec4(1.f, 0.f, 0.f, 1.f);
ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
handle_->draw( ctm, projection );
ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, 0.f, 0.f));
// ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, 0.f, 0.f));
vec = modelview * glm::vec4(-1.f, 0.f, 0.f, 1.f);
ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
handle_->draw( ctm, projection );
}
else if ( type_ == RESIZE_V ){
// top and bottom
ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(0.f, +1.f, 0.f) );
// ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(0.f, +1.f, 0.f));
vec = modelview * glm::vec4(0.f, 1.f, 0.f, 1.f);
ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
handle_->draw( ctm, projection );
ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(0.f, -1.f, 0.f));
// ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(0.f, -1.f, 0.f));
vec = modelview * glm::vec4(0.f, -1.f, 0.f, 1.f);
ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
handle_->draw( ctm, projection );
}
else if ( type_ == ROTATE ){

1
Mixer.cpp
View File

@@ -293,7 +293,6 @@ void Mixer::insertSource(Source *s)
// update view to show source created
current_view_->update(0);
// current_view_->makeVisible(s);
current_view_->restoreSettings();
}
}

2
PickingVisitor.cpp
View File

@@ -78,7 +78,7 @@ void PickingVisitor::visit(Handles &n)
glm::vec4 P = glm::inverse(modelview_) * glm::vec4( point_, 0.f, 1.f );
// get the bounding box of a handle
GlmToolkit::AxisAlignedBoundingBox bb = n.handle()->bbox().scaled(n.handle()->scale_);
GlmToolkit::AxisAlignedBoundingBox bb = n.handle()->bbox();
// test picking depending on type of handle
bool picked = false;

3
Primitives.cpp
View File

@@ -113,7 +113,6 @@ void ImageSurface::init()
textureindex_ = Resource::getTextureImage(resource_, &ar);
scale_.x = ar;
}
}
void ImageSurface::accept(Visitor& v)
@@ -139,7 +138,6 @@ void MediaSurface::init()
mediaplayer_->open(path_);
mediaplayer_->play(true);
}
void MediaSurface::draw(glm::mat4 modelview, glm::mat4 projection)
@@ -153,7 +151,6 @@ void MediaSurface::draw(glm::mat4 modelview, glm::mat4 projection)
textureindex_ = mediaplayer_->texture();
Surface::draw(modelview, projection);
}
void MediaSurface::update( float dt )

11
Scene.cpp
View File

@@ -409,19 +409,20 @@ void Animation::accept(Visitor& v)
v.visit(*this);
}
Scene::Scene(): root_(nullptr), foreground_(nullptr), background_(nullptr)
Scene::Scene()
{
root_ = new Group;
background_ = new Group;
background_->translation_.z = 0.f;
root_->attach(background_);
workspace_ = new Group;
workspace_->translation_.z = 1.f;
root_->attach(workspace_);
foreground_ = new Group;
foreground_->translation_.z = SCENE_DEPTH -0.1f;
root_->attach(background_);
root_->attach(workspace_);
root_->attach(foreground_);
}
@@ -446,7 +447,7 @@ void Scene::clearForeground()
void Scene::clearWorkspace()
{
foreground_->clear();
workspace_->clear();
}
void Scene::clearBackground()

4
Scene.h
View File

@@ -51,7 +51,7 @@ public:
inline int id () const { return id_; }
// must initialize the node before draw
virtual void init() { initialized_ = true; }
virtual void init () { initialized_ = true; }
virtual bool initialized () { return initialized_; }
// pure virtual draw : to be instanciated to define node behavior
@@ -63,7 +63,7 @@ public:
// accept all kind of visitors
virtual void accept (Visitor& v);
void copyTransform(Node *other);
void copyTransform (Node *other);
// public members, to manipulate with care
bool visible_;

7
UserInterfaceManager.cpp
View File

@@ -309,9 +309,9 @@ void UserInterface::handleMouse()
if ( ImGui::IsMouseDragging(ImGuiMouseButton_Right, 10.0f) )
{
// right mouse drag => drag current view
Mixer::manager().currentView()->drag( mouseclic[ImGuiMouseButton_Right], mousepos);
int c = Mixer::manager().currentView()->drag( mouseclic[ImGuiMouseButton_Right], mousepos);
ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeAll);
ImGui::SetMouseCursor(c);
}
else {
ImGui::SetMouseCursor(ImGuiMouseCursor_Arrow);
@@ -335,7 +335,8 @@ void UserInterface::handleMouse()
if (current)
{
// drag current source
Mixer::manager().currentView()->grab( mouseclic[ImGuiMouseButton_Left], mousepos, current, pick);
int c = Mixer::manager().currentView()->grab( mouseclic[ImGuiMouseButton_Left], mousepos, current, pick);
ImGui::SetMouseCursor(c);
}
else {
// Log::Info("Mouse drag (%.1f,%.1f)(%.1f,%.1f)", io.MouseClickedPos[0].x, io.MouseClickedPos[0].y, io.MousePos.x, io.MousePos.y);

37
View.cpp
View File

@@ -58,7 +58,7 @@ void View::update(float dt)
}
}
void View::drag (glm::vec2 from, glm::vec2 to)
View::Cursor View::drag (glm::vec2 from, glm::vec2 to)
{
static glm::vec3 start_translation = glm::vec3(0.f);
static glm::vec2 start_position = glm::vec2(0.f);
@@ -74,6 +74,8 @@ void View::drag (glm::vec2 from, glm::vec2 to)
// compute delta translation
scene.root()->translation_ = start_translation + gl_Position_to - gl_Position_from;
return Cursor_ResizeAll;
}
MixingView::MixingView() : View(MIXING)
@@ -106,10 +108,10 @@ void MixingView::zoom( float factor )
scene.root()->scale_.y = z;
}
void MixingView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2>)
View::Cursor MixingView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2>)
{
if (!s)
return;
return Cursor_Arrow;
Group *sourceNode = s->group(mode_);
@@ -130,6 +132,8 @@ void MixingView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *
// request update
s->touch();
return Cursor_ResizeAll;
}
uint MixingView::textureMixingQuadratic()
@@ -262,11 +266,13 @@ void GeometryView::zoom( float factor )
scene.root()->scale_.y = z;
}
void GeometryView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick)
View::Cursor GeometryView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick)
{
View::Cursor ret = Cursor_Arrow;
// work on the given source
if (!s)
return;
return ret;
Group *sourceNode = s->group(mode_);
// remember source transform at moment of clic at position 'from'
@@ -303,7 +309,7 @@ void GeometryView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node
S_resize.y = S_resize.x;
sourceNode->scale_ = start_scale * S_resize;
Log::Info(" resize ( %.1f, %.1f ) ", S_resize.x, S_resize.y);
// Log::Info(" resize ( %.1f, %.1f ) ", S_resize.x, S_resize.y);
// glm::vec3 factor = S_resize * glm::vec3(0.5f, 0.5f, 1.f);
//// glm::vec3 factor = S_resize * glm::vec3(1.f, 1.f, 1.f);
//// factor *= glm::sign( glm::vec3(pick.second, 1.f) );
@@ -312,32 +318,45 @@ void GeometryView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node
// sourceNode->translation_ = start_translation + factor;
//// sourceNode->translation_ = start_translation + S_resize * factor;
// select cursor depending on diagonal
glm::vec2 axis = glm::sign(pick.second);
ret = axis.x * axis.y > 0.f ? Cursor_ResizeNESW : Cursor_ResizeNWSE;
}
// picking on the resizing handles left or right
else if ( pick.first == s->handleNode(Handles::RESIZE_H) ) {
sourceNode->scale_ = start_scale * glm::vec3(S_resize.x, 1.f, 1.f);
ret = Cursor_ResizeEW;
}
// picking on the resizing handles top or bottom
else if ( pick.first == s->handleNode(Handles::RESIZE_V) ) {
sourceNode->scale_ = start_scale * glm::vec3(1.f, S_resize.y, 1.f);
ret = Cursor_ResizeNS;
}
// picking on the rotating handle
else if ( pick.first == s->handleNode(Handles::ROTATE) ) {
float angle = glm::orientedAngle( glm::normalize(glm::vec2(S_from)), glm::normalize(glm::vec2(S_to)));
if (UserInterface::manager().keyboardModifier())
angle = float ( int(angle * 30.f) ) / 30.f;
sourceNode->rotation_ = start_rotation + glm::vec3(0.f, 0.f, angle);
ret = Cursor_Hand;
}
// picking anywhere but on a handle: user wants to move the source
else {
sourceNode->translation_ = start_translation + gl_Position_to - gl_Position_from;
ret = Cursor_ResizeAll;
}
}
// don't have a handle, we can only move the source
else {
sourceNode->translation_ = start_translation + gl_Position_to - gl_Position_from;
ret = Cursor_ResizeAll;
}
// request update
s->touch();
return ret;
}
LayerView::LayerView() : View(LAYER), aspect_ratio(1.f)
@@ -428,10 +447,10 @@ void LayerView::setDepth (Source *s, float d)
View::need_deep_update_ = true;
}
void LayerView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick)
View::Cursor LayerView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick)
{
if (!s)
return;
return Cursor_Arrow;
static glm::vec3 start_translation = glm::vec3(0.f);
static glm::vec2 start_position = glm::vec2(0.f);
@@ -450,5 +469,7 @@ void LayerView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *,
// apply change
setDepth( s, MAX( -dest_translation.x, 0.f) );
return Cursor_ResizeAll;
}

25
View.h
View File

@@ -21,8 +21,23 @@ public:
virtual void update (float dt);
virtual void draw ();
virtual void zoom (float) {}
virtual void drag (glm::vec2, glm::vec2);
virtual void grab (glm::vec2, glm::vec2, Source*, std::pair<Node *, glm::vec2>) {}
typedef enum {
Cursor_Arrow = 0,
Cursor_TextInput,
Cursor_ResizeAll,
Cursor_ResizeNS,
Cursor_ResizeEW,
Cursor_ResizeNESW,
Cursor_ResizeNWSE,
Cursor_Hand,
Cursor_NotAllowed
} Cursor;
virtual Cursor drag (glm::vec2, glm::vec2);
virtual Cursor grab (glm::vec2, glm::vec2, Source*, std::pair<Node *, glm::vec2>) {
return Cursor_Arrow;
}
virtual void restoreSettings();
virtual void saveSettings();
@@ -43,7 +58,7 @@ public:
MixingView();
void zoom (float factor) override;
void grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2>) override;
Cursor grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2>) override;
private:
uint textureMixingQuadratic();
@@ -72,7 +87,7 @@ public:
void update (float dt) override;
void zoom (float factor) override;
void grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick) override;
Cursor grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick) override;
};
@@ -83,7 +98,7 @@ public:
void update (float dt) override;
void zoom (float factor) override;
void grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick) override;
Cursor grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick) override;
void setDepth (Source *, float d = -1.f);