Fix build errors
[blender.git] / source / blender / gpu / intern / gpu_codegen.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
25 #ifndef __GPU_CODEGEN_H__
26 #define __GPU_CODEGEN_H__
27
28 #include "DNA_customdata_types.h"
29 #include "DNA_listBase.h"
30 #include "GPU_material.h"
31 #include "GPU_glew.h"
32
33 struct GPUNode;
34 struct GPUOutput;
35 struct GPUShader;
36 struct GPUVertAttrLayers;
37 struct ListBase;
38 struct PreviewImage;
39
40 /* Pass Generation
41  * - Takes a list of nodes and a desired output, and makes a pass. This
42  *   will take ownership of the nodes and free them early if unused or
43  *   at the end if used.
44  */
45
46 typedef enum eGPUDataSource {
47         GPU_SOURCE_OUTPUT,
48         GPU_SOURCE_CONSTANT,
49         GPU_SOURCE_UNIFORM,
50         GPU_SOURCE_ATTR,
51         GPU_SOURCE_BUILTIN,
52         GPU_SOURCE_STRUCT,
53         GPU_SOURCE_TEX,
54 } eGPUDataSource;
55
56 typedef enum {
57         GPU_NODE_LINK_NONE = 0,
58         GPU_NODE_LINK_ATTR,
59         GPU_NODE_LINK_BUILTIN,
60         GPU_NODE_LINK_COLORBAND,
61         GPU_NODE_LINK_CONSTANT,
62         GPU_NODE_LINK_IMAGE_BLENDER,
63         GPU_NODE_LINK_OUTPUT,
64         GPU_NODE_LINK_UNIFORM,
65 } GPUNodeLinkType;
66
67 struct GPUNode {
68         struct GPUNode *next, *prev;
69
70         const char *name;
71
72         /* Internal flag to mark nodes during pruning */
73         bool tag;
74
75         ListBase inputs;
76         ListBase outputs;
77 };
78
79 struct GPUNodeLink {
80         GPUNodeStack *socket;
81
82         GPUNodeLinkType link_type;
83         int users; /* Refcount */
84
85         union {
86                 /* GPU_NODE_LINK_CONSTANT | GPU_NODE_LINK_UNIFORM */
87                 float *data;
88                 /* GPU_NODE_LINK_BUILTIN */
89                 eGPUBuiltin builtin;
90                 /* GPU_NODE_LINK_COLORBAND */
91                 struct GPUTexture **coba;
92                 /* GPU_NODE_LINK_OUTPUT */
93                 struct GPUOutput *output;
94                 /* GPU_NODE_LINK_ATTR */
95                 struct {
96                         const char *attr_name;
97                         CustomDataType attr_type;
98                 };
99                 /* GPU_NODE_LINK_IMAGE_BLENDER */
100                 struct {
101                         struct Image *ima;
102                         struct ImageUser *iuser;
103                         bool image_isdata;
104                 };
105         };
106 };
107
108 typedef struct GPUOutput {
109         struct GPUOutput *next, *prev;
110
111         GPUNode *node;
112         eGPUType type;      /* data type = length of vector/matrix */
113         GPUNodeLink *link; /* output link */
114         int id;            /* unique id as created by code generator */
115 } GPUOutput;
116
117 typedef struct GPUInput {
118         struct GPUInput *next, *prev;
119
120         GPUNode *node;
121         eGPUType type;                /* datatype */
122         GPUNodeLink *link;
123         int id;                      /* unique id as created by code generator */
124
125         eGPUDataSource source;        /* data source */
126
127         int shaderloc;               /* id from opengl */
128         char shadername[32];         /* name in shader */
129
130         /* Content based on eGPUDataSource */
131         union {
132                 /* GPU_SOURCE_CONSTANT | GPU_SOURCE_UNIFORM */
133                 float vec[16];                   /* vector data */
134                 /* GPU_SOURCE_BUILTIN */
135                 eGPUBuiltin builtin;              /* builtin uniform */
136                 /* GPU_SOURCE_TEX */
137                 struct {
138                         struct GPUTexture **coba;    /* input texture, only set at runtime */
139                         struct Image *ima;           /* image */
140                         struct ImageUser *iuser;     /* image user */
141                         bool image_isdata;           /* image does not contain color data */
142                         bool bindtex;                /* input is responsible for binding the texture? */
143                         int texid;                   /* number for multitexture, starting from zero */
144                         eGPUType textype;             /* texture type (2D, 1D Array ...) */
145                 };
146                 /* GPU_SOURCE_ATTR */
147                 struct {
148                         /** Attribute name. */
149                         char attr_name[MAX_CUSTOMDATA_LAYER_NAME];
150                         /** ID for vertex attributes. */
151                         int attr_id;
152                         /** This is the first one that is bound. */
153                         bool attr_first;
154                         /** Attribute type. */
155                         CustomDataType attr_type;
156                 };
157         };
158 } GPUInput;
159
160 struct GPUPass {
161         struct GPUPass *next;
162
163         struct GPUShader *shader;
164         char *fragmentcode;
165         char *geometrycode;
166         char *vertexcode;
167         char *defines;
168         uint refcount;               /* Orphaned GPUPasses gets freed by the garbage collector. */
169         uint32_t hash;               /* Identity hash generated from all GLSL code. */
170         bool compiled;               /* Did we already tried to compile the attached GPUShader. */
171 };
172
173 typedef struct GPUPass GPUPass;
174
175 GPUPass *GPU_generate_pass(
176         GPUMaterial *material,
177         GPUNodeLink *frag_outlink, struct GPUVertAttrLayers *attrs,
178         ListBase *nodes, int *builtins,
179         const char *vert_code, const char *geom_code,
180         const char *frag_lib, const char *defines);
181
182 struct GPUShader *GPU_pass_shader_get(GPUPass *pass);
183
184 void GPU_nodes_extract_dynamic_inputs(struct GPUShader *shader, ListBase *inputs, ListBase *nodes);
185 void GPU_nodes_get_vertex_attrs(ListBase *nodes, struct GPUVertAttrLayers *attrs);
186 void GPU_nodes_prune(ListBase *nodes, struct GPUNodeLink *outlink);
187
188 void GPU_pass_compile(GPUPass *pass, const char *shname);
189 void GPU_pass_release(GPUPass *pass);
190 void GPU_pass_free_nodes(ListBase *nodes);
191
192 void GPU_inputs_free(ListBase *inputs);
193
194 void gpu_codegen_init(void);
195 void gpu_codegen_exit(void);
196
197 /* Material calls */
198
199 const char *GPU_builtin_name(eGPUBuiltin builtin);
200 void gpu_material_add_node(struct GPUMaterial *material, struct GPUNode *node);
201 struct GPUTexture **gpu_material_ramp_texture_row_set(GPUMaterial *mat, int size, float *pixels, float *row);
202
203 #endif