3fdcd3c0c5be356d7f4065b1901b93999e1e2aea
[blender.git] / intern / cycles / render / shader.h
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __SHADER_H__
18 #define __SHADER_H__
19
20 #ifdef WITH_OSL
21 /* So no context pollution happens from indirectly included windows.h */
22 #  include "util/util_windows.h"
23 #  include <OSL/oslexec.h>
24 #endif
25
26 #include "render/attribute.h"
27 #include "kernel/kernel_types.h"
28
29 #include "graph/node.h"
30
31 #include "util/util_map.h"
32 #include "util/util_param.h"
33 #include "util/util_string.h"
34 #include "util/util_thread.h"
35 #include "util/util_types.h"
36
37 CCL_NAMESPACE_BEGIN
38
39 class Device;
40 class DeviceScene;
41 class DeviceRequestedFeatures;
42 class Mesh;
43 class Progress;
44 class Scene;
45 class ShaderGraph;
46 struct float3;
47
48 enum ShadingSystem {
49         SHADINGSYSTEM_OSL,
50         SHADINGSYSTEM_SVM
51 };
52
53 /* Keep those in sync with the python-defined enum. */
54 enum VolumeSampling {
55         VOLUME_SAMPLING_DISTANCE = 0,
56         VOLUME_SAMPLING_EQUIANGULAR = 1,
57         VOLUME_SAMPLING_MULTIPLE_IMPORTANCE = 2,
58
59         VOLUME_NUM_SAMPLING,
60 };
61
62 enum VolumeInterpolation {
63         VOLUME_INTERPOLATION_LINEAR = 0,
64         VOLUME_INTERPOLATION_CUBIC = 1,
65
66         VOLUME_NUM_INTERPOLATION,
67 };
68
69 enum DisplacementMethod {
70         DISPLACE_BUMP = 0,
71         DISPLACE_TRUE = 1,
72         DISPLACE_BOTH = 2,
73
74         DISPLACE_NUM_METHODS,
75 };
76
77 /* Shader describing the appearance of a Mesh, Light or Background.
78  *
79  * While there is only a single shader graph, it has three outputs: surface,
80  * volume and displacement, that the shader manager will compile and execute
81  * separately. */
82
83 class Shader : public Node {
84 public:
85         NODE_DECLARE
86
87         int pass_id;
88
89         /* shader graph */
90         ShaderGraph *graph;
91
92         /* sampling */
93         bool use_mis;
94         bool use_transparent_shadow;
95         bool heterogeneous_volume;
96         VolumeSampling volume_sampling_method;
97         int volume_interpolation_method;
98
99         /* synchronization */
100         bool need_update;
101         bool need_update_attributes;
102
103         /* If the shader has only volume components, the surface is assumed to
104          * be transparent.
105          * However, graph optimization might remove the volume subgraph, but
106          * since the user connected something to the volume output the surface
107          * should still be transparent.
108          * Therefore, has_volume_connected stores whether some volume subtree
109          * was connected before optimization. */
110         bool has_volume_connected;
111
112         /* information about shader after compiling */
113         bool has_surface;
114         bool has_surface_emission;
115         bool has_surface_transparent;
116         bool has_volume;
117         bool has_displacement;
118         bool has_surface_bssrdf;
119         bool has_bump;
120         bool has_bssrdf_bump;
121         bool has_surface_spatial_varying;
122         bool has_volume_spatial_varying;
123         bool has_object_dependency;
124         bool has_integrator_dependency;
125
126         /* displacement */
127         DisplacementMethod displacement_method;
128
129         /* requested mesh attributes */
130         AttributeRequestSet attributes;
131
132         /* determined before compiling */
133         uint id;
134         bool used;
135
136 #ifdef WITH_OSL
137         /* osl shading state references */
138         OSL::ShaderGroupRef osl_surface_ref;
139         OSL::ShaderGroupRef osl_surface_bump_ref;
140         OSL::ShaderGroupRef osl_volume_ref;
141         OSL::ShaderGroupRef osl_displacement_ref;
142 #endif
143
144         Shader();
145         ~Shader();
146
147         /* Checks whether the shader consists of just a emission node with fixed inputs that's connected directly to the output.
148          * If yes, it sets the content of emission to the constant value (color * strength), which is then used for speeding up light evaluation. */
149         bool is_constant_emission(float3* emission);
150
151         void set_graph(ShaderGraph *graph);
152         void tag_update(Scene *scene);
153         void tag_used(Scene *scene);
154 };
155
156 /* Shader Manager virtual base class
157  * 
158  * From this the SVM and OSL shader managers are derived, that do the actual
159  * shader compiling and device updating. */
160
161 class ShaderManager {
162 public:
163         bool need_update;
164
165         static ShaderManager *create(Scene *scene, int shadingsystem);
166         virtual ~ShaderManager();
167
168         virtual void reset(Scene *scene) = 0;
169
170         virtual bool use_osl() { return false; }
171
172         /* device update */
173         virtual void device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress) = 0;
174         virtual void device_free(Device *device, DeviceScene *dscene, Scene *scene) = 0;
175
176         void device_update_shaders_used(Scene *scene);
177         void device_update_common(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress);
178         void device_free_common(Device *device, DeviceScene *dscene, Scene *scene);
179
180         /* get globally unique id for a type of attribute */
181         uint get_attribute_id(ustring name);
182         uint get_attribute_id(AttributeStandard std);
183
184         /* get shader id for mesh faces */
185         int get_shader_id(Shader *shader, bool smooth = false);
186
187         /* add default shaders to scene, to use as default for things that don't
188          * have any shader assigned explicitly */
189         static void add_default(Scene *scene);
190
191         /* Selective nodes compilation. */
192         void get_requested_features(Scene *scene,
193                                     DeviceRequestedFeatures *requested_features);
194
195         static void free_memory();
196
197 protected:
198         ShaderManager();
199
200         typedef unordered_map<ustring, uint, ustringHash> AttributeIDMap;
201         AttributeIDMap unique_attribute_id;
202
203         static thread_mutex lookup_table_mutex;
204         static vector<float> beckmann_table;
205         static bool beckmann_table_ready;
206
207         size_t beckmann_table_offset;
208
209         void get_requested_graph_features(ShaderGraph *graph,
210                                           DeviceRequestedFeatures *requested_features);
211
212         thread_spin_lock attribute_lock_;
213 };
214
215 CCL_NAMESPACE_END
216
217 #endif /* __SHADER_H__ */
218