Cleanup: Use "region" for ARegion variable names
[blender.git] / source / blender / gpu / GPU_material.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2005 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup gpu
22  */
23
24 #pragma once
25
26 #include "DNA_customdata_types.h" /* for CustomDataType */
27 #include "DNA_listBase.h"
28
29 #include "BLI_sys_types.h" /* for bool */
30
31 #include "GPU_texture.h" /* for eGPUSamplerState */
32
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36
37 struct GHash;
38 struct GPUMaterial;
39 struct GPUNode;
40 struct GPUNodeLink;
41 struct GPUNodeStack;
42 struct GPUTexture;
43 struct GPUUniformBuf;
44 struct Image;
45 struct ImageUser;
46 struct ListBase;
47 struct Main;
48 struct Material;
49 struct Scene;
50 struct bNode;
51 struct bNodeTree;
52
53 typedef struct GPUMaterial GPUMaterial;
54 typedef struct GPUNode GPUNode;
55 typedef struct GPUNodeLink GPUNodeLink;
56
57 /* Functions to create GPU Materials nodes */
58
59 typedef enum eGPUType {
60   /* Keep in sync with GPU_DATATYPE_STR */
61   /* The value indicates the number of elements in each type */
62   GPU_NONE = 0,
63   GPU_FLOAT = 1,
64   GPU_VEC2 = 2,
65   GPU_VEC3 = 3,
66   GPU_VEC4 = 4,
67   GPU_MAT3 = 9,
68   GPU_MAT4 = 16,
69   GPU_MAX_CONSTANT_DATA = GPU_MAT4,
70
71   /* Values not in GPU_DATATYPE_STR */
72   GPU_TEX1D_ARRAY = 1001,
73   GPU_TEX2D = 1002,
74   GPU_TEX2D_ARRAY = 1003,
75   GPU_TEX3D = 1004,
76   GPU_SHADOW2D = 1005,
77   GPU_TEXCUBE = 1006,
78
79   /* GLSL Struct types */
80   GPU_CLOSURE = 1007,
81
82   /* Opengl Attributes */
83   GPU_ATTR = 3001,
84 } eGPUType;
85
86 typedef enum eGPUBuiltin {
87   GPU_VIEW_MATRIX = (1 << 0),
88   GPU_OBJECT_MATRIX = (1 << 1),
89   GPU_INVERSE_VIEW_MATRIX = (1 << 2),
90   GPU_INVERSE_OBJECT_MATRIX = (1 << 3),
91   GPU_VIEW_POSITION = (1 << 4),
92   GPU_VIEW_NORMAL = (1 << 5),
93   GPU_OBJECT_COLOR = (1 << 6),
94   GPU_AUTO_BUMPSCALE = (1 << 7),
95   GPU_CAMERA_TEXCO_FACTORS = (1 << 8),
96   GPU_PARTICLE_SCALAR_PROPS = (1 << 9),
97   GPU_PARTICLE_LOCATION = (1 << 10),
98   GPU_PARTICLE_VELOCITY = (1 << 11),
99   GPU_PARTICLE_ANG_VELOCITY = (1 << 12),
100   GPU_LOC_TO_VIEW_MATRIX = (1 << 13),
101   GPU_INVERSE_LOC_TO_VIEW_MATRIX = (1 << 14),
102   GPU_OBJECT_INFO = (1 << 15),
103   GPU_BARYCENTRIC_TEXCO = (1 << 16),
104   GPU_BARYCENTRIC_DIST = (1 << 17),
105   GPU_WORLD_NORMAL = (1 << 18),
106 } eGPUBuiltin;
107
108 typedef enum eGPUMatFlag {
109   GPU_MATFLAG_DIFFUSE = (1 << 0),
110   GPU_MATFLAG_GLOSSY = (1 << 1),
111   GPU_MATFLAG_REFRACT = (1 << 2),
112   GPU_MATFLAG_SSS = (1 << 3),
113   GPU_MATFLAG_BARYCENTRIC = (1 << 4),
114 } eGPUMatFlag;
115
116 typedef struct GPUNodeStack {
117   eGPUType type;
118   float vec[4];
119   struct GPUNodeLink *link;
120   bool hasinput;
121   bool hasoutput;
122   short sockettype;
123   bool end;
124 } GPUNodeStack;
125
126 typedef enum eGPUMaterialStatus {
127   GPU_MAT_FAILED = 0,
128   GPU_MAT_QUEUED,
129   GPU_MAT_SUCCESS,
130 } eGPUMaterialStatus;
131
132 typedef enum eGPUVolumeDefaultValue {
133   GPU_VOLUME_DEFAULT_0,
134   GPU_VOLUME_DEFAULT_1,
135 } eGPUVolumeDefaultValue;
136
137 typedef void (*GPUMaterialEvalCallbackFn)(GPUMaterial *mat,
138                                           int options,
139                                           const char **vert_code,
140                                           const char **geom_code,
141                                           const char **frag_lib,
142                                           const char **defines);
143
144 GPUNodeLink *GPU_constant(const float *num);
145 GPUNodeLink *GPU_uniform(const float *num);
146 GPUNodeLink *GPU_attribute(GPUMaterial *mat, CustomDataType type, const char *name);
147 GPUNodeLink *GPU_uniform_attribute(GPUMaterial *mat, const char *name, bool use_dupli);
148 GPUNodeLink *GPU_image(GPUMaterial *mat,
149                        struct Image *ima,
150                        struct ImageUser *iuser,
151                        eGPUSamplerState sampler_state);
152 GPUNodeLink *GPU_image_tiled(GPUMaterial *mat,
153                              struct Image *ima,
154                              struct ImageUser *iuser,
155                              eGPUSamplerState sampler_state);
156 GPUNodeLink *GPU_image_tiled_mapping(GPUMaterial *mat, struct Image *ima, struct ImageUser *iuser);
157 GPUNodeLink *GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *row);
158 GPUNodeLink *GPU_volume_grid(GPUMaterial *mat,
159                              const char *name,
160                              eGPUVolumeDefaultValue default_value);
161 GPUNodeLink *GPU_builtin(eGPUBuiltin builtin);
162
163 bool GPU_link(GPUMaterial *mat, const char *name, ...);
164 bool GPU_stack_link(GPUMaterial *mat,
165                     struct bNode *node,
166                     const char *name,
167                     GPUNodeStack *in,
168                     GPUNodeStack *out,
169                     ...);
170 GPUNodeLink *GPU_uniformbuf_link_out(struct GPUMaterial *mat,
171                                      struct bNode *node,
172                                      struct GPUNodeStack *stack,
173                                      const int index);
174
175 void GPU_material_output_link(GPUMaterial *material, GPUNodeLink *link);
176
177 void GPU_material_sss_profile_create(GPUMaterial *material,
178                                      float radii[3],
179                                      const short *falloff_type,
180                                      const float *sharpness);
181 struct GPUUniformBuf *GPU_material_sss_profile_get(GPUMaterial *material,
182                                                    int sample_len,
183                                                    struct GPUTexture **tex_profile);
184
185 /* High level functions to create and use GPU materials */
186 GPUMaterial *GPU_material_from_nodetree_find(struct ListBase *gpumaterials,
187                                              const void *engine_type,
188                                              int options);
189 GPUMaterial *GPU_material_from_nodetree(struct Scene *scene,
190                                         struct Material *ma,
191                                         struct bNodeTree *ntree,
192                                         struct ListBase *gpumaterials,
193                                         const void *engine_type,
194                                         const int options,
195                                         const bool is_volume_shader,
196                                         const char *vert_code,
197                                         const char *geom_code,
198                                         const char *frag_lib,
199                                         const char *defines,
200                                         const char *name,
201                                         GPUMaterialEvalCallbackFn callback);
202 void GPU_material_compile(GPUMaterial *mat);
203 void GPU_material_free(struct ListBase *gpumaterial);
204
205 void GPU_materials_free(struct Main *bmain);
206
207 struct Scene *GPU_material_scene(GPUMaterial *material);
208 struct GPUPass *GPU_material_get_pass(GPUMaterial *material);
209 struct GPUShader *GPU_material_get_shader(GPUMaterial *material);
210 struct Material *GPU_material_get_material(GPUMaterial *material);
211 eGPUMaterialStatus GPU_material_status(GPUMaterial *mat);
212
213 struct GPUUniformBuf *GPU_material_uniform_buffer_get(GPUMaterial *material);
214 void GPU_material_uniform_buffer_create(GPUMaterial *material, ListBase *inputs);
215 struct GPUUniformBuf *GPU_material_create_sss_profile_ubo(void);
216
217 bool GPU_material_has_surface_output(GPUMaterial *mat);
218 bool GPU_material_has_volume_output(GPUMaterial *mat);
219
220 bool GPU_material_is_volume_shader(GPUMaterial *mat);
221
222 void GPU_material_flag_set(GPUMaterial *mat, eGPUMatFlag flag);
223 bool GPU_material_flag_get(GPUMaterial *mat, eGPUMatFlag flag);
224
225 void GPU_pass_cache_init(void);
226 void GPU_pass_cache_garbage_collect(void);
227 void GPU_pass_cache_free(void);
228
229 /* Requested Material Attributes and Textures */
230
231 typedef struct GPUMaterialAttribute {
232   struct GPUMaterialAttribute *next, *prev;
233   int type;      /* CustomDataType */
234   char name[64]; /* MAX_CUSTOMDATA_LAYER_NAME */
235   eGPUType gputype;
236   int id;
237   int users;
238 } GPUMaterialAttribute;
239
240 typedef struct GPUMaterialTexture {
241   struct GPUMaterialTexture *next, *prev;
242   struct Image *ima;
243   struct ImageUser *iuser;
244   struct GPUTexture **colorband;
245   char sampler_name[32];       /* Name of sampler in GLSL. */
246   char tiled_mapping_name[32]; /* Name of tile mapping sampler in GLSL. */
247   int users;
248   int sampler_state; /* eGPUSamplerState */
249 } GPUMaterialTexture;
250
251 typedef struct GPUMaterialVolumeGrid {
252   struct GPUMaterialVolumeGrid *next, *prev;
253   char *name;
254   eGPUVolumeDefaultValue default_value;
255   char sampler_name[32];   /* Name of sampler in GLSL. */
256   char transform_name[32]; /* Name of 4x4 matrix in GLSL. */
257   int users;
258 } GPUMaterialVolumeGrid;
259
260 ListBase GPU_material_attributes(GPUMaterial *material);
261 ListBase GPU_material_textures(GPUMaterial *material);
262 ListBase GPU_material_volume_grids(GPUMaterial *material);
263
264 typedef struct GPUUniformAttr {
265   struct GPUUniformAttr *next, *prev;
266
267   /* Meaningful part of the attribute set key. */
268   char name[64]; /* MAX_CUSTOMDATA_LAYER_NAME */
269   bool use_dupli;
270
271   /* Helper fields used by code generation. */
272   short id;
273   int users;
274 } GPUUniformAttr;
275
276 typedef struct GPUUniformAttrList {
277   ListBase list; /* GPUUniformAttr */
278
279   /* List length and hash code precomputed for fast lookup and comparison. */
280   unsigned int count, hash_code;
281 } GPUUniformAttrList;
282
283 GPUUniformAttrList *GPU_material_uniform_attributes(GPUMaterial *material);
284
285 struct GHash *GPU_uniform_attr_list_hash_new(const char *info);
286 void GPU_uniform_attr_list_copy(GPUUniformAttrList *dest, GPUUniformAttrList *src);
287 void GPU_uniform_attr_list_free(GPUUniformAttrList *set);
288
289 #ifdef __cplusplus
290 }
291 #endif