Merge branch 'master' into blender2.8
[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_mesh;
102         bool need_sync_object;
103
104         /* If the shader has only volume components, the surface is assumed to
105          * be transparent.
106          * However, graph optimization might remove the volume subgraph, but
107          * since the user connected something to the volume output the surface
108          * should still be transparent.
109          * Therefore, has_volume_connected stores whether some volume subtree
110          * was connected before optimization. */
111         bool has_volume_connected;
112
113         /* information about shader after compiling */
114         bool has_surface;
115         bool has_surface_emission;
116         bool has_surface_transparent;
117         bool has_volume;
118         bool has_displacement;
119         bool has_surface_bssrdf;
120         bool has_bump;
121         bool has_bssrdf_bump;
122         bool has_surface_spatial_varying;
123         bool has_volume_spatial_varying;
124         bool has_object_dependency;
125         bool has_attribute_dependency;
126         bool has_integrator_dependency;
127
128         /* displacement */
129         DisplacementMethod displacement_method;
130
131         /* requested mesh attributes */
132         AttributeRequestSet attributes;
133
134         /* determined before compiling */
135         uint id;
136         bool used;
137
138 #ifdef WITH_OSL
139         /* osl shading state references */
140         OSL::ShaderGroupRef osl_surface_ref;
141         OSL::ShaderGroupRef osl_surface_bump_ref;
142         OSL::ShaderGroupRef osl_volume_ref;
143         OSL::ShaderGroupRef osl_displacement_ref;
144 #endif
145
146         Shader();
147         ~Shader();
148
149         /* Checks whether the shader consists of just a emission node with fixed inputs that's connected directly to the output.
150          * If yes, it sets the content of emission to the constant value (color * strength), which is then used for speeding up light evaluation. */
151         bool is_constant_emission(float3* emission);
152
153         void set_graph(ShaderGraph *graph);
154         void tag_update(Scene *scene);
155         void tag_used(Scene *scene);
156 };
157
158 /* Shader Manager virtual base class
159  *
160  * From this the SVM and OSL shader managers are derived, that do the actual
161  * shader compiling and device updating. */
162
163 class ShaderManager {
164 public:
165         bool need_update;
166
167         static ShaderManager *create(Scene *scene, int shadingsystem);
168         virtual ~ShaderManager();
169
170         virtual void reset(Scene *scene) = 0;
171
172         virtual bool use_osl() { return false; }
173
174         /* device update */
175         virtual void device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress) = 0;
176         virtual void device_free(Device *device, DeviceScene *dscene, Scene *scene) = 0;
177
178         void device_update_shaders_used(Scene *scene);
179         void device_update_common(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress);
180         void device_free_common(Device *device, DeviceScene *dscene, Scene *scene);
181
182         /* get globally unique id for a type of attribute */
183         uint get_attribute_id(ustring name);
184         uint get_attribute_id(AttributeStandard std);
185
186         /* get shader id for mesh faces */
187         int get_shader_id(Shader *shader, bool smooth = false);
188
189         /* add default shaders to scene, to use as default for things that don't
190          * have any shader assigned explicitly */
191         static void add_default(Scene *scene);
192
193         /* Selective nodes compilation. */
194         void get_requested_features(Scene *scene,
195                                     DeviceRequestedFeatures *requested_features);
196
197         static void free_memory();
198
199         float linear_rgb_to_gray(float3 c);
200
201         string get_cryptomatte_materials(Scene *scene);
202
203 protected:
204         ShaderManager();
205
206         typedef unordered_map<ustring, uint, ustringHash> AttributeIDMap;
207         AttributeIDMap unique_attribute_id;
208
209         static thread_mutex lookup_table_mutex;
210         static vector<float> beckmann_table;
211         static bool beckmann_table_ready;
212
213         size_t beckmann_table_offset;
214
215         void get_requested_graph_features(ShaderGraph *graph,
216                                           DeviceRequestedFeatures *requested_features);
217
218         thread_spin_lock attribute_lock_;
219
220         float3 xyz_to_r;
221         float3 xyz_to_g;
222         float3 xyz_to_b;
223         float3 rgb_to_y;
224 };
225
226 CCL_NAMESPACE_END
227
228 #endif  /* __SHADER_H__ */