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,
65  char *type, 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  da_init(sv->default_val);
80 }
81 
82 static inline void shader_var_free(struct shader_var *sv)
83 {
84  bfree(sv->type);
85  bfree(sv->name);
86  bfree(sv->mapping);
87  da_free(sv->default_val);
88 }
89 
90 /* ------------------------------------------------------------------------- */
91 
93  char *name;
94  DARRAY(char*) states;
95  DARRAY(char*) values;
96 };
97 
98 static inline void shader_sampler_init(struct shader_sampler *ss)
99 {
100  memset(ss, 0, sizeof(struct shader_sampler));
101 }
102 
103 static inline void shader_sampler_free(struct shader_sampler *ss)
104 {
105  size_t i;
106  for (i = 0; i < ss->states.num; i++)
107  bfree(ss->states.array[i]);
108  for (i = 0; i < ss->values.num; i++)
109  bfree(ss->values.array[i]);
110 
111  bfree(ss->name);
112  da_free(ss->states);
113  da_free(ss->values);
114 }
115 
117  struct gs_sampler_info *info);
118 
119 /* ------------------------------------------------------------------------- */
120 
122  char *name;
123  DARRAY(struct shader_var) vars;
124 };
125 
126 static inline void shader_struct_init(struct shader_struct *ss)
127 {
128  memset(ss, 0, sizeof(struct shader_struct));
129 }
130 
131 static inline void shader_struct_free(struct shader_struct *ss)
132 {
133  size_t i;
134 
135  for (i = 0; i < ss->vars.num; i++)
136  shader_var_free(ss->vars.array+i);
137 
138  bfree(ss->name);
139  da_free(ss->vars);
140 }
141 
142 /* ------------------------------------------------------------------------- */
143 
144 struct shader_func {
145  char *name;
146  char *return_type;
147  char *mapping;
148  DARRAY(struct shader_var) params;
149 
150  struct cf_token *start, *end;
151 };
152 
153 static inline void shader_func_init(struct shader_func *sf,
154  char *return_type, char *name)
155 {
156  da_init(sf->params);
157 
158  sf->return_type = return_type;
159  sf->mapping = NULL;
160  sf->name = name;
161  sf->start = NULL;
162  sf->end = NULL;
163 }
164 
165 static inline void shader_func_free(struct shader_func *sf)
166 {
167  size_t i;
168 
169  for (i = 0; i < sf->params.num; i++)
170  shader_var_free(sf->params.array+i);
171 
172  bfree(sf->name);
173  bfree(sf->return_type);
174  bfree(sf->mapping);
175  da_free(sf->params);
176 }
177 
178 /* ------------------------------------------------------------------------- */
179 
181  struct cf_parser cfp;
182 
183  DARRAY(struct shader_var) params;
184  DARRAY(struct shader_struct) structs;
185  DARRAY(struct shader_sampler) samplers;
186  DARRAY(struct shader_func) funcs;
187 };
188 
189 static inline void shader_parser_init(struct shader_parser *sp)
190 {
191  cf_parser_init(&sp->cfp);
192 
193  da_init(sp->params);
194  da_init(sp->structs);
195  da_init(sp->samplers);
196  da_init(sp->funcs);
197 }
198 
199 static inline void shader_parser_free(struct shader_parser *sp)
200 {
201  size_t i;
202 
203  for (i = 0; i < sp->params.num; i++)
204  shader_var_free(sp->params.array+i);
205  for (i = 0; i < sp->structs.num; i++)
206  shader_struct_free(sp->structs.array+i);
207  for (i = 0; i < sp->samplers.num; i++)
208  shader_sampler_free(sp->samplers.array+i);
209  for (i = 0; i < sp->funcs.num; i++)
210  shader_func_free(sp->funcs.array+i);
211 
212  cf_parser_free(&sp->cfp);
213  da_free(sp->params);
214  da_free(sp->structs);
215  da_free(sp->samplers);
216  da_free(sp->funcs);
217 }
218 
219 EXPORT bool shader_parse(struct shader_parser *sp, const char *shader,
220  const char *file);
221 
222 static inline char *shader_parser_geterrors(struct shader_parser *sp)
223 {
225 }
226 
227 static inline struct shader_var *shader_parser_getparam(
228  struct shader_parser *sp, const char *param_name)
229 {
230  size_t i;
231  for (i = 0; i < sp->params.num; i++) {
232  struct shader_var *param = sp->params.array+i;
233  if (strcmp(param->name, param_name) == 0)
234  return param;
235  }
236 
237  return NULL;
238 }
239 
240 static inline struct shader_struct *shader_parser_getstruct(
241  struct shader_parser *sp, const char *struct_name)
242 {
243  size_t i;
244  for (i = 0; i < sp->structs.num; i++) {
245  struct shader_struct *st = sp->structs.array+i;
246  if (strcmp(st->name, struct_name) == 0)
247  return st;
248  }
249 
250  return NULL;
251 }
252 
253 static inline struct shader_sampler *shader_parser_getsampler(
254  struct shader_parser *sp, const char *sampler_name)
255 {
256  size_t i;
257  for (i = 0; i < sp->samplers.num; i++) {
258  struct shader_sampler *sampler = sp->samplers.array+i;
259  if (strcmp(sampler->name, sampler_name) == 0)
260  return sampler;
261  }
262 
263  return NULL;
264 }
265 
266 static inline struct shader_func *shader_parser_getfunc(
267  struct shader_parser *sp, const char *func_name)
268 {
269  size_t i;
270  for (i = 0; i < sp->funcs.num; i++) {
271  struct shader_func *func = sp->funcs.array+i;
272  if (strcmp(func->name, func_name) == 0)
273  return func;
274  }
275 
276  return NULL;
277 }
278 
279 #ifdef __cplusplus
280 }
281 #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:93
int array_count
Definition: shader-parser.h:53
char * return_type
Definition: shader-parser.h:146
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:147
char * name
Definition: shader-parser.h:122
DARRAY(struct shader_var) params
Definition: cf-lexer.h:47
struct cf_parser cfp
Definition: shader-parser.h:181
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:121
Definition: shader-parser.h:92
struct cf_token * end
Definition: shader-parser.h:150
gs_shader_param_type
Definition: graphics.h:280
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:145
Definition: shader-parser.h:144
Definition: shader-parser.h:48
struct cf_token * start
Definition: shader-parser.h:150
#define da_free(v)
Definition: darray.h:458
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:456
gs_address_mode
Definition: graphics.h:158
Definition: shader-parser.h:180
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