blob: ae6c41db5e9f0c7c5dd0706e950d1dee9d8b5aac (
plain)
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
|
/*
requirement driven design
do we store graphs as files or in a db with UUID as key?
do we traverse the graph as direct recursive function calls or programmatically from outside?
or keep a reference to the container graph in each node?
graph parent;
vector<signal_input> signal_inputs;
vector<image_input> image_inputs;
//in input
int input_id;
&image get_ouput()
{
for (int i=0;i<inputs.size;i++){
if (inputs[i].input_id) parent.nodes[input_id].get_output(); ///how to find the output in the node? uids for everything?
}
render();
return &image_data;
}
OR
for (int i=0;i<inputs.size;i++){
if (inputs[i].connection) inputs[i].connection->get_output(); ///methinks this is neater? you can check pointer for NULL, can't be ref
}
NO NODE HAS MORE THAN ONE OUTPUT
WE DON'T LINK TO AN OUTPUT OBJECT WE LINK TO THE NODE - GET_OUTPUT IS THE RENDER FUNCTION
settings - how do we deal with settings being controllable
signal inputs can have a gui representation as well
other gui items don't have an input
scaling to come
time is always in floating points seconds - time has to be requested when rendering - either a preview
what about testing a float for equality?
maybe we should look at time in int (frames) - - what does this imply
is it easier to have a function like:
bool Same_frame(float time1, float time2);
2 main questions
authentication - how
authentication to renderer or just session?
files - where
generated images & movies where?
*/
#include <unordered_map>
#include "Poco/UUID.h"
#include "Poco/UUIDGenerator.h"
using Poco::UUID;
using Poco::UUIDGenerator;
#define ROTOR_READY 0
#define ROTOR_ANALYSING_AUDIO 1
#define ROTOR_CREATING_PREVIEW 2
#define ROTOR_RENDERING 3
namespace Rotor {
//forward declaration
class Node;
class Render_status{
public:
int id;
float progress;
};
class Render_requirements{
public:
int num_performances;
int num_clips;
};
class Render_context{ //Poco thread object
//manages access to the 'patchbay'
//high level interfaces for the wizard
//and low level interface onto the graph
public:
Render_status get_status();
void cancel(); //interrupt locking process
int make_preview(int nodeID, float time); //starts a frame preview - returns status code - how to retrieve?
int load_graph(Poco::UUID uid);
UUID save_graph(); //returns UUID of saved graph
int load_audio(string filename);
Render_requirements get_requirements();
int load_video(int num,string filename); //can be performance or clip
private:
int status;
float progress; //for a locking process: audio analysis or rendering
};
class Input{
public:
Node* connection;
};
class Image_input: public Input{
public:
};
class Signal_input: public Input{
public:
};
class Node{
public:
UUID uid; //every usable node has a UUID
int id;
vector<Signal_input> inputs; //simple node has signal inputs and outputs
void get_output(float time);
void gather_inputs(float time) {
for (int i=0;i<inputs.size();i++){
if (inputs[i].connection) inputs[i].connection->get_output(time);
}
}
};
class Image{
char* data;
};
class Image_node: public Node{
public:
vector<Image_input> image_inputs; //image node also has image inputs and outputs
void gather_inputs(float time) {
for (int i=0;i<inputs.size();i++){
if (inputs[i].connection) inputs[i].connection->get_output(time);
}
}
Image& get_output(float time){ //sample implementation
gather_inputs(time);
//do something: i.e
//and then
return &inputs[0].connection->image;
}
void get_preview(float time);
Image* image; //this can be privately allocated or just passed on as the node see fit
private:
float image_time;
};
class Graph{
public:
UUID uid; //every version of a graph has a UUID
private:
std::unordered_map<int,Node> nodes;
};
}
/*
coding style
Types begin with a capital, use underscore as a seperator
*/
|
