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
|
#include <string>
#include <sstream>
#include <iostream>
#include <map>
#include <unordered_map>
#include "utils.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 { //base type for variable pointers
public:
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:
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;
}
T* get(Frame_parameters frame);
T value;
};
//what happens if we want to link an unlinked attribute at runtime
//should attributes and paramaters just be the same thing
//it would be really nice if there could be arithmetic
//type objects that could act on multiple types
//either we call them attributes and inlets or just vars
//for the author, is it better to have seperate static members?
//for the GUI, yes. but is that another issue?
//does the gui need a hint for the "basic" mode inlets so they stand out?
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 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);
}
};
}
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> IT* create_inlet(std::string name){
vars[name]=new Variable_type<IT>();
return &((dynamic_cast<Variable_type<IT>*>(vars[name]))->value);
}
};
class time: public Node_type<double> {
public:
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");
}
double* get_output(const Frame_parameters &frame){
result=(*inlet)*(*value);
return &result;
}
private:
double *inlet;
double *value;
double result;
};
}
//next:: make a couple of nodes that do something
//test them
//make loading and saving functions
//xml or json?
|
