c6ed2e3f837d028c2f87167b9e25d762b6374d91
[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 } GPUNodeLinkImage;
68
69 struct GPUNode {
70         struct GPUNode *next, *prev;
71
72         const char *name;
73
74         /* Internal flag to mark nodes during pruning */
75         bool tag;
76
77         ListBase inputs;
78         ListBase outputs;
79 };
80
81 struct GPUNodeLink {
82         GPUNodeStack *socket;
83
84         CustomDataType attribtype;
85         const char *attribname;
86
87         GPUNodeLinkImage image;
88         bool image_isdata;
89
90         bool texture;
91         int texturesize;
92
93         void *ptr1, *ptr2;
94
95         bool dynamic;
96         GPUDynamicType dynamictype;
97
98         GPUType type;
99
100         /* Refcount */
101         int users;
102
103         struct GPUTexture *dynamictex;
104
105         GPUBuiltin builtin;
106         GPUOpenGLBuiltin oglbuiltin;
107
108         struct GPUOutput *output;
109 };
110
111 typedef struct GPUOutput {
112         struct GPUOutput *next, *prev;
113
114         GPUNode *node;
115         GPUType type;      /* data type = length of vector/matrix */
116         GPUNodeLink *link; /* output link */
117         int id;            /* unique id as created by code generator */
118 } GPUOutput;
119
120 typedef struct GPUInput {
121         struct GPUInput *next, *prev;
122
123         GPUNode *node;
124
125         GPUType type;                /* datatype */
126         GPUDataSource source;        /* data source */
127
128         int id;                      /* unique id as created by code generator */
129         int texid;                   /* number for multitexture, starting from zero */
130         int attribid;                /* id for vertex attributes */
131         bool bindtex;                /* input is responsible for binding the texture? */
132         bool definetex;              /* input is responsible for defining the pixel? */
133         int textarget;               /* GL texture target, e.g. GL_TEXTURE_2D */
134         GPUType textype;             /* datatype */
135
136         struct Image *ima;           /* image */
137         struct ImageUser *iuser;     /* image user */
138         struct PreviewImage *prv;    /* preview images & icons */
139         bool image_isdata;           /* image does not contain color data */
140         float *dynamicvec;           /* vector data in case it is dynamic */
141         GPUDynamicType dynamictype;  /* origin of the dynamic uniform */
142         void *dynamicdata;           /* data source of the dynamic uniform */
143         struct GPUTexture *tex;      /* input texture, only set at runtime */
144         int shaderloc;               /* id from opengl */
145         char shadername[32];         /* name in shader */
146
147         float vec[16];               /* vector data */
148         GPUNodeLink *link;
149         bool dynamictex;             /* dynamic? */
150         CustomDataType attribtype;   /* attribute type */
151         char attribname[MAX_CUSTOMDATA_LAYER_NAME]; /* attribute name */
152         int attribfirst;             /* this is the first one that is bound */
153         GPUBuiltin builtin;          /* builtin uniform */
154         GPUOpenGLBuiltin oglbuiltin; /* opengl built in varying */
155 } GPUInput;
156
157 struct GPUPass {
158         struct GPUPass *next, *prev;
159
160         ListBase inputs;
161         struct GPUOutput *output;
162         struct GPUShader *shader;
163         char *fragmentcode;
164         char *vertexcode;
165         const char *libcode;
166 };
167
168
169 typedef struct GPUPass GPUPass;
170
171 GPUPass *GPU_generate_pass(ListBase *nodes, struct GPUNodeLink *outlink,
172                            struct GPUVertexAttribs *attribs, int *builtin,
173                            const GPUMatType type, const char *name);
174
175 struct GPUShader *GPU_pass_shader(GPUPass *pass);
176
177 void GPU_pass_bind(GPUPass *pass, double time, int mipmap);
178 void GPU_pass_update_uniforms(GPUPass *pass);
179 void GPU_pass_unbind(GPUPass *pass);
180
181 void GPU_pass_free(GPUPass *pass);
182
183 void gpu_codegen_init(void);
184 void gpu_codegen_exit(void);
185
186 /* Material calls */
187
188 const char *GPU_builtin_name(GPUBuiltin builtin);
189 void gpu_material_add_node(struct GPUMaterial *material, struct GPUNode *node);
190 int GPU_link_changed(struct GPUNodeLink *link);
191
192 #endif
193