Open Broadcaster Software
Free, open source software for live streaming and recording
shader-parser.h
Go to the documentation of this file.
1 /******************************************************************************
2  Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
3 
4  This program is free software: you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation, either version 2 of the License, or
7  (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, see <http://www.gnu.org/licenses/>.
16 ******************************************************************************/
17 
18 #pragma once
19 
20 #include "../util/cf-parser.h"
21 #include "graphics.h"
22 
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26 
28 EXPORT enum gs_sample_filter get_sample_filter(const char *filter);
29 EXPORT enum gs_address_mode get_address_mode(const char *address_mode);
30 
31 /*
32  * Shader Parser
33  *
34  * Parses a shader and extracts data such as shader constants, samplers,
35  * and vertex input information. Also allows the reformatting of shaders for
36  * different libraries. This is usually used only by graphics libraries,
37  */
38 
46 };
47 
48 struct shader_var {
49  char *type;
50  char *name;
51  char *mapping;
54  size_t gl_sampler_id; /* optional: used/parsed by GL */
55 
56  DARRAY(uint8_t) default_val;
57 };
58 
59 static inline void shader_var_init(struct shader_var *sv)
60 {
61  memset(sv, 0, sizeof(struct shader_var));
62 }
63 
64 static inline void shader_var_init_param(struct shader_var *sv, char *type,
65  char *name, bool is_uniform,
66  bool is_const)
67 {
68  if (is_uniform)
70  else if (is_const)
72  else
74 
75  sv->type = type;
76  sv->name = name;
77  sv->mapping = NULL;
78  sv->array_count = 0;
79  sv->gl_sampler_id = (size_t)-1;
80  da_init(sv->default_val);
81 }
82 
83 static inline void shader_var_free(struct shader_var *sv)
84 {
85  bfree(sv->type);
86  bfree(sv->name);
87  bfree(sv->mapping);
88  da_free(sv->default_val);
89 }
90 
91 /* ------------------------------------------------------------------------- */
92 
94  char *name;
95  DARRAY(char *) states;
96  DARRAY(char *) values;
97 };
98 
99 static inline void shader_sampler_init(struct shader_sampler *ss)
100 {
101  memset(ss, 0, sizeof(struct shader_sampler));
102 }
103 
104 static inline void shader_sampler_free(struct shader_sampler *ss)
105 {
106  size_t i;
107  for (i = 0; i < ss->states.num; i++)
108  bfree(ss->states.array[i]);
109  for (i = 0; i < ss->values.num; i++)
110  bfree(ss->values.array[i]);
111 
112  bfree(ss->name);
113  da_free(ss->states);
114  da_free(ss->values);
115 }
116 
118  struct gs_sampler_info *info);
119 
120 /* ------------------------------------------------------------------------- */
121 
123  char *name;
124  DARRAY(struct shader_var) vars;
125 };
126 
127 static inline void shader_struct_init(struct shader_struct *ss)
128 {
129  memset(ss, 0, sizeof(struct shader_struct));
130 }
131 
132 static inline void shader_struct_free(struct shader_struct *ss)
133 {
134  size_t i;
135 
136  for (i = 0; i < ss->vars.num; i++)
137  shader_var_free(ss->vars.array + i);
138 
139  bfree(ss->name);
140  da_free(ss->vars);
141 }
142 
143 /* ------------------------------------------------------------------------- */
144 
145 struct shader_func {
146  char *name;
147  char *return_type;
148  char *mapping;
149  DARRAY(struct shader_var) params;
150 
151  struct cf_token *start, *end;
152 };
153 
154 static inline void shader_func_init(struct shader_func *sf, char *return_type,
155  char *name)
156 {
157  da_init(sf->params);
158 
159  sf->return_type = return_type;
160  sf->mapping = NULL;
161  sf->name = name;
162  sf->start = NULL;
163  sf->end = NULL;
164 }
165 
166 static inline void shader_func_free(struct shader_func *sf)
167 {
168  size_t i;
169 
170  for (i = 0; i < sf->params.num; i++)
171  shader_var_free(sf->params.array + i);
172 
173  bfree(sf->name);
174  bfree(sf->return_type);
175  bfree(sf->mapping);
176  da_free(sf->params);
177 }
178 
179 /* ------------------------------------------------------------------------- */
180 
182  struct cf_parser cfp;
183 
184  DARRAY(struct shader_var) params;
185  DARRAY(struct shader_struct) structs;
186  DARRAY(struct shader_sampler) samplers;
187  DARRAY(struct shader_func) funcs;
188 };
189 
190 static inline void shader_parser_init(struct shader_parser *sp)
191 {
192  cf_parser_init(&sp->cfp);
193 
194  da_init(sp->params);
195  da_init(sp->structs);
196  da_init(sp->samplers);
197  da_init(sp->funcs);
198 }
199 
200 static inline void shader_parser_free(struct shader_parser *sp)
201 {
202  size_t i;
203 
204  for (i = 0; i < sp->params.num; i++)
205  shader_var_free(sp->params.array + i);
206  for (i = 0; i < sp->structs.num; i++)
207  shader_struct_free(sp->structs.array + i);
208  for (i = 0; i < sp->samplers.num; i++)
209  shader_sampler_free(sp->samplers.array + i);
210  for (i = 0; i < sp->funcs.num; i++)
211  shader_func_free(sp->funcs.array + i);
212 
213  cf_parser_free(&sp->cfp);
214  da_free(sp->params);
215  da_free(sp->structs);
216  da_free(sp->samplers);
217  da_free(sp->funcs);
218 }
219 
220 EXPORT bool shader_parse(struct shader_parser *sp, const char *shader,
221  const char *file);
222 
223 static inline char *shader_parser_geterrors(struct shader_parser *sp)
224 {
226 }
227 
228 static inline struct shader_var *
229 shader_parser_getparam(struct shader_parser *sp, const char *param_name)
230 {
231  size_t i;
232  for (i = 0; i < sp->params.num; i++) {
233  struct shader_var *param = sp->params.array + i;
234  if (strcmp(param->name, param_name) == 0)
235  return param;
236  }
237 
238  return NULL;
239 }
240 
241 static inline struct shader_struct *
242 shader_parser_getstruct(struct shader_parser *sp, const char *struct_name)
243 {
244  size_t i;
245  for (i = 0; i < sp->structs.num; i++) {
246  struct shader_struct *st = sp->structs.array + i;
247  if (strcmp(st->name, struct_name) == 0)
248  return st;
249  }
250 
251  return NULL;
252 }
253 
254 static inline struct shader_sampler *
255 shader_parser_getsampler(struct shader_parser *sp, const char *sampler_name)
256 {
257  size_t i;
258  for (i = 0; i < sp->samplers.num; i++) {
259  struct shader_sampler *sampler = sp->samplers.array + i;
260  if (strcmp(sampler->name, sampler_name) == 0)
261  return sampler;
262  }
263 
264  return NULL;
265 }
266 
267 static inline struct shader_func *
268 shader_parser_getfunc(struct shader_parser *sp, const char *func_name)
269 {
270  size_t i;
271  for (i = 0; i < sp->funcs.num; i++) {
272  struct shader_func *func = sp->funcs.array + i;
273  if (strcmp(func->name, func_name) == 0)
274  return func;
275  }
276 
277  return NULL;
278 }
279 
280 #ifdef __cplusplus
281 }
282 #endif
EXPORT char * error_data_buildstring(struct error_data *ed)
DARRAY(struct shader_var) vars
Definition: graphics.h:217
gs_sample_filter
Definition: graphics.h:146
char * name
Definition: shader-parser.h:94
int array_count
Definition: shader-parser.h:53
char * return_type
Definition: shader-parser.h:147
enum shader_var_type var_type
Definition: shader-parser.h:52
shader_var_type
Definition: shader-parser.h:39
char * mapping
Definition: shader-parser.h:148
char * name
Definition: shader-parser.h:123
DARRAY(struct shader_var) params
Definition: cf-lexer.h:47
struct cf_parser cfp
Definition: shader-parser.h:182
unsigned char uint8_t
Definition: vc_stdint.h:27
char * type
Definition: shader-parser.h:49
EXPORT void shader_sampler_convert(struct shader_sampler *ss, struct gs_sampler_info *info)
#define EXPORT
Definition: c99defs.h:49
Definition: shader-parser.h:45
Definition: shader-parser.h:122
Definition: shader-parser.h:93
struct cf_token * end
Definition: shader-parser.h:151
gs_shader_param_type
Definition: graphics.h:283
EXPORT enum gs_shader_param_type get_shader_param_type(const char *type)
Definition: shader-parser.h:42
EXPORT bool shader_parse(struct shader_parser *sp, const char *shader, const char *file)
char * name
Definition: shader-parser.h:146
Definition: shader-parser.h:145
Definition: shader-parser.h:48
struct cf_token * start
Definition: shader-parser.h:151
#define da_free(v)
Definition: darray.h:467
DARRAY(char *) states
EXPORT enum gs_sample_filter get_sample_filter(const char *filter)
Definition: shader-parser.h:44
struct error_data error_list
Definition: cf-parser.h:43
char * mapping
Definition: shader-parser.h:51
char * name
Definition: shader-parser.h:50
Definition: shader-parser.h:41
DARRAY(uint8_t) default_val
EXPORT enum gs_address_mode get_address_mode(const char *address_mode)
Definition: cf-parser.h:40
Definition: shader-parser.h:40
#define da_init(v)
Definition: darray.h:465
gs_address_mode
Definition: graphics.h:158
Definition: shader-parser.h:181
size_t gl_sampler_id
Definition: shader-parser.h:54
EXPORT void bfree(void *ptr)
Definition: shader-parser.h:43
DARRAY(struct shader_var) params