falkTX
/
paulstretchplugin
mirror of https://bitbucket.org/xenakios/paulstretchplugin.git
1
0
Fork 0
Code Issues 0 Releases 10 Wiki Activity
Browse Source

Rename breakpoint envelope related things

master
xenakios 6 years ago
parent
023989d3de
commit
007cc1cded
3 changed files with 93 additions and 93 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +23
    -23
      Source/envelope_component.cpp
  2. +1
    -1
      Source/envelope_component.h
  3. +69
    -69
      Source/jcdp_envelope.h

+ 23
- 23
Source/envelope_component.cpp View File

@@ -32,10 +32,10 @@ EnvelopeComponent::~EnvelopeComponent()
}

void EnvelopeComponent::show_bubble(int x, int y, const envelope_node& node)
void EnvelopeComponent::show_bubble(int x, int y, const envelope_point& node)
{
double scaledtime = XFromNormalized(node.Time);
double scaledvalue = YFromNormalized(node.Value);
double scaledtime = XFromNormalized(node.pt_x);
double scaledvalue = YFromNormalized(node.pt_y);
x -= 50;
if (x < 0)
x = 0;
@@ -114,9 +114,9 @@ void EnvelopeComponent::paint(Graphics& g)
draw_env(Colours::aquamarine.darker(), true, 1.0f);
for (int i = 0; i < m_envelope->GetNumNodes(); ++i)
{
const envelope_node& pt = m_envelope->GetNodeAtIndex(i);
double xcor = jmap(pt.Time, m_view_start_time, m_view_end_time, 0.0, (double)getWidth());
double ycor = (double)getHeight() - jmap(pt.Value, m_view_start_value, m_view_end_value, 0.0, (double)getHeight());
const envelope_point& pt = m_envelope->GetNodeAtIndex(i);
double xcor = jmap(pt.pt_x, m_view_start_time, m_view_end_time, 0.0, (double)getWidth());
double ycor = (double)getHeight() - jmap(pt.pt_y, m_view_start_value, m_view_end_value, 0.0, (double)getHeight());
g.setColour(Colours::white);
if (pt.Status == 0)
g.drawRect((float)xcor - 4.0f, (float)ycor - 4.0f, 8.0f, 8.0f, 1.0f);
@@ -148,7 +148,7 @@ void EnvelopeComponent::mouseDrag(const MouseEvent& ev)
if (m_segment_drag_info.first >= 0 && ev.mods.isAltDown())
{
double dist = jmap<double>(ev.getDistanceFromDragStartX(), -300.0, 300.0, -1.0, 1.0);
m_envelope->performRelativeTransformation([dist, this](int index, envelope_node& point)
m_envelope->performRelativeTransformation([dist, this](int index, envelope_point& point)
{
if (index == m_segment_drag_info.first)
{
@@ -170,23 +170,23 @@ void EnvelopeComponent::mouseDrag(const MouseEvent& ev)
if (m_node_to_drag >= 0)
{
//Logger::writeToLog("trying to move pt " + String(m_node_to_drag));
envelope_node& pt = m_envelope->GetNodeAtIndex(m_node_to_drag);
envelope_point& pt = m_envelope->GetNodeAtIndex(m_node_to_drag);
double left_bound = m_view_start_time;
double right_bound = m_view_end_time;
if (m_node_to_drag > 0 )
{
left_bound = m_envelope->GetNodeAtIndex(m_node_to_drag - 1).Time;
left_bound = m_envelope->GetNodeAtIndex(m_node_to_drag - 1).pt_x;
}
if (m_node_to_drag < m_envelope->GetNumNodes() - 1)
{
right_bound = m_envelope->GetNodeAtIndex(m_node_to_drag + 1).Time;
right_bound = m_envelope->GetNodeAtIndex(m_node_to_drag + 1).pt_x;
}
double normx = jmap((double)ev.x, 0.0, (double)getWidth(), m_view_start_time, m_view_end_time);
double normy = jmap((double)getHeight() - ev.y, 0.0, (double)getHeight(), m_view_start_value, m_view_end_value);
pt.Time=jlimit(left_bound+0.001, right_bound - 0.001, normx);
pt.Value=jlimit(0.0,1.0,normy);
pt.pt_x=jlimit(left_bound+0.001, right_bound - 0.001, normx);
pt.pt_y=jlimit(0.0,1.0,normy);
m_envelope->updateMinMaxValues();
m_last_tip = String(pt.Time, 2) + " " + String(pt.Value, 2);
m_last_tip = String(pt.pt_x, 2) + " " + String(pt.pt_y, 2);
show_bubble(ev.x, ev.y, pt);
m_node_that_was_dragged = m_node_to_drag;
repaint();
@@ -239,8 +239,8 @@ void EnvelopeComponent::mouseDown(const MouseEvent & ev)
{
for (int i = 0; i < m_envelope->GetNumNodes(); ++i)
{
double val = 1.0 - m_envelope->GetNodeAtIndex(i).Value;
m_envelope->GetNodeAtIndex(i).Value = val;
double val = 1.0 - m_envelope->GetNodeAtIndex(i).pt_y;
m_envelope->GetNodeAtIndex(i).pt_y = val;
}
}
if (r == 3)
@@ -375,7 +375,7 @@ bool EnvelopeComponent::keyPressed(const KeyPress & ev)
m_node_to_drag = -1;
{
ScopedLock locker(*m_cs);
m_envelope->removePointsConditionally([](const envelope_node& pt) { return pt.Status == 1; });
m_envelope->removePointsConditionally([](const envelope_point& pt) { return pt.Status == 1; });
if (m_envelope->GetNumNodes() == 0)
m_envelope->AddNode({ 0.0,0.5 });
}
@@ -392,9 +392,9 @@ int EnvelopeComponent::find_hot_envelope_point(double xcor, double ycor)
return -1;
for (int i = 0; i < m_envelope->GetNumNodes(); ++i)
{
const envelope_node& pt = m_envelope->GetNodeAtIndex(i);
double ptxcor = jmap(pt.Time, m_view_start_time, m_view_end_time, 0.0, (double)getWidth());
double ptycor = (double)getHeight() - jmap(pt.Value, m_view_start_value, m_view_end_value, 0.0, (double)getHeight());
const envelope_point& pt = m_envelope->GetNodeAtIndex(i);
double ptxcor = jmap(pt.pt_x, m_view_start_time, m_view_end_time, 0.0, (double)getWidth());
double ptycor = (double)getHeight() - jmap(pt.pt_y, m_view_start_value, m_view_end_value, 0.0, (double)getHeight());
juce::Rectangle<double> target(ptxcor - 4.0, ptycor - 4.0, 8.0, 8.0);
if (target.contains(xcor, ycor) == true)
{
@@ -410,10 +410,10 @@ int EnvelopeComponent::findHotEnvelopeSegment(double xcor, double ycor, bool det
return -1;
for (int i = 0; i < m_envelope->GetNumNodes()-1; ++i)
{
const envelope_node& pt0 = m_envelope->GetNodeAtIndex(i);
const envelope_node& pt1 = m_envelope->GetNodeAtIndex(i+1);
float xcor0 = (float)jmap<double>(pt0.Time, m_view_start_time, m_view_end_time, 0.0, getWidth());
float xcor1 = (float)jmap<double>(pt1.Time, m_view_start_time, m_view_end_time, 0.0, getWidth());
const envelope_point& pt0 = m_envelope->GetNodeAtIndex(i);
const envelope_point& pt1 = m_envelope->GetNodeAtIndex(i+1);
float xcor0 = (float)jmap<double>(pt0.pt_x, m_view_start_time, m_view_end_time, 0.0, getWidth());
float xcor1 = (float)jmap<double>(pt1.pt_x, m_view_start_time, m_view_end_time, 0.0, getWidth());
float segwidth = xcor1 - xcor0;
juce::Rectangle<float> segrect(xcor0+8.0f, 0.0f, segwidth-16.0f, (float)getHeight());
if (segrect.contains((float)xcor, (float)ycor))


+ 1
- 1
Source/envelope_component.h View File

@@ -68,7 +68,7 @@ private:
int m_node_that_was_dragged = -1;
String m_last_tip;
BubbleMessageComponent m_bubble;
void show_bubble(int x, int y, const envelope_node &node);
void show_bubble(int x, int y, const envelope_point &node);
CriticalSection* m_cs = nullptr;
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(EnvelopeComponent)
};

+ 69
- 69
Source/jcdp_envelope.h View File

@@ -23,14 +23,14 @@ www.gnu.org/licenses
#include "../JuceLibraryCode/JuceHeader.h"
#include "PS_Source/globals.h"

struct envelope_node
struct envelope_point
{
envelope_node()
: Time(0.0), Value(0.0), ShapeParam1(0.5), ShapeParam2(0.5) {}
envelope_node(double x, double y, double p1=0.5, double p2=0.5)
: Time(x), Value(y),ShapeParam1(p1),ShapeParam2(p2) {}
double Time;
double Value;
envelope_point()
: pt_x(0.0), pt_y(0.0), ShapeParam1(0.5), ShapeParam2(0.5) {}
envelope_point(double x, double y, double p1=0.5, double p2=0.5)
: pt_x(x), pt_y(y),ShapeParam1(p1),ShapeParam2(p2) {}
double pt_x;
double pt_y;
int Shape = 0;
double ShapeParam1;
double ShapeParam2;
@@ -38,8 +38,8 @@ struct envelope_node
size_t get_hash() const
{
size_t seed = 0;
seed ^= std::hash<double>()(Time) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= std::hash<double>()(Value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= std::hash<double>()(pt_x) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= std::hash<double>()(pt_y) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= std::hash<int>()(Shape) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= std::hash<double>()(ShapeParam1) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= std::hash<double>()(ShapeParam2) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
@@ -49,9 +49,9 @@ struct envelope_node

};

inline bool operator<(const envelope_node& a, const envelope_node& b)
inline bool operator<(const envelope_point& a, const envelope_point& b)
{
return a.Time<b.Time;
return a.pt_x<b.pt_x;
}

template<typename T>
@@ -147,36 +147,36 @@ inline double get_shaped_value(double x, int, double p1, double)
#endif
}

using nodes_t=std::vector<envelope_node>;
using nodes_t=std::vector<envelope_point>;

inline double GetInterpolatedNodeValue(const nodes_t& m_nodes, double atime, double m_defvalue=0.5)
{
int maxnodeind=(int)m_nodes.size()-1;
if (m_nodes.size()==0) return m_defvalue;
if (m_nodes.size()==1) return m_nodes[0].Value;
if (atime<=m_nodes[0].Time)
return m_nodes[0].Value;
if (atime>m_nodes[maxnodeind].Time)
return m_nodes[maxnodeind].Value;
const envelope_node to_search(atime,0.0);
if (m_nodes.size()==1) return m_nodes[0].pt_y;
if (atime<=m_nodes[0].pt_x)
return m_nodes[0].pt_y;
if (atime>m_nodes[maxnodeind].pt_x)
return m_nodes[maxnodeind].pt_y;
const envelope_point to_search(atime,0.0);
//to_search.Time=atime;
auto it=std::lower_bound(m_nodes.begin(),m_nodes.end(),to_search,
[](const envelope_node& a, const envelope_node& b)
{ return a.Time<b.Time; } );
[](const envelope_point& a, const envelope_point& b)
{ return a.pt_x<b.pt_x; } );
if (it==m_nodes.end())
{
return m_defvalue;
}
--it; // lower_bound has returned iterator to point one too far
double t1=it->Time;
double v1=it->Value;
double t1=it->pt_x;
double v1=it->pt_y;
double p1=it->ShapeParam1;
double p2=it->ShapeParam2;
++it; // next envelope point
double tdelta=it->Time-t1;
double tdelta=it->pt_x-t1;
if (tdelta<0.00001)
tdelta=0.00001;
double vdelta=it->Value-v1;
double vdelta=it->pt_y-v1;
return v1+vdelta*get_shaped_value(((1.0/tdelta*(atime-t1))),0,p1,p2);

}
@@ -230,7 +230,7 @@ public:
{
ValueTree pt_tree("pt");
storeToTreeProperties(pt_tree, nullptr,
"x", m_nodes[i].Time, "y", m_nodes[i].Value, "p1", m_nodes[i].ShapeParam1, "p2", m_nodes[i].ShapeParam2);
"x", m_nodes[i].pt_x, "y", m_nodes[i].pt_y, "p1", m_nodes[i].ShapeParam1, "p2", m_nodes[i].ShapeParam2);
result.addChild(pt_tree, -1, nullptr);
}
result.setProperty("wrapxtransform", m_transform_wrap_x, nullptr);
@@ -263,8 +263,8 @@ public:
MemoryBlock mb;
for (int i = 0; i < m_nodes.size(); ++i)
{
appendToMemoryBlock(mb, m_nodes[i].Time);
appendToMemoryBlock(mb, m_nodes[i].Value);
appendToMemoryBlock(mb, m_nodes[i].pt_x);
appendToMemoryBlock(mb, m_nodes[i].pt_y);
appendToMemoryBlock(mb, m_nodes[i].ShapeParam1);
appendToMemoryBlock(mb, m_nodes[i].ShapeParam2);
}
@@ -279,7 +279,7 @@ public:
return 0.0;
if (index == 0)
return 0.0;
return m_nodes[index - 1].Time + margin;
return m_nodes[index - 1].pt_x + margin;
}
double getNodeRightBound(int index, double margin = 0.01) const noexcept
{
@@ -287,11 +287,11 @@ public:
return 1.0;
if (index == m_nodes.size()-1)
return 1.0;
return m_nodes[index + 1].Time - margin;
return m_nodes[index + 1].pt_x - margin;
}
const std::vector<envelope_node>& get_all_nodes() const { return m_nodes; }
const std::vector<envelope_point>& get_all_nodes() const { return m_nodes; }
void set_all_nodes(nodes_t nds) { m_nodes=std::move(nds); }
void set_reset_nodes(const std::vector<envelope_node>& nodes, bool convertvalues=false)
void set_reset_nodes(const std::vector<envelope_point>& nodes, bool convertvalues=false)
{
if (convertvalues==false)
m_reset_nodes=nodes;
@@ -302,8 +302,8 @@ public:
m_nodes.clear();
for (int i=0;i<nodes.size();++i)
{
envelope_node node=nodes[i];
node.Value=scaled_to_normalized_func(node.Value);
envelope_point node=nodes[i];
node.pt_y=scaled_to_normalized_func(node.pt_y);
m_nodes.push_back(node);
}
}
@@ -331,7 +331,7 @@ public:
m_updateopinprogress=false;
SortNodes();
}
void AddNode(envelope_node newnode)
void AddNode(envelope_point newnode)
{
m_nodes.push_back(newnode);
if (!m_updateopinprogress)
@@ -351,7 +351,7 @@ public:
{
m_nodes.erase(std::remove_if(std::begin(m_nodes),
std::end(m_nodes),
[t0,t1](const envelope_node& a) { return a.Time>=t0 && a.Time<=t1; } ),
[t0,t1](const envelope_point& a) { return a.pt_x>=t0 && a.pt_x<=t1; } ),
std::end(m_nodes) );
}
template<typename F>
@@ -359,7 +359,7 @@ public:
{
m_nodes.erase(std::remove_if(m_nodes.begin(), m_nodes.end(), predicate), m_nodes.end());
}
envelope_node& GetNodeAtIndex(int indx)
envelope_point& GetNodeAtIndex(int indx)
{
if (m_nodes.size()==0)
{
@@ -371,7 +371,7 @@ public:
indx=(int)m_nodes.size()-1;
return m_nodes[indx];
}
const envelope_node& GetNodeAtIndex(int indx) const
const envelope_point& GetNodeAtIndex(int indx) const
{
if (m_nodes.size()==0)
{
@@ -390,7 +390,7 @@ public:
if (indx>(int)m_nodes.size()-1) i=(int)m_nodes.size()-1;
m_nodes[i].Status=nstatus;
}
void SetNode(int indx, envelope_node anode)
void SetNode(int indx, envelope_point anode)
{
int i=indx;
if (indx<0) i=0;
@@ -402,8 +402,8 @@ public:
int i=indx;
if (indx<0) i=0;
if (indx>(int)m_nodes.size()-1) i=(int)m_nodes.size()-1;
if (setTime) m_nodes[i].Time=atime;
if (setValue) m_nodes[i].Value=avalue;
if (setTime) m_nodes[i].pt_x=atime;
if (setValue) m_nodes[i].pt_y=avalue;
}


@@ -419,8 +419,8 @@ public:
if (m_nodes.size()==0)
return m_defvalue;
if (m_nodes.size()==1)
return m_nodes[0].Value;
if (atime<=m_nodes[0].Time)
return m_nodes[0].pt_y;
if (atime<=m_nodes[0].pt_x)
{
#ifdef INTERPOLATING_ENVELOPE_BORDERS
t1=m_nodes[0].Time;
@@ -431,10 +431,10 @@ public:
v1=m_nodes[0].Value;
return interpolate_foo(atime,t0,v0,t1,v1,p1,p2);
#else
return m_nodes[0].Value;
return m_nodes[0].pt_y;
#endif
}
if (atime>m_nodes[maxnodeind].Time)
if (atime>m_nodes[maxnodeind].pt_x)
{
#ifdef INTERPOLATING_ENVELOPE_BORDERS
t0=m_nodes[maxnodeind].Time;
@@ -445,40 +445,40 @@ public:
p2=m_nodes[maxnodeind].ShapeParam2;
return interpolate_foo(atime,t0,v0,t1,v1,p1,p2);
#else
return m_nodes.back().Value;
return m_nodes.back().pt_y;
#endif
}
const envelope_node to_search(atime,0.0);
const envelope_point to_search(atime,0.0);
//to_search.Time=atime;
auto it=std::lower_bound(m_nodes.begin(),m_nodes.end(),to_search,
[](const envelope_node& a, const envelope_node& b)
{ return a.Time<b.Time; } );
[](const envelope_point& a, const envelope_point& b)
{ return a.pt_x<b.pt_x; } );
if (it==m_nodes.end())
{
return m_defvalue;
}
--it; // lower_bound has returned iterator to point one too far
t0=it->Time;
v0=it->Value;
t0=it->pt_x;
v0=it->pt_y;
p1=it->ShapeParam1;
p2=it->ShapeParam2;
++it; // next envelope point
t1=it->Time;
v1=it->Value;
t1=it->pt_x;
v1=it->pt_y;
return interpolate_foo(atime,t0,v0,t1,v1,p1,p2);
}
bool IsSorted() const
{
return std::is_sorted(m_nodes.begin(), m_nodes.end(), []
(const envelope_node& lhs, const envelope_node& rhs)
(const envelope_point& lhs, const envelope_point& rhs)
{
return lhs.Time<rhs.Time;
return lhs.pt_x<rhs.pt_x;
});
}
void SortNodes()
{
stable_sort(m_nodes.begin(),m_nodes.end(),
[](const envelope_node& a, const envelope_node& b){ return a.Time<b.Time; } );
[](const envelope_point& a, const envelope_point& b){ return a.pt_x<b.pt_x; } );
}
double minimum_value() const { return m_minvalue; }
double maximum_value() const { return m_maxvalue; }
@@ -503,7 +503,7 @@ public:
{
for (int i = 0; i < m_old_nodes.size(); ++i)
{
envelope_node node = m_old_nodes[i];
envelope_point node = m_old_nodes[i];
f(i, node);
node.ShapeParam1 = jlimit(0.0, 1.0, node.ShapeParam1);
m_nodes[i] = node;
@@ -513,11 +513,11 @@ public:
{
if (index >= m_old_nodes.size())
{
m_nodes.back().Value = jlimit(0.0,1.0,m_old_nodes.back().Value+amount);
m_nodes.back().pt_y = jlimit(0.0,1.0,m_old_nodes.back().pt_y+amount);
return;
}
m_nodes[index].Value = jlimit(0.0, 1.0, m_old_nodes[index].Value + amount);
m_nodes[index+1].Value = jlimit(0.0, 1.0, m_old_nodes[index+1].Value + amount);
m_nodes[index].pt_y = jlimit(0.0, 1.0, m_old_nodes[index].pt_y + amount);
m_nodes[index+1].pt_y = jlimit(0.0, 1.0, m_old_nodes[index+1].pt_y + amount);
}
const nodes_t& repeater_nodes() const
{
@@ -528,10 +528,10 @@ public:
m_repeater_nodes.clear();
for (int i=0;i<m_nodes.size();++i)
{
if (m_nodes[i].Time>=m_playoffset && m_nodes[i].Time<=m_playoffset+1.0)
if (m_nodes[i].pt_x>=m_playoffset && m_nodes[i].pt_x<=m_playoffset+1.0)
{
envelope_node temp=m_nodes[i];
temp.Time-=m_playoffset;
envelope_point temp=m_nodes[i];
temp.pt_x-=m_playoffset;
m_repeater_nodes.push_back(temp);
}
}
@@ -558,17 +558,17 @@ public:
if (m_nodes.size() == 0)
return;
envelope_node pt0 = GetNodeAtIndex(point_index);
envelope_node pt1 = GetNodeAtIndex(point_index+1);
double xdiff = pt1.Time - pt0.Time;
envelope_point pt0 = GetNodeAtIndex(point_index);
envelope_point pt1 = GetNodeAtIndex(point_index+1);
double xdiff = pt1.pt_x - pt0.pt_x;
if (xdiff > 0.0)
{
int numsegments = numsegmentsfunc(xdiff);
for (int j=0;j<numsegments;++j)
{
double cb_x0 = pt0.Time + xdiff / (numsegments)*j;
double cb_x0 = pt0.pt_x + xdiff / (numsegments)*j;
double cb_y0 = GetInterpolatedNodeValue(cb_x0);
double cb_x1 = pt0.Time + xdiff / (numsegments)*(j+1);
double cb_x1 = pt0.pt_x + xdiff / (numsegments)*(j+1);
double cb_y1 = GetInterpolatedNodeValue(cb_x1);
handlesegmentfunc(cb_x0, cb_y0,cb_x1,cb_y1);
}
@@ -642,8 +642,8 @@ public:
double maxv = 0.0;
for (auto& e : m_nodes)
{
minv = std::min(minv, e.Value);
maxv = std::max(maxv, e.Value);
minv = std::min(minv, e.pt_y);
maxv = std::max(maxv, e.pt_y);
}
m_minvalue = minv;
m_maxvalue = maxv;


Write Preview
Loading…
Cancel
Save