noobs 0.0.6

package/include/graphics/bounds.h

@@ -0,0 +1,108 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "math-defs.h"
+#include "vec3.h"
+
+/*
+ * Axis Aligned Bounding Box
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BOUNDS_OUTSIDE 1
+#define BOUNDS_INSIDE 2
+#define BOUNDS_PARTIAL 3
+
+struct bounds {
+	struct vec3 min, max;
+};
+
+static inline void bounds_zero(struct bounds *dst)
+{
+	vec3_zero(&dst->min);
+	vec3_zero(&dst->max);
+}
+
+static inline void bounds_copy(struct bounds *dst, const struct bounds *b)
+{
+	vec3_copy(&dst->min, &b->min);
+	vec3_copy(&dst->max, &b->max);
+}
+
+EXPORT void bounds_move(struct bounds *dst, const struct bounds *b, const struct vec3 *v);
+
+EXPORT void bounds_scale(struct bounds *dst, const struct bounds *b, const struct vec3 *v);
+
+EXPORT void bounds_merge(struct bounds *dst, const struct bounds *b1, const struct bounds *b2);
+EXPORT void bounds_merge_point(struct bounds *dst, const struct bounds *b, const struct vec3 *v);
+
+EXPORT void bounds_get_point(struct vec3 *dst, const struct bounds *b, unsigned int i);
+EXPORT void bounds_get_center(struct vec3 *dst, const struct bounds *b);
+
+/**
+ * Note: transforms as OBB, then converts back to AABB, which can result in
+ * the actual size becoming larger than it originally was.
+ */
+EXPORT void bounds_transform(struct bounds *dst, const struct bounds *b, const struct matrix4 *m);
+EXPORT void bounds_transform3x4(struct bounds *dst, const struct bounds *b, const struct matrix3 *m);
+
+EXPORT bool bounds_intersection_ray(const struct bounds *b, const struct vec3 *orig, const struct vec3 *dir, float *t);
+EXPORT bool bounds_intersection_line(const struct bounds *b, const struct vec3 *p1, const struct vec3 *p2, float *t);
+
+EXPORT bool bounds_plane_test(const struct bounds *b, const struct plane *p);
+EXPORT bool bounds_under_plane(const struct bounds *b, const struct plane *p);
+
+static inline bool bounds_inside(const struct bounds *b, const struct bounds *test)
+{
+	return test->min.x >= b->min.x && test->min.y >= b->min.y && test->min.z >= b->min.z &&
+	       test->max.x <= b->max.x && test->max.y <= b->max.y && test->max.z <= b->max.z;
+}
+
+static inline bool bounds_vec3_inside(const struct bounds *b, const struct vec3 *v)
+{
+	return v->x >= (b->min.x - EPSILON) && v->x <= (b->max.x + EPSILON) && v->y >= (b->min.y - EPSILON) &&
+	       v->y <= (b->max.y + EPSILON) && v->z >= (b->min.z - EPSILON) && v->z <= (b->max.z + EPSILON);
+}
+
+EXPORT bool bounds_intersects(const struct bounds *b, const struct bounds *test, float epsilon);
+EXPORT bool bounds_intersects_obb(const struct bounds *b, const struct bounds *test, const struct matrix4 *m,
+				  float epsilon);
+EXPORT bool bounds_intersects_obb3x4(const struct bounds *b, const struct bounds *test, const struct matrix3 *m,
+				     float epsilon);
+
+static inline bool bounds_intersects_ray(const struct bounds *b, const struct vec3 *orig, const struct vec3 *dir)
+{
+	float t;
+	return bounds_intersection_ray(b, orig, dir, &t);
+}
+
+static inline bool bounds_intersects_line(const struct bounds *b, const struct vec3 *p1, const struct vec3 *p2)
+{
+	float t;
+	return bounds_intersection_line(b, p1, p2, &t);
+}
+
+EXPORT float bounds_min_dist(const struct bounds *b, const struct plane *p);
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/device-exports.h

