noobs 0.0.6

package/include/graphics/effect.h

@@ -0,0 +1,190 @@
+/******************************************************************************
+    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 "effect-parser.h"
+#include "graphics.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef DARRAY(struct gs_effect_param) gs_effect_param_array_t;
+typedef DARRAY(struct pass_shaderparam) pass_shaderparam_array_t;
+
+/*
+ * Effects introduce a means of bundling together shader text into one
+ * file with shared functions and parameters.  This is done because often
+ * shaders must be duplicated when you need to alter minor aspects of the code
+ * that cannot be done via constants.  Effects allow developers to easily
+ * switch shaders and set constants that can be used between shaders.
+ *
+ * Effects are built via the effect parser, and shaders are automatically
+ * generated for each technique's pass.
+ */
+
+/* ------------------------------------------------------------------------- */
+
+enum effect_section { EFFECT_PARAM, EFFECT_TECHNIQUE, EFFECT_SAMPLER, EFFECT_PASS, EFFECT_ANNOTATION };
+
+/* ------------------------------------------------------------------------- */
+
+struct gs_effect_param {
+	char *name;
+	enum effect_section section;
+
+	enum gs_shader_param_type type;
+
+	bool changed;
+	DARRAY(uint8_t) cur_val;
+	DARRAY(uint8_t) default_val;
+
+	gs_effect_t *effect;
+	gs_samplerstate_t *next_sampler;
+
+	/*char *full_name;
+	float scroller_min, scroller_max, scroller_inc, scroller_mul;*/
+	gs_effect_param_array_t annotations;
+};
+
+static inline void effect_param_init(struct gs_effect_param *param)
+{
+	memset(param, 0, sizeof(struct gs_effect_param));
+	da_init(param->annotations);
+}
+
+static inline void effect_param_free(struct gs_effect_param *param)
+{
+	bfree(param->name);
+	//bfree(param->full_name);
+	da_free(param->cur_val);
+	da_free(param->default_val);
+
+	size_t i;
+	for (i = 0; i < param->annotations.num; i++)
+		effect_param_free(param->annotations.array + i);
+
+	da_free(param->annotations);
+}
+
+EXPORT void effect_param_parse_property(gs_eparam_t *param, const char *property);
+
+/* ------------------------------------------------------------------------- */
+
+struct pass_shaderparam {
+	struct gs_effect_param *eparam;
+	gs_sparam_t *sparam;
+};
+
+struct gs_effect_pass {
+	char *name;
+	enum effect_section section;
+
+	gs_shader_t *vertshader;
+	gs_shader_t *pixelshader;
+	pass_shaderparam_array_t vertshader_params;
+	pass_shaderparam_array_t pixelshader_params;
+};
+
+static inline void effect_pass_init(struct gs_effect_pass *pass)
+{
+	memset(pass, 0, sizeof(struct gs_effect_pass));
+}
+
+static inline void effect_pass_free(struct gs_effect_pass *pass)
+{
+	bfree(pass->name);
+	da_free(pass->vertshader_params);
+	da_free(pass->pixelshader_params);
+
+	gs_shader_destroy(pass->vertshader);
+	gs_shader_destroy(pass->pixelshader);
+}
+
+/* ------------------------------------------------------------------------- */
+
+struct gs_effect_technique {
+	char *name;
+	enum effect_section section;
+	struct gs_effect *effect;
+
+	DARRAY(struct gs_effect_pass) passes;
+};
+
+static inline void effect_technique_init(struct gs_effect_technique *t)
+{
+	memset(t, 0, sizeof(struct gs_effect_technique));
+}
+
+static inline void effect_technique_free(struct gs_effect_technique *t)
+{
+	size_t i;
+	for (i = 0; i < t->passes.num; i++)
+		effect_pass_free(t->passes.array + i);
+
+	da_free(t->passes);
+	bfree(t->name);
+}
+
+/* ------------------------------------------------------------------------- */
+
+struct gs_effect {
+	bool processing;
+	bool cached;
+	char *effect_path, *effect_dir;
+
+	gs_effect_param_array_t params;
+	DARRAY(struct gs_effect_technique) techniques;
+
+	struct gs_effect_technique *cur_technique;
+	struct gs_effect_pass *cur_pass;
+
+	gs_eparam_t *view_proj, *world, *scale;
+	graphics_t *graphics;
+
+	struct gs_effect *next;
+
+	size_t loop_pass;
+	bool looping;
+};
+
+static inline void effect_init(gs_effect_t *effect)
+{
+	memset(effect, 0, sizeof(struct gs_effect));
+}
+
+static inline void effect_free(gs_effect_t *effect)
+{
+	size_t i;
+	for (i = 0; i < effect->params.num; i++)
+		effect_param_free(effect->params.array + i);
+	for (i = 0; i < effect->techniques.num; i++)
+		effect_technique_free(effect->techniques.array + i);
+
+	da_free(effect->params);
+	da_free(effect->techniques);
+
+	bfree(effect->effect_path);
+	bfree(effect->effect_dir);
+	effect->effect_path = NULL;
+	effect->effect_dir = NULL;
+}
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/graphics-internal.h

