Cleanup: comment line length (editors)
[blender.git] / source / blender / gpu / intern / gpu_codegen.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Brecht Van Lommel.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/gpu/intern/gpu_codegen.h
29  *  \ingroup gpu
30  */
31
32
33 #ifndef __GPU_CODEGEN_H__
34 #define __GPU_CODEGEN_H__
35
36 #include "DNA_customdata_types.h"
37 #include "DNA_listBase.h"
38 #include "GPU_material.h"
39 #include "GPU_glew.h"
40
41 struct ListBase;
42 struct GPUShader;
43 struct GPUOutput;
44 struct GPUNode;
45 struct GPUVertexAttribs;
46 struct PreviewImage;
47
48 /* Pass Generation
49  * - Takes a list of nodes and a desired output, and makes a pass. This
50  *   will take ownership of the nodes and free them early if unused or
51  *   at the end if used.
52  */
53
54 typedef enum GPUDataSource {
55         GPU_SOURCE_VEC_UNIFORM,
56         GPU_SOURCE_BUILTIN,
57         GPU_SOURCE_OPENGL_BUILTIN,
58         GPU_SOURCE_TEX_PIXEL,
59         GPU_SOURCE_TEX,
60         GPU_SOURCE_ATTRIB
61 } GPUDataSource;
62
63 typedef enum {
64         GPU_NODE_LINK_IMAGE_NONE = 0,
65         GPU_NODE_LINK_IMAGE_BLENDER = 1,
66         GPU_NODE_LINK_IMAGE_PREVIEW = 2,
67         GPU_NODE_LINK_IMAGE_CUBE_MAP = 3
68 } GPUNodeLinkImage;
69
70 struct GPUNode {
71         struct GPUNode *next, *prev;
72
73         const char *name;
74
75         /* Internal flag to mark nodes during pruning */
76         bool tag;
77
78         ListBase inputs;
79         ListBase outputs;
80 };
81
82 struct GPUNodeLink {
83         GPUNodeStack *socket;
84
85         CustomDataType attribtype;
86         const char *attribname;
87
88         GPUNodeLinkImage image;
89         bool image_isdata;
90
91         bool texture;
92         int texturesize;
93
94         void *ptr1, *ptr2;
95
96         bool dynamic;
97         GPUDynamicType dynamictype;
98
99         GPUType type;
100
101         /* Refcount */
102         int users;
103
104         struct GPUTexture *dynamictex;
105
106         GPUBuiltin builtin;
107         GPUOpenGLBuiltin oglbuiltin;
108
109         struct GPUOutput *output;
110 };
111
112 typedef struct GPUOutput {
113         struct GPUOutput *next, *prev;
114
115         GPUNode *node;
116         GPUType type;      /* data type = length of vector/matrix */
117         GPUNodeLink *link; /* output link */
118         int id;            /* unique id as created by code generator */
119 } GPUOutput;
120
121 typedef struct GPUInput {
122         struct GPUInput *next, *prev;
123
124         GPUNode *node;
125
126         GPUType type;                /* datatype */
127         GPUDataSource source;        /* data source */
128
129         int id;                      /* unique id as created by code generator */
130         int texid;                   /* number for multitexture, starting from zero */
131         int attribid;                /* id for vertex attributes */
132         bool bindtex;                /* input is responsible for binding the texture? */
133         bool definetex;              /* input is responsible for defining the pixel? */
134         int textarget;               /* GL texture target, e.g. GL_TEXTURE_2D */
135         GPUType textype;             /* datatype */
136
137         struct Image *ima;           /* image */
138         struct ImageUser *iuser;     /* image user */
139         struct PreviewImage *prv;    /* preview images & icons */
140         bool image_isdata;           /* image does not contain color data */
141         float *dynamicvec;           /* vector data in case it is dynamic */
142         GPUDynamicType dynamictype;  /* origin of the dynamic uniform */
143         void *dynamicdata;           /* data source of the dynamic uniform */
144         struct GPUTexture *tex;      /* input texture, only set at runtime */
145         int shaderloc;               /* id from opengl */
146         char shadername[32];         /* name in shader */
147
148         float vec[16];               /* vector data */
149         GPUNodeLink *link;
150         bool dynamictex;             /* dynamic? */
151         CustomDataType attribtype;   /* attribute type */
152         char attribname[MAX_CUSTOMDATA_LAYER_NAME]; /* attribute name */
153         int attribfirst;             /* this is the first one that is bound */
154         GPUBuiltin builtin;          /* builtin uniform */
155         GPUOpenGLBuiltin oglbuiltin; /* opengl built in varying */
156 } GPUInput;
157
158 struct GPUPass {
159         struct GPUPass *next, *prev;
160
161         ListBase inputs;
162         struct GPUOutput *output;
163         struct GPUShader *shader;
164         char *fragmentcode;
165         char *geometrycode;
166         char *vertexcode;
167         const char *libcode;
168 };
169
170
171 typedef struct GPUPass GPUPass;
172
173 GPUPass *GPU_generate_pass(ListBase *nodes, struct GPUNodeLink *outlink,
174                            struct GPUVertexAttribs *attribs, int *builtin,
175                            const GPUMatType type, const char *name,
176                            const bool use_opensubdiv,
177                            const bool use_new_shading);
178
179 struct GPUShader *GPU_pass_shader(GPUPass *pass);
180
181 void GPU_pass_bind(GPUPass *pass, double time, int mipmap);
182 void GPU_pass_update_uniforms(GPUPass *pass);
183 void GPU_pass_unbind(GPUPass *pass);
184
185 void GPU_pass_free(GPUPass *pass);
186 void GPU_pass_free_nodes(ListBase *nodes);
187
188 void gpu_codegen_init(void);
189 void gpu_codegen_exit(void);
190
191 /* Material calls */
192
193 const char *GPU_builtin_name(GPUBuiltin builtin);
194 void gpu_material_add_node(struct GPUMaterial *material, struct GPUNode *node);
195 int GPU_link_changed(struct GPUNodeLink *link);
196
197 #endif