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
|
#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;
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;
}
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;
};
//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 type;
std::string type;
std::string type;
std::string type;
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());
}
}
}
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]));
}
};
}
#endif //ROTOR_H
|