@@ -0,0 +1,177 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include <util/c99defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EXPORT const char *device_get_name(void);
+EXPORT const char *gpu_get_driver_version(void);
+EXPORT const char *gpu_get_renderer(void);
+EXPORT uint64_t gpu_get_dmem(void);
+EXPORT uint64_t gpu_get_smem(void);
+EXPORT int device_get_type(void);
+EXPORT bool device_enum_adapters(gs_device_t *device, bool (*callback)(void *param, const char *name, uint32_t id),
+				 void *param);
+EXPORT const char *device_preprocessor_name(void);
+EXPORT int device_create(gs_device_t **device, uint32_t adapter);
+EXPORT void device_destroy(gs_device_t *device);
+EXPORT void device_enter_context(gs_device_t *device);
+EXPORT void device_leave_context(gs_device_t *device);
+EXPORT void *device_get_device_obj(gs_device_t *device);
+EXPORT gs_swapchain_t *device_swapchain_create(gs_device_t *device, const struct gs_init_data *data);
+EXPORT void device_resize(gs_device_t *device, uint32_t x, uint32_t y);
+EXPORT enum gs_color_space device_get_color_space(gs_device_t *device);
+EXPORT void device_update_color_space(gs_device_t *device);
+EXPORT void device_get_size(const gs_device_t *device, uint32_t *x, uint32_t *y);
+EXPORT uint32_t device_get_width(const gs_device_t *device);
+EXPORT uint32_t device_get_height(const gs_device_t *device);
+EXPORT gs_texture_t *device_texture_create(gs_device_t *device, uint32_t width, uint32_t height,
+					   enum gs_color_format color_format, uint32_t levels, const uint8_t **data,
+					   uint32_t flags);
+EXPORT gs_texture_t *device_cubetexture_create(gs_device_t *device, uint32_t size, enum gs_color_format color_format,
+					       uint32_t levels, const uint8_t **data, uint32_t flags);
+EXPORT gs_texture_t *device_voltexture_create(gs_device_t *device, uint32_t width, uint32_t height, uint32_t depth,
+					      enum gs_color_format color_format, uint32_t levels,
+					      const uint8_t *const *data, uint32_t flags);
+EXPORT gs_zstencil_t *device_zstencil_create(gs_device_t *device, uint32_t width, uint32_t height,
+					     enum gs_zstencil_format format);
+EXPORT gs_stagesurf_t *device_stagesurface_create(gs_device_t *device, uint32_t width, uint32_t height,
+						  enum gs_color_format color_format);
+EXPORT gs_samplerstate_t *device_samplerstate_create(gs_device_t *device, const struct gs_sampler_info *info);
+EXPORT gs_shader_t *device_vertexshader_create(gs_device_t *device, const char *shader, const char *file,
+					       char **error_string);
+EXPORT gs_shader_t *device_pixelshader_create(gs_device_t *device, const char *shader, const char *file,
+					      char **error_string);
+EXPORT gs_vertbuffer_t *device_vertexbuffer_create(gs_device_t *device, struct gs_vb_data *data, uint32_t flags);
+EXPORT gs_indexbuffer_t *device_indexbuffer_create(gs_device_t *device, enum gs_index_type type, void *indices,
+						   size_t num, uint32_t flags);
+EXPORT gs_timer_t *device_timer_create(gs_device_t *device);
+EXPORT gs_timer_range_t *device_timer_range_create(gs_device_t *device);
+EXPORT enum gs_texture_type device_get_texture_type(const gs_texture_t *texture);
+EXPORT void device_load_vertexbuffer(gs_device_t *device, gs_vertbuffer_t *vertbuffer);
+EXPORT void device_load_indexbuffer(gs_device_t *device, gs_indexbuffer_t *indexbuffer);
+EXPORT void device_load_texture(gs_device_t *device, gs_texture_t *tex, int unit);
+EXPORT void device_load_texture_srgb(gs_device_t *device, gs_texture_t *tex, int unit);
+EXPORT void device_load_samplerstate(gs_device_t *device, gs_samplerstate_t *samplerstate, int unit);
+EXPORT void device_load_vertexshader(gs_device_t *device, gs_shader_t *vertshader);
+EXPORT void device_load_pixelshader(gs_device_t *device, gs_shader_t *pixelshader);
+EXPORT void device_load_default_samplerstate(gs_device_t *device, bool b_3d, int unit);
+EXPORT gs_shader_t *device_get_vertex_shader(const gs_device_t *device);
+EXPORT gs_shader_t *device_get_pixel_shader(const gs_device_t *device);
+EXPORT gs_texture_t *device_get_render_target(const gs_device_t *device);
+EXPORT gs_zstencil_t *device_get_zstencil_target(const gs_device_t *device);
+EXPORT void device_set_render_target(gs_device_t *device, gs_texture_t *tex, gs_zstencil_t *zstencil);
+EXPORT void device_set_render_target_with_color_space(gs_device_t *device, gs_texture_t *tex, gs_zstencil_t *zstencil,
+						      enum gs_color_space space);
+EXPORT void device_set_cube_render_target(gs_device_t *device, gs_texture_t *cubetex, int side,
+					  gs_zstencil_t *zstencil);
+EXPORT void device_enable_framebuffer_srgb(gs_device_t *device, bool enable);
+EXPORT bool device_framebuffer_srgb_enabled(gs_device_t *device);
+EXPORT void device_copy_texture(gs_device_t *device, gs_texture_t *dst, gs_texture_t *src);
+EXPORT void device_copy_texture_region(gs_device_t *device, gs_texture_t *dst, uint32_t dst_x, uint32_t dst_y,
+				       gs_texture_t *src, uint32_t src_x, uint32_t src_y, uint32_t src_w,
+				       uint32_t src_h);
+EXPORT void device_stage_texture(gs_device_t *device, gs_stagesurf_t *dst, gs_texture_t *src);
+EXPORT void device_begin_frame(gs_device_t *device);
+EXPORT void device_begin_scene(gs_device_t *device);
+EXPORT void device_draw(gs_device_t *device, enum gs_draw_mode draw_mode, uint32_t start_vert, uint32_t num_verts);
+EXPORT void device_end_scene(gs_device_t *device);
+EXPORT void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swapchain);
+EXPORT void device_clear(gs_device_t *device, uint32_t clear_flags, const struct vec4 *color, float depth,
+			 uint8_t stencil);
+EXPORT bool device_is_present_ready(gs_device_t *device);
+EXPORT void device_present(gs_device_t *device);
+EXPORT void device_flush(gs_device_t *device);
+EXPORT void device_set_cull_mode(gs_device_t *device, enum gs_cull_mode mode);
+EXPORT enum gs_cull_mode device_get_cull_mode(const gs_device_t *device);
+EXPORT void device_enable_blending(gs_device_t *device, bool enable);
+EXPORT void device_enable_depth_test(gs_device_t *device, bool enable);
+EXPORT void device_enable_stencil_test(gs_device_t *device, bool enable);
+EXPORT void device_enable_stencil_write(gs_device_t *device, bool enable);
+EXPORT void device_enable_color(gs_device_t *device, bool red, bool green, bool blue, bool alpha);
+EXPORT void device_blend_function(gs_device_t *device, enum gs_blend_type src, enum gs_blend_type dest);
+EXPORT void device_blend_function_separate(gs_device_t *device, enum gs_blend_type src_c, enum gs_blend_type dest_c,
+					   enum gs_blend_type src_a, enum gs_blend_type dest_a);
+EXPORT void device_blend_op(gs_device_t *device, enum gs_blend_op_type op);
+
+EXPORT void device_depth_function(gs_device_t *device, enum gs_depth_test test);
+EXPORT void device_stencil_function(gs_device_t *device, enum gs_stencil_side side, enum gs_depth_test test);
+EXPORT void device_stencil_op(gs_device_t *device, enum gs_stencil_side side, enum gs_stencil_op_type fail,
+			      enum gs_stencil_op_type zfail, enum gs_stencil_op_type zpass);
+EXPORT void device_set_viewport(gs_device_t *device, int x, int y, int width, int height);
+EXPORT void device_get_viewport(const gs_device_t *device, struct gs_rect *rect);
+EXPORT void device_set_scissor_rect(gs_device_t *device, const struct gs_rect *rect);
+EXPORT void device_ortho(gs_device_t *device, float left, float right, float top, float bottom, float znear,
+			 float zfar);
+EXPORT void device_frustum(gs_device_t *device, float left, float right, float top, float bottom, float znear,
+			   float zfar);
+EXPORT void device_projection_push(gs_device_t *device);
+EXPORT void device_projection_pop(gs_device_t *device);
+EXPORT void device_debug_marker_begin(gs_device_t *device, const char *markername, const float color[4]);
+EXPORT void device_debug_marker_end(gs_device_t *device);
+EXPORT bool device_is_monitor_hdr(gs_device_t *device, void *monitor);
+EXPORT bool device_shared_texture_available(void);
+EXPORT bool device_nv12_available(gs_device_t *device);
+EXPORT bool device_p010_available(gs_device_t *device);
+
+#ifdef __APPLE__
+EXPORT gs_texture_t *device_texture_create_from_iosurface(gs_device_t *device, void *iosurf);
+EXPORT gs_texture_t *device_texture_open_shared(gs_device_t *device, uint32_t handle);
+#endif
+
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__DragonFly__)
+
+EXPORT gs_texture_t *device_texture_create_from_dmabuf(gs_device_t *device, unsigned int width, unsigned int height,
+						       uint32_t drm_format, enum gs_color_format color_format,
+						       uint32_t n_planes, const int *fds, const uint32_t *strides,
+						       const uint32_t *offsets, const uint64_t *modifiers);
+
+EXPORT bool device_query_dmabuf_capabilities(gs_device_t *device, enum gs_dmabuf_flags *gs_dmabuf_flags,
+					     uint32_t **drm_formats, size_t *n_formats);
+
+EXPORT bool device_query_dmabuf_modifiers_for_format(gs_device_t *device, uint32_t drm_format, uint64_t **modifiers,
+						     size_t *n_modifiers);
+
+EXPORT gs_texture_t *device_texture_create_from_pixmap(gs_device_t *device, uint32_t width, uint32_t height,
+						       enum gs_color_format color_format, uint32_t target,
+						       void *pixmap);
+
+EXPORT bool device_query_sync_capabilities(gs_device_t *device);
+
+EXPORT gs_sync_t *device_sync_create(gs_device_t *device);
+
+EXPORT gs_sync_t *device_sync_create_from_syncobj_timeline_point(gs_device_t *device, int syncobj_fd,
+								 uint64_t timeline_point);
+
+EXPORT void device_sync_destroy(gs_device_t *device, gs_sync_t *sync);
+
+EXPORT bool device_sync_export_syncobj_timeline_point(gs_device_t *device, gs_sync_t *sync, int syncobj_fd,
+						      uint64_t timeline_point);
+
+EXPORT bool device_sync_signal_syncobj_timeline_point(gs_device_t *device, int syncobj_fd, uint64_t timeline_point);
+
+EXPORT bool device_sync_wait(gs_device_t *device, gs_sync_t *sync);
+#endif
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/effect-parser.h

