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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
#ifndef ROTOR_H
#define ROTOR_H
#include <string>
#include <sstream>
#include <iostream>
#include <map>
#include <vector>
#include <unordered_map>
#include <json/json.h>
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;
virtual std::string get_type()=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){
std::istringstream cur(s);
cur >> value;
}
std::string get_type(){ //need this to output node templates
return "unknown";
}
bool connect(Node* target){
if (connectable){
if (dynamic_cast<Node_type<T>*>(target)){
connection=target;
return true;
}
}
return false;
}
const T& get(const Frame_parameters &frame){
if (connection){
return (dynamic_cast<Node_type<T>*>(connection))->get_output(frame);
}
return value;
}
T value;
};
class Variable_array: public Variable {
public:
Variable_array(){};
std::vector<Variable> values;
};
template <class T> class Variable_array_type: public Variable_array {
public:
Variable_array_type(){};
void add(int num=1){
for (int i=0;i<num;i++) values.push_back(T());
}
bool connect(int which,Node* target){
if (values.size()>which){
return values[which].connect(target);
}
return false;
}
const T& get(int which,const Frame_parameters &frame){
if (values.size()>which){
return values[which].get(frame);
}
return value;
}
std::vector<Variable_type<T>> values;
T value;
};
//don't forget the dupliicate inlets
//it needs to be a property of a var
//vars need to be:
//std::unordered_map<std::string,std::pair<bool,std::vector<Variable*>>>
//??
//or could it be that a var has properties
//var needs to be a class?
//or multi var could be a subclass of var?
//with an extra accessor const T& get(int which,const Frame_parameters &frame)
//in Node we could have create_multi_inlet() and add_multi_inlet()
class Node { //base type for node pointers
public:
virtual ~Node(){
for (auto v:vars){
delete v.second;
}
}
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;
}
virtual Node* clone(std::map<std::string,std::string> &_settings)=0;
std::string node_type;
std::string node_id;
std::string id;
std::string description;
std::string title;
std::string ui_type;
std::string output_type;
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());
}
}
}
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]));
}
template <class IT> Variable_array_type<IT>* create_array(std::string name){
vars[name]=new Variable_array_type<IT>();
return (dynamic_cast<Variable_array_type<IT>*>(vars[name]));
}
};
}
#endif //ROTOR_H
|