@@ -0,0 +1,335 @@
+/******************************************************************************
+    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/threading.h"
+#include "../util/darray.h"
+#include "graphics.h"
+#include "matrix3.h"
+#include "matrix4.h"
+
+/* ========================================================================= *
+ * Exports                                                                   *
+ * ========================================================================= */
+
+struct gs_exports {
+	const char *(*device_get_name)(void);
+	const char *(*gpu_get_driver_version)(void);
+	const char *(*gpu_get_renderer)(void);
+	uint64_t (*gpu_get_dmem)(void);
+	uint64_t (*gpu_get_smem)(void);
+	int (*device_get_type)(void);
+	bool (*device_enum_adapters)(gs_device_t *device, bool (*callback)(void *, const char *, uint32_t), void *);
+	const char *(*device_preprocessor_name)(void);
+	int (*device_create)(gs_device_t **device, uint32_t adapter);
+	void (*device_destroy)(gs_device_t *device);
+	void (*device_enter_context)(gs_device_t *device);
+	void (*device_leave_context)(gs_device_t *device);
+	void *(*device_get_device_obj)(gs_device_t *device);
+	gs_swapchain_t *(*device_swapchain_create)(gs_device_t *device, const struct gs_init_data *data);
+	void (*device_resize)(gs_device_t *device, uint32_t x, uint32_t y);
+	enum gs_color_space (*device_get_color_space)(gs_device_t *device);
+	void (*device_update_color_space)(gs_device_t *device);
+	void (*device_get_size)(const gs_device_t *device, uint32_t *x, uint32_t *y);
+	uint32_t (*device_get_width)(const gs_device_t *device);
+	uint32_t (*device_get_height)(const gs_device_t *device);
+	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);
+	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);
+	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);
+	gs_zstencil_t *(*device_zstencil_create)(gs_device_t *device, uint32_t width, uint32_t height,
+						 enum gs_zstencil_format format);
+	gs_stagesurf_t *(*device_stagesurface_create)(gs_device_t *device, uint32_t width, uint32_t height,
+						      enum gs_color_format color_format);
+	gs_samplerstate_t *(*device_samplerstate_create)(gs_device_t *device, const struct gs_sampler_info *info);
+	gs_shader_t *(*device_vertexshader_create)(gs_device_t *device, const char *shader, const char *file,
+						   char **error_string);
+	gs_shader_t *(*device_pixelshader_create)(gs_device_t *device, const char *shader, const char *file,
+						  char **error_string);
+	gs_vertbuffer_t *(*device_vertexbuffer_create)(gs_device_t *device, struct gs_vb_data *data, uint32_t flags);
+	gs_indexbuffer_t *(*device_indexbuffer_create)(gs_device_t *device, enum gs_index_type type, void *indices,
+						       size_t num, uint32_t flags);
+	gs_timer_t *(*device_timer_create)(gs_device_t *device);
+	gs_timer_range_t *(*device_timer_range_create)(gs_device_t *device);
+	enum gs_texture_type (*device_get_texture_type)(const gs_texture_t *texture);
+	void (*device_load_vertexbuffer)(gs_device_t *device, gs_vertbuffer_t *vertbuffer);
+	void (*device_load_indexbuffer)(gs_device_t *device, gs_indexbuffer_t *indexbuffer);
+	void (*device_load_texture)(gs_device_t *device, gs_texture_t *tex, int unit);
+	void (*device_load_samplerstate)(gs_device_t *device, gs_samplerstate_t *samplerstate, int unit);
+	void (*device_load_vertexshader)(gs_device_t *device, gs_shader_t *vertshader);
+	void (*device_load_pixelshader)(gs_device_t *device, gs_shader_t *pixelshader);
+	void (*device_load_default_samplerstate)(gs_device_t *device, bool b_3d, int unit);
+	gs_shader_t *(*device_get_vertex_shader)(const gs_device_t *device);
+	gs_shader_t *(*device_get_pixel_shader)(const gs_device_t *device);
+	gs_texture_t *(*device_get_render_target)(const gs_device_t *device);
+	gs_zstencil_t *(*device_get_zstencil_target)(const gs_device_t *device);
+	void (*device_set_render_target)(gs_device_t *device, gs_texture_t *tex, gs_zstencil_t *zstencil);
+	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);
+	void (*device_set_cube_render_target)(gs_device_t *device, gs_texture_t *cubetex, int side,
+					      gs_zstencil_t *zstencil);
+	void (*device_enable_framebuffer_srgb)(gs_device_t *device, bool enable);
+	bool (*device_framebuffer_srgb_enabled)(gs_device_t *device);
+	void (*device_copy_texture)(gs_device_t *device, gs_texture_t *dst, gs_texture_t *src);
+	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);
+	void (*device_stage_texture)(gs_device_t *device, gs_stagesurf_t *dst, gs_texture_t *src);
+	void (*device_begin_frame)(gs_device_t *device);
+	void (*device_begin_scene)(gs_device_t *device);
+	void (*device_draw)(gs_device_t *device, enum gs_draw_mode draw_mode, uint32_t start_vert, uint32_t num_verts);
+	void (*device_end_scene)(gs_device_t *device);
+	void (*device_load_swapchain)(gs_device_t *device, gs_swapchain_t *swaphchain);
+	void (*device_clear)(gs_device_t *device, uint32_t clear_flags, const struct vec4 *color, float depth,
+			     uint8_t stencil);
+	bool (*device_is_present_ready)(gs_device_t *device);
+	void (*device_present)(gs_device_t *device);
+	void (*device_flush)(gs_device_t *device);
+	void (*device_set_cull_mode)(gs_device_t *device, enum gs_cull_mode mode);
+	enum gs_cull_mode (*device_get_cull_mode)(const gs_device_t *device);
+	void (*device_enable_blending)(gs_device_t *device, bool enable);
+	void (*device_enable_depth_test)(gs_device_t *device, bool enable);
+	void (*device_enable_stencil_test)(gs_device_t *device, bool enable);
+	void (*device_enable_stencil_write)(gs_device_t *device, bool enable);
+	void (*device_enable_color)(gs_device_t *device, bool red, bool green, bool blue, bool alpha);
+	void (*device_blend_function)(gs_device_t *device, enum gs_blend_type src, enum gs_blend_type dest);
+	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);
+	void (*device_blend_op)(gs_device_t *device, enum gs_blend_op_type op);
+
+	void (*device_depth_function)(gs_device_t *device, enum gs_depth_test test);
+	void (*device_stencil_function)(gs_device_t *device, enum gs_stencil_side side, enum gs_depth_test test);
+	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);
+	void (*device_set_viewport)(gs_device_t *device, int x, int y, int width, int height);
+	void (*device_get_viewport)(const gs_device_t *device, struct gs_rect *rect);
+	void (*device_set_scissor_rect)(gs_device_t *device, const struct gs_rect *rect);
+	void (*device_ortho)(gs_device_t *device, float left, float right, float top, float bottom, float znear,
+			     float zfar);
+	void (*device_frustum)(gs_device_t *device, float left, float right, float top, float bottom, float znear,
+			       float zfar);
+	void (*device_projection_push)(gs_device_t *device);
+	void (*device_projection_pop)(gs_device_t *device);
+
+	void (*gs_swapchain_destroy)(gs_swapchain_t *swapchain);
+
+	void (*gs_texture_destroy)(gs_texture_t *tex);
+	uint32_t (*gs_texture_get_width)(const gs_texture_t *tex);
+	uint32_t (*gs_texture_get_height)(const gs_texture_t *tex);
+	enum gs_color_format (*gs_texture_get_color_format)(const gs_texture_t *tex);
+	bool (*gs_texture_map)(gs_texture_t *tex, uint8_t **ptr, uint32_t *linesize);
+	void (*gs_texture_unmap)(gs_texture_t *tex);
+	bool (*gs_texture_is_rect)(const gs_texture_t *tex);
+	void *(*gs_texture_get_obj)(const gs_texture_t *tex);
+
+	void (*gs_cubetexture_destroy)(gs_texture_t *cubetex);
+	uint32_t (*gs_cubetexture_get_size)(const gs_texture_t *cubetex);
+	enum gs_color_format (*gs_cubetexture_get_color_format)(const gs_texture_t *cubetex);
+
+	void (*gs_voltexture_destroy)(gs_texture_t *voltex);
+	uint32_t (*gs_voltexture_get_width)(const gs_texture_t *voltex);
+	uint32_t (*gs_voltexture_get_height)(const gs_texture_t *voltex);
+	uint32_t (*gs_voltexture_get_depth)(const gs_texture_t *voltex);
+	enum gs_color_format (*gs_voltexture_get_color_format)(const gs_texture_t *voltex);
+
+	void (*gs_stagesurface_destroy)(gs_stagesurf_t *stagesurf);
+	uint32_t (*gs_stagesurface_get_width)(const gs_stagesurf_t *stagesurf);
+	uint32_t (*gs_stagesurface_get_height)(const gs_stagesurf_t *stagesurf);
+	enum gs_color_format (*gs_stagesurface_get_color_format)(const gs_stagesurf_t *stagesurf);
+	bool (*gs_stagesurface_map)(gs_stagesurf_t *stagesurf, uint8_t **data, uint32_t *linesize);
+	void (*gs_stagesurface_unmap)(gs_stagesurf_t *stagesurf);
+
+	void (*gs_zstencil_destroy)(gs_zstencil_t *zstencil);
+
+	void (*gs_samplerstate_destroy)(gs_samplerstate_t *samplerstate);
+
+	void (*gs_vertexbuffer_destroy)(gs_vertbuffer_t *vertbuffer);
+	void (*gs_vertexbuffer_flush)(gs_vertbuffer_t *vertbuffer);
+	void (*gs_vertexbuffer_flush_direct)(gs_vertbuffer_t *vertbuffer, const struct gs_vb_data *data);
+	struct gs_vb_data *(*gs_vertexbuffer_get_data)(const gs_vertbuffer_t *vertbuffer);
+
+	void (*gs_indexbuffer_destroy)(gs_indexbuffer_t *indexbuffer);
+	void (*gs_indexbuffer_flush)(gs_indexbuffer_t *indexbuffer);
+	void (*gs_indexbuffer_flush_direct)(gs_indexbuffer_t *indexbuffer, const void *data);
+	void *(*gs_indexbuffer_get_data)(const gs_indexbuffer_t *indexbuffer);
+	size_t (*gs_indexbuffer_get_num_indices)(const gs_indexbuffer_t *indexbuffer);
+	enum gs_index_type (*gs_indexbuffer_get_type)(const gs_indexbuffer_t *indexbuffer);
+
+	void (*gs_timer_destroy)(gs_timer_t *timer);
+	void (*gs_timer_begin)(gs_timer_t *timer);
+	void (*gs_timer_end)(gs_timer_t *timer);
+	bool (*gs_timer_get_data)(gs_timer_t *timer, uint64_t *ticks);
+	void (*gs_timer_range_destroy)(gs_timer_range_t *range);
+	bool (*gs_timer_range_begin)(gs_timer_range_t *range);
+	bool (*gs_timer_range_end)(gs_timer_range_t *range);
+	bool (*gs_timer_range_get_data)(gs_timer_range_t *range, bool *disjoint, uint64_t *frequency);
+
+	void (*gs_shader_destroy)(gs_shader_t *shader);
+	int (*gs_shader_get_num_params)(const gs_shader_t *shader);
+	gs_sparam_t *(*gs_shader_get_param_by_idx)(gs_shader_t *shader, uint32_t param);
+	gs_sparam_t *(*gs_shader_get_param_by_name)(gs_shader_t *shader, const char *name);
+	gs_sparam_t *(*gs_shader_get_viewproj_matrix)(const gs_shader_t *shader);
+	gs_sparam_t *(*gs_shader_get_world_matrix)(const gs_shader_t *shader);
+	void (*gs_shader_get_param_info)(const gs_sparam_t *param, struct gs_shader_param_info *info);
+	void (*gs_shader_set_bool)(gs_sparam_t *param, bool val);
+	void (*gs_shader_set_float)(gs_sparam_t *param, float val);
+	void (*gs_shader_set_int)(gs_sparam_t *param, int val);
+	void (*gs_shader_set_matrix3)(gs_sparam_t *param, const struct matrix3 *val);
+	void (*gs_shader_set_matrix4)(gs_sparam_t *param, const struct matrix4 *val);
+	void (*gs_shader_set_vec2)(gs_sparam_t *param, const struct vec2 *val);
+	void (*gs_shader_set_vec3)(gs_sparam_t *param, const struct vec3 *val);
+	void (*gs_shader_set_vec4)(gs_sparam_t *param, const struct vec4 *val);
+	void (*gs_shader_set_texture)(gs_sparam_t *param, gs_texture_t *val);
+	void (*gs_shader_set_val)(gs_sparam_t *param, const void *val, size_t size);
+	void (*gs_shader_set_default)(gs_sparam_t *param);
+	void (*gs_shader_set_next_sampler)(gs_sparam_t *param, gs_samplerstate_t *sampler);
+
+	bool (*device_nv12_available)(gs_device_t *device);
+	bool (*device_p010_available)(gs_device_t *device);
+	bool (*device_texture_create_nv12)(gs_device_t *device, gs_texture_t **tex_y, gs_texture_t **tex_uv,
+					   uint32_t width, uint32_t height, uint32_t flags);
+	bool (*device_texture_create_p010)(gs_device_t *device, gs_texture_t **tex_y, gs_texture_t **tex_uv,
+					   uint32_t width, uint32_t height, uint32_t flags);
+
+	bool (*device_is_monitor_hdr)(gs_device_t *device, void *monitor);
+
+	void (*device_debug_marker_begin)(gs_device_t *device, const char *markername, const float color[4]);
+	void (*device_debug_marker_end)(gs_device_t *device);
+
+	uint32_t (*gs_get_adapter_count)(void);
+
+#ifdef __APPLE__
+	/* OSX/Cocoa specific functions */
+	gs_texture_t *(*device_texture_create_from_iosurface)(gs_device_t *dev, void *iosurf);
+	gs_texture_t *(*device_texture_open_shared)(gs_device_t *dev, uint32_t handle);
+	bool (*gs_texture_rebind_iosurface)(gs_texture_t *texture, void *iosurf);
+	bool (*device_shared_texture_available)(void);
+
+#elif _WIN32
+	bool (*device_gdi_texture_available)(void);
+	bool (*device_shared_texture_available)(void);
+
+	bool (*device_get_duplicator_monitor_info)(gs_device_t *device, int monitor_idx,
+						   struct gs_monitor_info *monitor_info);
+	int (*device_duplicator_get_monitor_index)(gs_device_t *device, void *monitor);
+
+	gs_duplicator_t *(*device_duplicator_create)(gs_device_t *device, int monitor_idx);
+	void (*gs_duplicator_destroy)(gs_duplicator_t *duplicator);
+
+	bool (*gs_duplicator_update_frame)(gs_duplicator_t *duplicator);
+	gs_texture_t *(*gs_duplicator_get_texture)(gs_duplicator_t *duplicator);
+	enum gs_color_space (*gs_duplicator_get_color_space)(gs_duplicator_t *duplicator);
+	float (*gs_duplicator_get_sdr_white_level)(gs_duplicator_t *duplicator);
+
+	bool (*device_can_adapter_fast_clear)(gs_device_t *device);
+
+	gs_texture_t *(*device_texture_create_gdi)(gs_device_t *device, uint32_t width, uint32_t height);
+
+	void *(*gs_texture_get_dc)(gs_texture_t *gdi_tex);
+	void (*gs_texture_release_dc)(gs_texture_t *gdi_tex);
+
+	gs_texture_t *(*device_texture_open_shared)(gs_device_t *device, uint32_t handle);
+	gs_texture_t *(*device_texture_open_nt_shared)(gs_device_t *device, uint32_t handle);
+	uint32_t (*device_texture_get_shared_handle)(gs_texture_t *tex);
+	gs_texture_t *(*device_texture_wrap_obj)(gs_device_t *device, void *obj);
+	int (*device_texture_acquire_sync)(gs_texture_t *tex, uint64_t key, uint32_t ms);
+	int (*device_texture_release_sync)(gs_texture_t *tex, uint64_t key);
+
+	gs_stagesurf_t *(*device_stagesurface_create_nv12)(gs_device_t *device, uint32_t width, uint32_t height);
+	gs_stagesurf_t *(*device_stagesurface_create_p010)(gs_device_t *device, uint32_t width, uint32_t height);
+	void (*device_register_loss_callbacks)(gs_device_t *device, const struct gs_device_loss *callbacks);
+	void (*device_unregister_loss_callbacks)(gs_device_t *device, void *data);
+#elif defined(__linux__) || defined(__FreeBSD__) || defined(__DragonFly__)
+	struct gs_texture *(*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);
+	bool (*device_query_dmabuf_capabilities)(gs_device_t *device, enum gs_dmabuf_flags *dmabuf_flags,
+						 uint32_t **drm_formats, size_t *n_formats);
+	bool (*device_query_dmabuf_modifiers_for_format)(gs_device_t *device, uint32_t drm_format, uint64_t **modifiers,
+							 size_t *n_modifiers);
+	struct gs_texture *(*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);
+	bool (*device_query_sync_capabilities)(gs_device_t *device);
+	gs_sync_t *(*device_sync_create)(gs_device_t *device);
+	gs_sync_t *(*device_sync_create_from_syncobj_timeline_point)(gs_device_t *device, int syncobj_fd,
+								     uint64_t timeline_point);
+	void (*device_sync_destroy)(gs_device_t *device, gs_sync_t *sync);
+	bool (*device_sync_export_syncobj_timeline_point)(gs_device_t *device, gs_sync_t *sync, int syncobj_fd,
+							  uint64_t timeline_point);
+	bool (*device_sync_signal_syncobj_timeline_point)(gs_device_t *device, int syncobj_fd, uint64_t timeline_point);
+	bool (*device_sync_wait)(gs_device_t *device, gs_sync_t *sync);
+#endif
+};
+
+/* ========================================================================= *
+ * Graphics Subsystem Data                                                   *
+ * ========================================================================= */
+
+struct blend_state {
+	bool enabled;
+	enum gs_blend_type src_c;
+	enum gs_blend_type dest_c;
+	enum gs_blend_type src_a;
+	enum gs_blend_type dest_a;
+	enum gs_blend_op_type op;
+};
+
+struct graphics_subsystem {
+	void *module;
+	gs_device_t *device;
+	struct gs_exports exports;
+
+	DARRAY(struct gs_rect) viewport_stack;
+
+	DARRAY(struct matrix4) matrix_stack;
+	size_t cur_matrix;
+
+	struct matrix4 projection;
+	struct gs_effect *cur_effect;
+
+	gs_vertbuffer_t *sprite_buffer;
+	gs_vertbuffer_t *flipped_sprite_buffer;
+	gs_vertbuffer_t *subregion_buffer;
+
+	bool using_immediate;
+	struct gs_vb_data *vbd;
+	gs_vertbuffer_t *immediate_vertbuffer;
+	DARRAY(struct vec3) verts;
+	DARRAY(struct vec3) norms;
+	DARRAY(uint32_t) colors;
+	DARRAY(struct vec2) texverts[16];
+
+	pthread_mutex_t effect_mutex;
+	struct gs_effect *first_effect;
+
+	pthread_mutex_t mutex;
+	volatile long ref;
+
+	struct blend_state cur_blend_state;
+	DARRAY(struct blend_state) blend_state_stack;
+
+	bool linear_srgb;
+};