@@ -0,0 +1,290 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "../util/darray.h"
+#include "../util/cf-parser.h"
+#include "graphics.h"
+#include "shader-parser.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct dstr;
+
+typedef DARRAY(struct ep_param) ep_param_array_t;
+typedef DARRAY(struct ep_var) ep_var_array_t;
+
+/*
+ * The effect parser takes an effect file and converts it into individual
+ * shaders for each technique's pass.  It automatically writes all dependent
+ * structures/functions/parameters to the shader and builds shader text for
+ * each shader component of each pass.
+ */
+
+/* ------------------------------------------------------------------------- */
+/* effect parser var data */
+
+enum ep_var_type { EP_VAR_NONE, EP_VAR_IN = EP_VAR_NONE, EP_VAR_INOUT, EP_VAR_OUT, EP_VAR_UNIFORM };
+
+struct ep_var {
+	char *type, *name, *mapping;
+	enum ep_var_type var_type;
+};
+
+static inline void ep_var_init(struct ep_var *epv)
+{
+	memset(epv, 0, sizeof(struct ep_var));
+}
+
+static inline void ep_var_free(struct ep_var *epv)
+{
+	bfree(epv->type);
+	bfree(epv->name);
+	bfree(epv->mapping);
+}
+
+/* ------------------------------------------------------------------------- */
+/* effect parser param data */
+
+struct ep_param {
+	char *type, *name;
+	DARRAY(uint8_t) default_val;
+	DARRAY(char *) properties;
+	struct gs_effect_param *param;
+	bool is_const, is_property, is_uniform, is_texture, written;
+	int writeorder, array_count;
+	ep_param_array_t annotations;
+};
+
+static inline void ep_param_init(struct ep_param *epp, char *type, char *name, bool is_property, bool is_const,
+				 bool is_uniform)
+{
+	epp->type = type;
+	epp->name = name;
+	epp->is_property = is_property;
+	epp->is_const = is_const;
+	epp->is_uniform = is_uniform;
+	epp->is_texture = (astrcmp_n(epp->type, "texture", 7) == 0);
+	epp->written = false;
+	epp->writeorder = false;
+	epp->array_count = 0;
+	da_init(epp->default_val);
+	da_init(epp->properties);
+	da_init(epp->annotations);
+}
+
+static inline void ep_param_free(struct ep_param *epp)
+{
+	bfree(epp->type);
+	bfree(epp->name);
+	da_free(epp->default_val);
+	da_free(epp->properties);
+
+	for (size_t i = 0; i < epp->annotations.num; i++)
+		ep_param_free(epp->annotations.array + i);
+	da_free(epp->annotations);
+}
+
+/* ------------------------------------------------------------------------- */
+/* effect parser struct data */
+
+struct ep_struct {
+	char *name;
+	ep_var_array_t vars; /* struct ep_var */
+	bool written;
+};
+
+static inline bool ep_struct_mapped(struct ep_struct *eps)
+{
+	if (eps->vars.num > 0)
+		return eps->vars.array[0].mapping != NULL;
+
+	return false;
+}
+
+static inline void ep_struct_init(struct ep_struct *eps)
+{
+	memset(eps, 0, sizeof(struct ep_struct));
+}
+
+static inline void ep_struct_free(struct ep_struct *eps)
+{
+	size_t i;
+
+	bfree(eps->name);
+	for (i = 0; i < eps->vars.num; i++)
+		ep_var_free(eps->vars.array + i);
+	da_free(eps->vars);
+}
+
+/* ------------------------------------------------------------------------- */
+/* effect parser sampler data */
+
+struct ep_sampler {
+	char *name;
+	DARRAY(char *) states;
+	DARRAY(char *) values;
+
+	bool written;
+};
+
+static inline void ep_sampler_init(struct ep_sampler *eps)
+{
+	memset(eps, 0, sizeof(struct ep_sampler));
+}
+
+static inline void ep_sampler_free(struct ep_sampler *eps)
+{
+	size_t i;
+
+	for (i = 0; i < eps->states.num; i++)
+		bfree(eps->states.array[i]);
+	for (i = 0; i < eps->values.num; i++)
+		bfree(eps->values.array[i]);
+
+	bfree(eps->name);
+	da_free(eps->states);
+	da_free(eps->values);
+}
+
+/* ------------------------------------------------------------------------- */
+/* effect parser pass data */
+
+struct ep_pass {
+	char *name;
+	cf_token_array_t vertex_program;
+	cf_token_array_t fragment_program;
+	struct gs_effect_pass *pass;
+};
+
+static inline void ep_pass_init(struct ep_pass *epp)
+{
+	memset(epp, 0, sizeof(struct ep_pass));
+}
+
+static inline void ep_pass_free(struct ep_pass *epp)
+{
+	bfree(epp->name);
+	da_free(epp->vertex_program);
+	da_free(epp->fragment_program);
+}
+
+/* ------------------------------------------------------------------------- */
+/* effect parser technique data */
+
+struct ep_technique {
+	char *name;
+	DARRAY(struct ep_pass) passes; /* struct ep_pass */
+};
+
+static inline void ep_technique_init(struct ep_technique *ept)
+{
+	memset(ept, 0, sizeof(struct ep_technique));
+}
+
+static inline void ep_technique_free(struct ep_technique *ept)
+{
+	size_t i;
+
+	for (i = 0; i < ept->passes.num; i++)
+		ep_pass_free(ept->passes.array + i);
+
+	bfree(ept->name);
+	da_free(ept->passes);
+}
+
+/* ------------------------------------------------------------------------- */
+/* effect parser function data */
+
+struct ep_func {
+	char *name, *ret_type, *mapping;
+	struct dstr contents;
+	ep_var_array_t param_vars;
+	DARRAY(char *) func_deps;
+	DARRAY(char *) struct_deps;
+	DARRAY(char *) param_deps;
+	DARRAY(char *) sampler_deps;
+	bool written;
+};
+
+static inline void ep_func_init(struct ep_func *epf, char *ret_type, char *name)
+{
+	memset(epf, 0, sizeof(struct ep_func));
+	epf->name = name;
+	epf->ret_type = ret_type;
+}
+
+static inline void ep_func_free(struct ep_func *epf)
+{
+	size_t i;
+	for (i = 0; i < epf->param_vars.num; i++)
+		ep_var_free(epf->param_vars.array + i);
+
+	bfree(epf->name);
+	bfree(epf->ret_type);
+	bfree(epf->mapping);
+	dstr_free(&epf->contents);
+	da_free(epf->param_vars);
+	da_free(epf->func_deps);
+	da_free(epf->struct_deps);
+	da_free(epf->param_deps);
+	da_free(epf->sampler_deps);
+}
+
+/* ------------------------------------------------------------------------- */
+
+struct effect_parser {
+	gs_effect_t *effect;
+
+	ep_param_array_t params;
+	DARRAY(struct ep_struct) structs;
+	DARRAY(struct ep_func) funcs;
+	DARRAY(struct ep_sampler) samplers;
+	DARRAY(struct ep_technique) techniques;
+
+	/* internal vars */
+	DARRAY(struct cf_lexer) files;
+	cf_token_array_t tokens;
+	struct gs_effect_pass *cur_pass;
+
+	struct cf_parser cfp;
+};
+
+static inline void ep_init(struct effect_parser *ep)
+{
+	da_init(ep->params);
+	da_init(ep->structs);
+	da_init(ep->funcs);
+	da_init(ep->samplers);
+	da_init(ep->techniques);
+	da_init(ep->files);
+	da_init(ep->tokens);
+
+	ep->cur_pass = NULL;
+	cf_parser_init(&ep->cfp);
+}
+
+extern void ep_free(struct effect_parser *ep);
+
+extern bool ep_parse(struct effect_parser *ep, gs_effect_t *effect, const char *effect_string, const char *file);
+
+#ifdef __cplusplus
+}
+#endif