dc57ed4e4eb4decd7caf74a684f540969b2e6a19
[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_windows.h"
23 #  include <OSL/oslexec.h>
24 #endif
25
26 #include "attribute.h"
27 #include "kernel_types.h"
28
29 #include "node.h"
30
31 #include "util_map.h"
32 #include "util_param.h"
33 #include "util_string.h"
34 #include "util_thread.h"
35 #include "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 /* Shader describing the appearance of a Mesh, Light or Background.
70  *
71  * While there is only a single shader graph, it has three outputs: surface,
72  * volume and displacement, that the shader manager will compile and execute
73  * separately. */
74
75 class Shader : public Node {
76 public:
77         NODE_DECLARE;
78
79         int pass_id;
80
81         /* shader graph */
82         ShaderGraph *graph;
83
84         /* shader graph with auto bump mapping included, we compile two shaders,
85          * with and without bump,  because the displacement method is a mesh
86          * level setting, so we need to handle both */
87         ShaderGraph *graph_bump;
88
89         /* sampling */
90         bool use_mis;
91         bool use_transparent_shadow;
92         bool heterogeneous_volume;
93         VolumeSampling volume_sampling_method;
94         int volume_interpolation_method;
95
96         /* synchronization */
97         bool need_update;
98         bool need_update_attributes;
99
100         /* information about shader after compiling */
101         bool has_surface;
102         bool has_surface_emission;
103         bool has_surface_transparent;
104         bool has_volume;
105         bool has_displacement;
106         bool has_surface_bssrdf;
107         bool has_bssrdf_bump;
108         bool has_surface_spatial_varying;
109         bool has_volume_spatial_varying;
110         bool has_object_dependency;
111         bool has_integrator_dependency;
112
113         /* requested mesh attributes */
114         AttributeRequestSet attributes;
115
116         /* determined before compiling */
117         uint id;
118         bool used;
119
120 #ifdef WITH_OSL
121         /* osl shading state references */
122         OSL::ShaderGroupRef osl_surface_ref;
123         OSL::ShaderGroupRef osl_surface_bump_ref;
124         OSL::ShaderGroupRef osl_volume_ref;
125         OSL::ShaderGroupRef osl_displacement_ref;
126 #endif
127
128         Shader();
129         ~Shader();
130
131         void set_graph(ShaderGraph *graph);
132         void tag_update(Scene *scene);
133         void tag_used(Scene *scene);
134 };
135
136 /* Shader Manager virtual base class
137  * 
138  * From this the SVM and OSL shader managers are derived, that do the actual
139  * shader compiling and device updating. */
140
141 class ShaderManager {
142 public:
143         bool need_update;
144
145         static ShaderManager *create(Scene *scene, int shadingsystem);
146         virtual ~ShaderManager();
147
148         virtual void reset(Scene *scene) = 0;
149
150         virtual bool use_osl() { return false; }
151
152         /* device update */
153         virtual void device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress) = 0;
154         virtual void device_free(Device *device, DeviceScene *dscene, Scene *scene) = 0;
155
156         void device_update_shaders_used(Scene *scene);
157         void device_update_common(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress);
158         void device_free_common(Device *device, DeviceScene *dscene, Scene *scene);
159
160         /* get globally unique id for a type of attribute */
161         uint get_attribute_id(ustring name);
162         uint get_attribute_id(AttributeStandard std);
163
164         /* get shader id for mesh faces */
165         int get_shader_id(Shader *shader, Mesh *mesh = NULL, bool smooth = false);
166
167         /* add default shaders to scene, to use as default for things that don't
168          * have any shader assigned explicitly */
169         static void add_default(Scene *scene);
170
171         /* Selective nodes compilation. */
172         void get_requested_features(Scene *scene,
173                                     DeviceRequestedFeatures *requested_features);
174
175         static void free_memory();
176
177 protected:
178         ShaderManager();
179
180         typedef unordered_map<ustring, uint, ustringHash> AttributeIDMap;
181         AttributeIDMap unique_attribute_id;
182
183         thread_mutex lookup_table_mutex;
184         static vector<float> beckmann_table;
185
186         size_t beckmann_table_offset;
187
188         void get_requested_graph_features(ShaderGraph *graph,
189                                           DeviceRequestedFeatures *requested_features);
190 };
191
192 CCL_NAMESPACE_END
193
194 #endif /* __SHADER_H__ */
195