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
|
/*
* Copyright 2011-2013 Blender Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License
*/
#ifndef __SVM_H__
#define __SVM_H__
#include "attribute.h"
#include "graph.h"
#include "shader.h"
#include "util_set.h"
#include "util_string.h"
CCL_NAMESPACE_BEGIN
class Device;
class DeviceScene;
class ImageManager;
class Scene;
class ShaderGraph;
class ShaderInput;
class ShaderNode;
class ShaderOutput;
/* Shader Manager */
class SVMShaderManager : public ShaderManager {
public:
SVMShaderManager();
~SVMShaderManager();
void reset(Scene *scene);
void device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress);
void device_free(Device *device, DeviceScene *dscene, Scene *scene);
};
/* Graph Compiler */
class SVMCompiler {
public:
SVMCompiler(ShaderManager *shader_manager, ImageManager *image_manager,
bool use_multi_closure_);
void compile(Shader *shader, vector<int4>& svm_nodes, int index);
void stack_assign(ShaderOutput *output);
void stack_assign(ShaderInput *input);
int stack_find_offset(ShaderSocketType type);
void stack_clear_offset(ShaderSocketType type, int offset);
void stack_link(ShaderInput *input, ShaderOutput *output);
void add_node(NodeType type, int a = 0, int b = 0, int c = 0);
void add_node(int a = 0, int b = 0, int c = 0, int d = 0);
void add_node(NodeType type, const float3& f);
void add_node(const float4& f);
void add_array(float4 *f, int num);
uint attribute(ustring name);
uint attribute(AttributeStandard std);
uint encode_uchar4(uint x, uint y = 0, uint z = 0, uint w = 0);
uint closure_mix_weight_offset() { return mix_weight_offset; }
ShaderType output_type() { return current_type; }
ImageManager *image_manager;
ShaderManager *shader_manager;
bool background;
protected:
/* stack */
struct Stack {
Stack() { memset(users, 0, sizeof(users)); }
Stack(const Stack& other) { memcpy(users, other.users, sizeof(users)); }
Stack& operator=(const Stack& other) { memcpy(users, other.users, sizeof(users)); return *this; }
bool empty()
{
for(int i = 0; i < SVM_STACK_SIZE; i++)
if(users[i])
return false;
return true;
}
void print()
{
printf("stack <");
for(int i = 0; i < SVM_STACK_SIZE; i++)
printf((users[i])? "*": " ");
printf(">\n");
}
int users[SVM_STACK_SIZE];
};
struct StackBackup {
Stack stack;
vector<int> offsets;
set<ShaderNode*> done;
};
void stack_backup(StackBackup& backup, set<ShaderNode*>& done);
void stack_restore(StackBackup& backup, set<ShaderNode*>& done);
void stack_clear_temporary(ShaderNode *node);
int stack_size(ShaderSocketType type);
void stack_clear_users(ShaderNode *node, set<ShaderNode*>& done);
bool node_skip_input(ShaderNode *node, ShaderInput *input);
/* single closure */
void find_dependencies(set<ShaderNode*>& dependencies, const set<ShaderNode*>& done, ShaderInput *input);
void generate_svm_nodes(const set<ShaderNode*>& nodes, set<ShaderNode*>& done);
void generate_closure(ShaderNode *node, set<ShaderNode*>& done);
/* multi closure */
void generate_multi_closure(ShaderNode *node, set<ShaderNode*>& done, set<ShaderNode*>& closure_done);
/* compile */
void compile_type(Shader *shader, ShaderGraph *graph, ShaderType type);
vector<int4> svm_nodes;
ShaderType current_type;
Shader *current_shader;
ShaderGraph *current_graph;
Stack active_stack;
int max_stack_use;
uint mix_weight_offset;
bool use_multi_closure;
};
CCL_NAMESPACE_END
#endif /* __SVM_H__ */
|