1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
#include <string>
#include <sstream>
#include <iostream>
#include <map>
#include <unordered_map>
namespace Rotor {
class Node;
template <class NT> class Node_type;
class Audio_frame{
public:
Audio_frame(uint16_t *_samples,int _channels,int _numsamples){
samples=_samples;
channels=_channels;
numsamples=_numsamples;
}
uint16_t *samples;
int channels,numsamples;
};
class Frame_parameters{
public:
Frame_parameters(double _time,double _framerate,double _duration,int _w,int _h,Audio_frame *_audio=nullptr)
{ time=_time; framerate=_framerate; duration=_duration; w=_w; h=_h;audio=_audio;};
Frame_parameters(int _frame,double _framerate,double _duration,int _w,int _h,Audio_frame *_audio=nullptr)
{ time=((double)_frame)/_framerate; framerate=_framerate; duration=_duration; w=_w; h=_h;audio=_audio;};
int h,w;
Frame_parameters lastframe() const{
return Frame_parameters(time-(1.0/framerate),framerate,duration,w,h);
}
Frame_parameters nextframe() const{
return Frame_parameters(time+(1.0/framerate),framerate,duration,w,h);
}
double time; //num/denom ?
double framerate;
double duration;
Audio_frame *audio;
};
class Variable { //pure virtual base type for variable pointers
public:
Variable(){connection=nullptr;};
virtual void init(std::string s)=0;
virtual ~Variable(){};
virtual bool connect(Node* target)=0;
Node* connection;
bool connectable;
};
template <class T> class Variable_type : public Variable {
public:
Variable_type(bool _c){connectable=_c;};
void init(std::string s);
bool connect(Node* target);
const T& get(const Frame_parameters &frame);
T value;
};
class enum{
public:
vector<std::string> options;
};
//rotor variable types
class Node { //base type for node pointers
public:
virtual ~Node(){
for (auto v:vars){
//std::cerr<<"deleting "<<v.first<<" ("<<(*v.second)<<")"<<std::endl;
delete v.second;
}
}
protected:
std::unordered_map<std::string,Variable*> vars;
};
template <class NT> class Node_type : public Node {
public:
virtual const NT& get_output(const Frame_parameters &frame)=0;
void init(std::map<std::string,std::string> settings){
for (auto s:settings) {
if (vars.find(s.first)!=vars.end()){
vars[s.first]->init(s.second);
//printf("set %s to %s\n",s.first.c_str(),s.second.c_str());
}
};
}
bool connect(std::string v,Node *t){
auto var=vars.find(v);
if (var!=vars.end()){
if ((*var).second->connect(t)){
return true;
}
}
return false;
}
template <class IT> Variable_type<IT>* create_inlet(std::string name){
vars[name]=new Variable_type<IT>(true);
return (dynamic_cast<Variable_type<IT>*>(vars[name]));
}
template <class IT> Variable_type<IT>* create_attribute(std::string name){
vars[name]=new Variable_type<IT>(false);
return (dynamic_cast<Variable_type<IT>*>(vars[name]));
}
};
class time: public Node_type<double> {
public:
const double &get_output(const Frame_parameters &frame){
value=frame.time;
return value;
}
private:
double value;
};
class multiply: public Node_type<double> {
public:
multiply(){
inlet=create_inlet<double>("inlet");
value=create_inlet<double>("value");
}
const double &get_output(const Frame_parameters &frame){
result=inlet->get(frame)*value->get(frame);
return result;
}
private:
Variable_type<double> *inlet;
Variable_type<double> *value;
double result;
};
class print: public Node_type<std::string> {
public:
print(){
inlet=create_inlet<double>("inlet");
}
const std::string &get_output(const Frame_parameters &frame){
std::ostringstream out;
out << inlet->get(frame);
result=out.str();
return result;
}
private:
Variable_type<double> *inlet;
std::string result;
};
}
//next:: make a couple of nodes that do something
//test them
//make loading and saving functions
//xml or json?
|
