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