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/bmem.h"
21 #include "input.h"
22 #ifdef __APPLE__
23 #include <objc/objc-runtime.h>
24 #endif
25
26 /*
27 * This is an API-independent graphics subsystem wrapper.
28 *
29 * This allows the use of OpenGL and different Direct3D versions through
30 * one shared interface.
31 */
32
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36
37 #define GS_MAX_TEXTURES 8
38
39 struct vec2;
40 struct vec3;
41 struct vec4;
42 struct quat;
43 struct axisang;
44 struct plane;
45 struct matrix3;
46 struct matrix4;
47
48 enum gs_draw_mode {
49 GS_POINTS,
50 GS_LINES,
51 GS_LINESTRIP,
52 GS_TRIS,
53 GS_TRISTRIP,
54 };
55
56 enum gs_color_format {
57 GS_UNKNOWN,
58 GS_A8,
59 GS_R8,
60 GS_RGBA,
61 GS_BGRX,
62 GS_BGRA,
63 GS_R10G10B10A2,
64 GS_RGBA16,
65 GS_R16,
66 GS_RGBA16F,
67 GS_RGBA32F,
68 GS_RG16F,
69 GS_RG32F,
70 GS_R16F,
71 GS_R32F,
72 GS_DXT1,
73 GS_DXT3,
74 GS_DXT5,
75 GS_R8G8,
76 GS_RGBA_UNORM,
77 GS_BGRX_UNORM,
78 GS_BGRA_UNORM,
79 };
80
81 enum gs_zstencil_format {
82 GS_ZS_NONE,
83 GS_Z16,
84 GS_Z24_S8,
85 GS_Z32F,
86 GS_Z32F_S8X24,
87 };
88
89 enum gs_index_type {
90 GS_UNSIGNED_SHORT,
91 GS_UNSIGNED_LONG,
92 };
93
94 enum gs_cull_mode {
95 GS_BACK,
96 GS_FRONT,
97 GS_NEITHER,
98 };
99
100 enum gs_blend_type {
101 GS_BLEND_ZERO,
102 GS_BLEND_ONE,
103 GS_BLEND_SRCCOLOR,
104 GS_BLEND_INVSRCCOLOR,
105 GS_BLEND_SRCALPHA,
106 GS_BLEND_INVSRCALPHA,
107 GS_BLEND_DSTCOLOR,
108 GS_BLEND_INVDSTCOLOR,
109 GS_BLEND_DSTALPHA,
110 GS_BLEND_INVDSTALPHA,
111 GS_BLEND_SRCALPHASAT,
112 };
113
114 enum gs_depth_test {
115 GS_NEVER,
116 GS_LESS,
117 GS_LEQUAL,
118 GS_EQUAL,
119 GS_GEQUAL,
120 GS_GREATER,
121 GS_NOTEQUAL,
122 GS_ALWAYS,
123 };
124
125 enum gs_stencil_side {
126 GS_STENCIL_FRONT = 1,
127 GS_STENCIL_BACK,
128 GS_STENCIL_BOTH,
129 };
130
131 enum gs_stencil_op_type {
132 GS_KEEP,
133 GS_ZERO,
134 GS_REPLACE,
135 GS_INCR,
136 GS_DECR,
137 GS_INVERT,
138 };
139
140 enum gs_cube_sides {
141 GS_POSITIVE_X,
142 GS_NEGATIVE_X,
143 GS_POSITIVE_Y,
144 GS_NEGATIVE_Y,
145 GS_POSITIVE_Z,
146 GS_NEGATIVE_Z,
147 };
148
149 enum gs_sample_filter {
150 GS_FILTER_POINT,
151 GS_FILTER_LINEAR,
152 GS_FILTER_ANISOTROPIC,
153 GS_FILTER_MIN_MAG_POINT_MIP_LINEAR,
154 GS_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT,
155 GS_FILTER_MIN_POINT_MAG_MIP_LINEAR,
156 GS_FILTER_MIN_LINEAR_MAG_MIP_POINT,
157 GS_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR,
158 GS_FILTER_MIN_MAG_LINEAR_MIP_POINT,
159 };
160
161 enum gs_address_mode {
162 GS_ADDRESS_CLAMP,
163 GS_ADDRESS_WRAP,
164 GS_ADDRESS_MIRROR,
165 GS_ADDRESS_BORDER,
166 GS_ADDRESS_MIRRORONCE,
167 };
168
169 enum gs_texture_type {
170 GS_TEXTURE_2D,
171 GS_TEXTURE_3D,
172 GS_TEXTURE_CUBE,
173 };
174
175 struct gs_device_loss {
176 void (*device_loss_release)(void *data);
177 void (*device_loss_rebuild)(void *device, void *data);
178 void *data;
179 };
180
181 struct gs_monitor_info {
182 int rotation_degrees;
183 long x;
184 long y;
185 long cx;
186 long cy;
187 };
188
189 struct gs_tvertarray {
190 size_t width;
191 void *array;
192 };
193
194 struct gs_vb_data {
195 size_t num;
196 struct vec3 *points;
197 struct vec3 *normals;
198 struct vec3 *tangents;
199 uint32_t *colors;
200
201 size_t num_tex;
202 struct gs_tvertarray *tvarray;
203 };
204
gs_vbdata_create(void)205 static inline struct gs_vb_data *gs_vbdata_create(void)
206 {
207 return (struct gs_vb_data *)bzalloc(sizeof(struct gs_vb_data));
208 }
209
gs_vbdata_destroy(struct gs_vb_data * data)210 static inline void gs_vbdata_destroy(struct gs_vb_data *data)
211 {
212 uint32_t i;
213 if (!data)
214 return;
215
216 bfree(data->points);
217 bfree(data->normals);
218 bfree(data->tangents);
219 bfree(data->colors);
220 for (i = 0; i < data->num_tex; i++)
221 bfree(data->tvarray[i].array);
222 bfree(data->tvarray);
223 bfree(data);
224 }
225
226 struct gs_sampler_info {
227 enum gs_sample_filter filter;
228 enum gs_address_mode address_u;
229 enum gs_address_mode address_v;
230 enum gs_address_mode address_w;
231 int max_anisotropy;
232 uint32_t border_color;
233 };
234
235 struct gs_display_mode {
236 uint32_t width;
237 uint32_t height;
238 uint32_t bits;
239 uint32_t freq;
240 };
241
242 struct gs_rect {
243 int x;
244 int y;
245 int cx;
246 int cy;
247 };
248
249 /* wrapped opaque data types */
250
251 struct gs_texture;
252 struct gs_stage_surface;
253 struct gs_zstencil_buffer;
254 struct gs_vertex_buffer;
255 struct gs_index_buffer;
256 struct gs_sampler_state;
257 struct gs_shader;
258 struct gs_swap_chain;
259 struct gs_timer;
260 struct gs_texrender;
261 struct gs_shader_param;
262 struct gs_effect;
263 struct gs_effect_technique;
264 struct gs_effect_pass;
265 struct gs_effect_param;
266 struct gs_device;
267 struct graphics_subsystem;
268
269 typedef struct gs_texture gs_texture_t;
270 typedef struct gs_stage_surface gs_stagesurf_t;
271 typedef struct gs_zstencil_buffer gs_zstencil_t;
272 typedef struct gs_vertex_buffer gs_vertbuffer_t;
273 typedef struct gs_index_buffer gs_indexbuffer_t;
274 typedef struct gs_sampler_state gs_samplerstate_t;
275 typedef struct gs_swap_chain gs_swapchain_t;
276 typedef struct gs_timer gs_timer_t;
277 typedef struct gs_timer_range gs_timer_range_t;
278 typedef struct gs_texture_render gs_texrender_t;
279 typedef struct gs_shader gs_shader_t;
280 typedef struct gs_shader_param gs_sparam_t;
281 typedef struct gs_effect gs_effect_t;
282 typedef struct gs_effect_technique gs_technique_t;
283 typedef struct gs_effect_pass gs_epass_t;
284 typedef struct gs_effect_param gs_eparam_t;
285 typedef struct gs_device gs_device_t;
286 typedef struct graphics_subsystem graphics_t;
287
288 /* ---------------------------------------------------
289 * shader functions
290 * --------------------------------------------------- */
291
292 enum gs_shader_param_type {
293 GS_SHADER_PARAM_UNKNOWN,
294 GS_SHADER_PARAM_BOOL,
295 GS_SHADER_PARAM_FLOAT,
296 GS_SHADER_PARAM_INT,
297 GS_SHADER_PARAM_STRING,
298 GS_SHADER_PARAM_VEC2,
299 GS_SHADER_PARAM_VEC3,
300 GS_SHADER_PARAM_VEC4,
301 GS_SHADER_PARAM_INT2,
302 GS_SHADER_PARAM_INT3,
303 GS_SHADER_PARAM_INT4,
304 GS_SHADER_PARAM_MATRIX4X4,
305 GS_SHADER_PARAM_TEXTURE,
306 };
307
308 struct gs_shader_texture {
309 gs_texture_t *tex;
310 bool srgb;
311 };
312
313 #ifndef SWIG
314 struct gs_shader_param_info {
315 enum gs_shader_param_type type;
316 const char *name;
317 };
318
319 enum gs_shader_type {
320 GS_SHADER_VERTEX,
321 GS_SHADER_PIXEL,
322 };
323
324 EXPORT void gs_shader_destroy(gs_shader_t *shader);
325
326 EXPORT int gs_shader_get_num_params(const gs_shader_t *shader);
327 EXPORT gs_sparam_t *gs_shader_get_param_by_idx(gs_shader_t *shader,
328 uint32_t param);
329 EXPORT gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader,
330 const char *name);
331
332 EXPORT gs_sparam_t *gs_shader_get_viewproj_matrix(const gs_shader_t *shader);
333 EXPORT gs_sparam_t *gs_shader_get_world_matrix(const gs_shader_t *shader);
334
335 EXPORT void gs_shader_get_param_info(const gs_sparam_t *param,
336 struct gs_shader_param_info *info);
337 EXPORT void gs_shader_set_bool(gs_sparam_t *param, bool val);
338 EXPORT void gs_shader_set_float(gs_sparam_t *param, float val);
339 EXPORT void gs_shader_set_int(gs_sparam_t *param, int val);
340 EXPORT void gs_shader_set_matrix3(gs_sparam_t *param,
341 const struct matrix3 *val);
342 EXPORT void gs_shader_set_matrix4(gs_sparam_t *param,
343 const struct matrix4 *val);
344 EXPORT void gs_shader_set_vec2(gs_sparam_t *param, const struct vec2 *val);
345 EXPORT void gs_shader_set_vec3(gs_sparam_t *param, const struct vec3 *val);
346 EXPORT void gs_shader_set_vec4(gs_sparam_t *param, const struct vec4 *val);
347 EXPORT void gs_shader_set_texture(gs_sparam_t *param, gs_texture_t *val);
348 EXPORT void gs_shader_set_val(gs_sparam_t *param, const void *val, size_t size);
349 EXPORT void gs_shader_set_default(gs_sparam_t *param);
350 EXPORT void gs_shader_set_next_sampler(gs_sparam_t *param,
351 gs_samplerstate_t *sampler);
352 #endif
353
354 /* ---------------------------------------------------
355 * effect functions
356 * --------------------------------------------------- */
357
358 /*enum gs_effect_property_type {
359 GS_EFFECT_NONE,
360 GS_EFFECT_BOOL,
361 GS_EFFECT_FLOAT,
362 GS_EFFECT_COLOR,
363 GS_EFFECT_TEXTURE
364 };*/
365
366 #ifndef SWIG
367 struct gs_effect_param_info {
368 const char *name;
369 enum gs_shader_param_type type;
370
371 /* const char *full_name;
372 enum gs_effect_property_type prop_type;
373
374 float min, max, inc, mul; */
375 };
376 #endif
377
378 EXPORT void gs_effect_destroy(gs_effect_t *effect);
379
380 EXPORT gs_technique_t *gs_effect_get_technique(const gs_effect_t *effect,
381 const char *name);
382
383 EXPORT gs_technique_t *
384 gs_effect_get_current_technique(const gs_effect_t *effect);
385
386 EXPORT size_t gs_technique_begin(gs_technique_t *technique);
387 EXPORT void gs_technique_end(gs_technique_t *technique);
388 EXPORT bool gs_technique_begin_pass(gs_technique_t *technique, size_t pass);
389 EXPORT bool gs_technique_begin_pass_by_name(gs_technique_t *technique,
390 const char *name);
391 EXPORT void gs_technique_end_pass(gs_technique_t *technique);
392 EXPORT gs_epass_t *gs_technique_get_pass_by_idx(const gs_technique_t *technique,
393 size_t pass);
394 EXPORT gs_epass_t *
395 gs_technique_get_pass_by_name(const gs_technique_t *technique,
396 const char *name);
397
398 EXPORT size_t gs_effect_get_num_params(const gs_effect_t *effect);
399 EXPORT gs_eparam_t *gs_effect_get_param_by_idx(const gs_effect_t *effect,
400 size_t param);
401 EXPORT gs_eparam_t *gs_effect_get_param_by_name(const gs_effect_t *effect,
402 const char *name);
403 EXPORT size_t gs_param_get_num_annotations(const gs_eparam_t *param);
404 EXPORT gs_eparam_t *gs_param_get_annotation_by_idx(const gs_eparam_t *param,
405 size_t annotation);
406 EXPORT gs_eparam_t *gs_param_get_annotation_by_name(const gs_eparam_t *param,
407 const char *name);
408
409 /** Helper function to simplify effect usage. Use with a while loop that
410 * contains drawing functions. Automatically handles techniques, passes, and
411 * unloading. */
412 EXPORT bool gs_effect_loop(gs_effect_t *effect, const char *name);
413
414 /** used internally */
415 EXPORT void gs_effect_update_params(gs_effect_t *effect);
416
417 EXPORT gs_eparam_t *gs_effect_get_viewproj_matrix(const gs_effect_t *effect);
418 EXPORT gs_eparam_t *gs_effect_get_world_matrix(const gs_effect_t *effect);
419
420 #ifndef SWIG
421 EXPORT void gs_effect_get_param_info(const gs_eparam_t *param,
422 struct gs_effect_param_info *info);
423 #endif
424
425 EXPORT void gs_effect_set_bool(gs_eparam_t *param, bool val);
426 EXPORT void gs_effect_set_float(gs_eparam_t *param, float val);
427 EXPORT void gs_effect_set_int(gs_eparam_t *param, int val);
428 EXPORT void gs_effect_set_matrix4(gs_eparam_t *param,
429 const struct matrix4 *val);
430 EXPORT void gs_effect_set_vec2(gs_eparam_t *param, const struct vec2 *val);
431 EXPORT void gs_effect_set_vec3(gs_eparam_t *param, const struct vec3 *val);
432 EXPORT void gs_effect_set_vec4(gs_eparam_t *param, const struct vec4 *val);
433 EXPORT void gs_effect_set_texture(gs_eparam_t *param, gs_texture_t *val);
434 EXPORT void gs_effect_set_texture_srgb(gs_eparam_t *param, gs_texture_t *val);
435 EXPORT void gs_effect_set_val(gs_eparam_t *param, const void *val, size_t size);
436 EXPORT void gs_effect_set_default(gs_eparam_t *param);
437 EXPORT size_t gs_effect_get_val_size(gs_eparam_t *param);
438 EXPORT void *gs_effect_get_val(gs_eparam_t *param);
439 EXPORT size_t gs_effect_get_default_val_size(gs_eparam_t *param);
440 EXPORT void *gs_effect_get_default_val(gs_eparam_t *param);
441 EXPORT void gs_effect_set_next_sampler(gs_eparam_t *param,
442 gs_samplerstate_t *sampler);
443
444 EXPORT void gs_effect_set_color(gs_eparam_t *param, uint32_t argb);
445
446 /* ---------------------------------------------------
447 * texture render helper functions
448 * --------------------------------------------------- */
449
450 EXPORT gs_texrender_t *gs_texrender_create(enum gs_color_format format,
451 enum gs_zstencil_format zsformat);
452 EXPORT void gs_texrender_destroy(gs_texrender_t *texrender);
453 EXPORT bool gs_texrender_begin(gs_texrender_t *texrender, uint32_t cx,
454 uint32_t cy);
455 EXPORT void gs_texrender_end(gs_texrender_t *texrender);
456 EXPORT void gs_texrender_reset(gs_texrender_t *texrender);
457 EXPORT gs_texture_t *gs_texrender_get_texture(const gs_texrender_t *texrender);
458
459 /* ---------------------------------------------------
460 * graphics subsystem
461 * --------------------------------------------------- */
462
463 #define GS_BUILD_MIPMAPS (1 << 0)
464 #define GS_DYNAMIC (1 << 1)
465 #define GS_RENDER_TARGET (1 << 2)
466 #define GS_GL_DUMMYTEX (1 << 3) /**<< texture with no allocated texture data */
467 #define GS_DUP_BUFFER \
468 (1 << 4) /**<< do not pass buffer ownership when
469 * creating a vertex/index buffer */
470 #define GS_SHARED_TEX (1 << 5)
471 #define GS_SHARED_KM_TEX (1 << 6)
472
473 /* ---------------- */
474 /* global functions */
475
476 #define GS_SUCCESS 0
477 #define GS_ERROR_FAIL -1
478 #define GS_ERROR_MODULE_NOT_FOUND -2
479 #define GS_ERROR_NOT_SUPPORTED -3
480
481 struct gs_window {
482 #if defined(_WIN32)
483 void *hwnd;
484 #elif defined(__APPLE__)
485 __unsafe_unretained id view;
486 #elif defined(__linux__) || defined(__FreeBSD__)
487 /* I'm not sure how portable defining id to uint32_t is. */
488 uint32_t id;
489 void *display;
490 #endif
491 };
492
493 struct gs_init_data {
494 struct gs_window window;
495 uint32_t cx, cy;
496 uint32_t num_backbuffers;
497 enum gs_color_format format;
498 enum gs_zstencil_format zsformat;
499 uint32_t adapter;
500 };
501
502 #define GS_DEVICE_OPENGL 1
503 #define GS_DEVICE_DIRECT3D_11 2
504
505 EXPORT const char *gs_get_device_name(void);
506 EXPORT int gs_get_device_type(void);
507 EXPORT void gs_enum_adapters(bool (*callback)(void *param, const char *name,
508 uint32_t id),
509 void *param);
510
511 EXPORT int gs_create(graphics_t **graphics, const char *module,
512 uint32_t adapter);
513 EXPORT void gs_destroy(graphics_t *graphics);
514
515 EXPORT void gs_enter_context(graphics_t *graphics);
516 EXPORT void gs_leave_context(void);
517 EXPORT graphics_t *gs_get_context(void);
518 EXPORT void *gs_get_device_obj(void);
519
520 EXPORT void gs_matrix_push(void);
521 EXPORT void gs_matrix_pop(void);
522 EXPORT void gs_matrix_identity(void);
523 EXPORT void gs_matrix_transpose(void);
524 EXPORT void gs_matrix_set(const struct matrix4 *matrix);
525 EXPORT void gs_matrix_get(struct matrix4 *dst);
526 EXPORT void gs_matrix_mul(const struct matrix4 *matrix);
527 EXPORT void gs_matrix_rotquat(const struct quat *rot);
528 EXPORT void gs_matrix_rotaa(const struct axisang *rot);
529 EXPORT void gs_matrix_translate(const struct vec3 *pos);
530 EXPORT void gs_matrix_scale(const struct vec3 *scale);
531 EXPORT void gs_matrix_rotaa4f(float x, float y, float z, float angle);
532 EXPORT void gs_matrix_translate3f(float x, float y, float z);
533 EXPORT void gs_matrix_scale3f(float x, float y, float z);
534
535 EXPORT void gs_render_start(bool b_new);
536 EXPORT void gs_render_stop(enum gs_draw_mode mode);
537 EXPORT gs_vertbuffer_t *gs_render_save(void);
538 EXPORT void gs_vertex2f(float x, float y);
539 EXPORT void gs_vertex3f(float x, float y, float z);
540 EXPORT void gs_normal3f(float x, float y, float z);
541 EXPORT void gs_color(uint32_t color);
542 EXPORT void gs_texcoord(float x, float y, int unit);
543 EXPORT void gs_vertex2v(const struct vec2 *v);
544 EXPORT void gs_vertex3v(const struct vec3 *v);
545 EXPORT void gs_normal3v(const struct vec3 *v);
546 EXPORT void gs_color4v(const struct vec4 *v);
547 EXPORT void gs_texcoord2v(const struct vec2 *v, int unit);
548
549 EXPORT input_t *gs_get_input(void);
550 EXPORT gs_effect_t *gs_get_effect(void);
551
552 EXPORT gs_effect_t *gs_effect_create_from_file(const char *file,
553 char **error_string);
554 EXPORT gs_effect_t *gs_effect_create(const char *effect_string,
555 const char *filename, char **error_string);
556
557 EXPORT gs_shader_t *gs_vertexshader_create_from_file(const char *file,
558 char **error_string);
559 EXPORT gs_shader_t *gs_pixelshader_create_from_file(const char *file,
560 char **error_string);
561
562 enum gs_image_alpha_mode {
563 GS_IMAGE_ALPHA_STRAIGHT,
564 GS_IMAGE_ALPHA_PREMULTIPLY_SRGB,
565 GS_IMAGE_ALPHA_PREMULTIPLY,
566 };
567
568 EXPORT gs_texture_t *gs_texture_create_from_file(const char *file);
569 EXPORT uint8_t *gs_create_texture_file_data(const char *file,
570 enum gs_color_format *format,
571 uint32_t *cx, uint32_t *cy);
572 EXPORT uint8_t *gs_create_texture_file_data2(
573 const char *file, enum gs_image_alpha_mode alpha_mode,
574 enum gs_color_format *format, uint32_t *cx, uint32_t *cy);
575
576 #define GS_FLIP_U (1 << 0)
577 #define GS_FLIP_V (1 << 1)
578
579 /**
580 * Draws a 2D sprite
581 *
582 * If width or height is 0, the width or height of the texture will be used.
583 * The flip value specifies whether the texture should be flipped on the U or V
584 * axis with GS_FLIP_U and GS_FLIP_V.
585 */
586 EXPORT void gs_draw_sprite(gs_texture_t *tex, uint32_t flip, uint32_t width,
587 uint32_t height);
588
589 EXPORT void gs_draw_sprite_subregion(gs_texture_t *tex, uint32_t flip,
590 uint32_t x, uint32_t y, uint32_t cx,
591 uint32_t cy);
592
593 EXPORT void gs_draw_cube_backdrop(gs_texture_t *cubetex, const struct quat *rot,
594 float left, float right, float top,
595 float bottom, float znear);
596
597 /** sets the viewport to current swap chain size */
598 EXPORT void gs_reset_viewport(void);
599
600 /** sets default screen-sized orthographic mode */
601 EXPORT void gs_set_2d_mode(void);
602 /** sets default screen-sized perspective mode */
603 EXPORT void gs_set_3d_mode(double fovy, double znear, double zvar);
604
605 EXPORT void gs_viewport_push(void);
606 EXPORT void gs_viewport_pop(void);
607
608 EXPORT void gs_texture_set_image(gs_texture_t *tex, const uint8_t *data,
609 uint32_t linesize, bool invert);
610 EXPORT void gs_cubetexture_set_image(gs_texture_t *cubetex, uint32_t side,
611 const void *data, uint32_t linesize,
612 bool invert);
613
614 EXPORT void gs_perspective(float fovy, float aspect, float znear, float zfar);
615
616 EXPORT void gs_blend_state_push(void);
617 EXPORT void gs_blend_state_pop(void);
618 EXPORT void gs_reset_blend_state(void);
619
620 /* -------------------------- */
621 /* library-specific functions */
622
623 EXPORT gs_swapchain_t *gs_swapchain_create(const struct gs_init_data *data);
624
625 EXPORT void gs_resize(uint32_t x, uint32_t y);
626 EXPORT void gs_get_size(uint32_t *x, uint32_t *y);
627 EXPORT uint32_t gs_get_width(void);
628 EXPORT uint32_t gs_get_height(void);
629
630 EXPORT gs_texture_t *gs_texture_create(uint32_t width, uint32_t height,
631 enum gs_color_format color_format,
632 uint32_t levels, const uint8_t **data,
633 uint32_t flags);
634 EXPORT gs_texture_t *
635 gs_cubetexture_create(uint32_t size, enum gs_color_format color_format,
636 uint32_t levels, const uint8_t **data, uint32_t flags);
637 EXPORT gs_texture_t *gs_voltexture_create(uint32_t width, uint32_t height,
638 uint32_t depth,
639 enum gs_color_format color_format,
640 uint32_t levels, const uint8_t **data,
641 uint32_t flags);
642
643 EXPORT gs_zstencil_t *gs_zstencil_create(uint32_t width, uint32_t height,
644 enum gs_zstencil_format format);
645
646 EXPORT gs_stagesurf_t *
647 gs_stagesurface_create(uint32_t width, uint32_t height,
648 enum gs_color_format color_format);
649
650 EXPORT gs_samplerstate_t *
651 gs_samplerstate_create(const struct gs_sampler_info *info);
652
653 EXPORT gs_shader_t *gs_vertexshader_create(const char *shader, const char *file,
654 char **error_string);
655 EXPORT gs_shader_t *gs_pixelshader_create(const char *shader, const char *file,
656 char **error_string);
657
658 EXPORT gs_vertbuffer_t *gs_vertexbuffer_create(struct gs_vb_data *data,
659 uint32_t flags);
660 EXPORT gs_indexbuffer_t *gs_indexbuffer_create(enum gs_index_type type,
661 void *indices, size_t num,
662 uint32_t flags);
663
664 EXPORT gs_timer_t *gs_timer_create();
665 EXPORT gs_timer_range_t *gs_timer_range_create();
666
667 EXPORT enum gs_texture_type gs_get_texture_type(const gs_texture_t *texture);
668
669 EXPORT void gs_load_vertexbuffer(gs_vertbuffer_t *vertbuffer);
670 EXPORT void gs_load_indexbuffer(gs_indexbuffer_t *indexbuffer);
671 EXPORT void gs_load_texture(gs_texture_t *tex, int unit);
672 EXPORT void gs_load_samplerstate(gs_samplerstate_t *samplerstate, int unit);
673 EXPORT void gs_load_vertexshader(gs_shader_t *vertshader);
674 EXPORT void gs_load_pixelshader(gs_shader_t *pixelshader);
675
676 EXPORT void gs_load_default_samplerstate(bool b_3d, int unit);
677
678 EXPORT gs_shader_t *gs_get_vertex_shader(void);
679 EXPORT gs_shader_t *gs_get_pixel_shader(void);
680
681 EXPORT gs_texture_t *gs_get_render_target(void);
682 EXPORT gs_zstencil_t *gs_get_zstencil_target(void);
683
684 EXPORT void gs_set_render_target(gs_texture_t *tex, gs_zstencil_t *zstencil);
685 EXPORT void gs_set_cube_render_target(gs_texture_t *cubetex, int side,
686 gs_zstencil_t *zstencil);
687
688 EXPORT void gs_enable_framebuffer_srgb(bool enable);
689 EXPORT bool gs_framebuffer_srgb_enabled(void);
690
691 EXPORT bool gs_get_linear_srgb(void);
692 EXPORT bool gs_set_linear_srgb(bool linear_srgb);
693
694 EXPORT void gs_copy_texture(gs_texture_t *dst, gs_texture_t *src);
695 EXPORT void gs_copy_texture_region(gs_texture_t *dst, uint32_t dst_x,
696 uint32_t dst_y, gs_texture_t *src,
697 uint32_t src_x, uint32_t src_y,
698 uint32_t src_w, uint32_t src_h);
699 EXPORT void gs_stage_texture(gs_stagesurf_t *dst, gs_texture_t *src);
700
701 EXPORT void gs_begin_frame(void);
702 EXPORT void gs_begin_scene(void);
703 EXPORT void gs_draw(enum gs_draw_mode draw_mode, uint32_t start_vert,
704 uint32_t num_verts);
705 EXPORT void gs_end_scene(void);
706
707 #define GS_CLEAR_COLOR (1 << 0)
708 #define GS_CLEAR_DEPTH (1 << 1)
709 #define GS_CLEAR_STENCIL (1 << 2)
710
711 EXPORT void gs_load_swapchain(gs_swapchain_t *swapchain);
712 EXPORT void gs_clear(uint32_t clear_flags, const struct vec4 *color,
713 float depth, uint8_t stencil);
714 EXPORT void gs_present(void);
715 EXPORT void gs_flush(void);
716
717 EXPORT void gs_set_cull_mode(enum gs_cull_mode mode);
718 EXPORT enum gs_cull_mode gs_get_cull_mode(void);
719
720 EXPORT void gs_enable_blending(bool enable);
721 EXPORT void gs_enable_depth_test(bool enable);
722 EXPORT void gs_enable_stencil_test(bool enable);
723 EXPORT void gs_enable_stencil_write(bool enable);
724 EXPORT void gs_enable_color(bool red, bool green, bool blue, bool alpha);
725
726 EXPORT void gs_blend_function(enum gs_blend_type src, enum gs_blend_type dest);
727 EXPORT void gs_blend_function_separate(enum gs_blend_type src_c,
728 enum gs_blend_type dest_c,
729 enum gs_blend_type src_a,
730 enum gs_blend_type dest_a);
731 EXPORT void gs_depth_function(enum gs_depth_test test);
732
733 EXPORT void gs_stencil_function(enum gs_stencil_side side,
734 enum gs_depth_test test);
735 EXPORT void gs_stencil_op(enum gs_stencil_side side,
736 enum gs_stencil_op_type fail,
737 enum gs_stencil_op_type zfail,
738 enum gs_stencil_op_type zpass);
739
740 EXPORT void gs_set_viewport(int x, int y, int width, int height);
741 EXPORT void gs_get_viewport(struct gs_rect *rect);
742 EXPORT void gs_set_scissor_rect(const struct gs_rect *rect);
743
744 EXPORT void gs_ortho(float left, float right, float top, float bottom,
745 float znear, float zfar);
746 EXPORT void gs_frustum(float left, float right, float top, float bottom,
747 float znear, float zfar);
748
749 EXPORT void gs_projection_push(void);
750 EXPORT void gs_projection_pop(void);
751
752 EXPORT void gs_swapchain_destroy(gs_swapchain_t *swapchain);
753
754 EXPORT void gs_texture_destroy(gs_texture_t *tex);
755 EXPORT uint32_t gs_texture_get_width(const gs_texture_t *tex);
756 EXPORT uint32_t gs_texture_get_height(const gs_texture_t *tex);
757 EXPORT enum gs_color_format
758 gs_texture_get_color_format(const gs_texture_t *tex);
759 EXPORT bool gs_texture_map(gs_texture_t *tex, uint8_t **ptr,
760 uint32_t *linesize);
761 EXPORT void gs_texture_unmap(gs_texture_t *tex);
762 /** special-case function (GL only) - specifies whether the texture is a
763 * GL_TEXTURE_RECTANGLE type, which doesn't use normalized texture
764 * coordinates, doesn't support mipmapping, and requires address clamping */
765 EXPORT bool gs_texture_is_rect(const gs_texture_t *tex);
766 /**
767 * Gets a pointer to the context-specific object associated with the texture.
768 * For example, for GL, this is a GLuint*. For D3D11, ID3D11Texture2D*.
769 */
770 EXPORT void *gs_texture_get_obj(gs_texture_t *tex);
771
772 EXPORT void gs_cubetexture_destroy(gs_texture_t *cubetex);
773 EXPORT uint32_t gs_cubetexture_get_size(const gs_texture_t *cubetex);
774 EXPORT enum gs_color_format
775 gs_cubetexture_get_color_format(const gs_texture_t *cubetex);
776
777 EXPORT void gs_voltexture_destroy(gs_texture_t *voltex);
778 EXPORT uint32_t gs_voltexture_get_width(const gs_texture_t *voltex);
779 EXPORT uint32_t gs_voltexture_get_height(const gs_texture_t *voltex);
780 EXPORT uint32_t gs_voltexture_get_depth(const gs_texture_t *voltex);
781 EXPORT enum gs_color_format
782 gs_voltexture_get_color_format(const gs_texture_t *voltex);
783
784 EXPORT void gs_stagesurface_destroy(gs_stagesurf_t *stagesurf);
785 EXPORT uint32_t gs_stagesurface_get_width(const gs_stagesurf_t *stagesurf);
786 EXPORT uint32_t gs_stagesurface_get_height(const gs_stagesurf_t *stagesurf);
787 EXPORT enum gs_color_format
788 gs_stagesurface_get_color_format(const gs_stagesurf_t *stagesurf);
789 EXPORT bool gs_stagesurface_map(gs_stagesurf_t *stagesurf, uint8_t **data,
790 uint32_t *linesize);
791 EXPORT void gs_stagesurface_unmap(gs_stagesurf_t *stagesurf);
792
793 EXPORT void gs_zstencil_destroy(gs_zstencil_t *zstencil);
794
795 EXPORT void gs_samplerstate_destroy(gs_samplerstate_t *samplerstate);
796
797 EXPORT void gs_vertexbuffer_destroy(gs_vertbuffer_t *vertbuffer);
798 EXPORT void gs_vertexbuffer_flush(gs_vertbuffer_t *vertbuffer);
799 EXPORT void gs_vertexbuffer_flush_direct(gs_vertbuffer_t *vertbuffer,
800 const struct gs_vb_data *data);
801 EXPORT struct gs_vb_data *
802 gs_vertexbuffer_get_data(const gs_vertbuffer_t *vertbuffer);
803
804 EXPORT void gs_indexbuffer_destroy(gs_indexbuffer_t *indexbuffer);
805 EXPORT void gs_indexbuffer_flush(gs_indexbuffer_t *indexbuffer);
806 EXPORT void gs_indexbuffer_flush_direct(gs_indexbuffer_t *indexbuffer,
807 const void *data);
808 EXPORT void *gs_indexbuffer_get_data(const gs_indexbuffer_t *indexbuffer);
809 EXPORT size_t
810 gs_indexbuffer_get_num_indices(const gs_indexbuffer_t *indexbuffer);
811 EXPORT enum gs_index_type
812 gs_indexbuffer_get_type(const gs_indexbuffer_t *indexbuffer);
813
814 EXPORT void gs_timer_destroy(gs_timer_t *timer);
815 EXPORT void gs_timer_begin(gs_timer_t *timer);
816 EXPORT void gs_timer_end(gs_timer_t *timer);
817 EXPORT bool gs_timer_get_data(gs_timer_t *timer, uint64_t *ticks);
818 EXPORT void gs_timer_range_destroy(gs_timer_range_t *timer);
819 EXPORT void gs_timer_range_begin(gs_timer_range_t *range);
820 EXPORT void gs_timer_range_end(gs_timer_range_t *range);
821 EXPORT bool gs_timer_range_get_data(gs_timer_range_t *range, bool *disjoint,
822 uint64_t *frequency);
823
824 EXPORT bool gs_nv12_available(void);
825
826 #define GS_USE_DEBUG_MARKERS 0
827 #if GS_USE_DEBUG_MARKERS
828 static const float GS_DEBUG_COLOR_DEFAULT[] = {0.5f, 0.5f, 0.5f, 1.0f};
829 static const float GS_DEBUG_COLOR_RENDER_VIDEO[] = {0.0f, 0.5f, 0.0f, 1.0f};
830 static const float GS_DEBUG_COLOR_MAIN_TEXTURE[] = {0.0f, 0.25f, 0.0f, 1.0f};
831 static const float GS_DEBUG_COLOR_DISPLAY[] = {0.0f, 0.5f, 0.5f, 1.0f};
832 static const float GS_DEBUG_COLOR_SOURCE[] = {0.0f, 0.5f, 5.0f, 1.0f};
833 static const float GS_DEBUG_COLOR_ITEM[] = {0.5f, 0.0f, 0.0f, 1.0f};
834 static const float GS_DEBUG_COLOR_ITEM_TEXTURE[] = {0.25f, 0.0f, 0.0f, 1.0f};
835 static const float GS_DEBUG_COLOR_CONVERT_FORMAT[] = {0.5f, 0.5f, 0.0f, 1.0f};
836 #define GS_DEBUG_MARKER_BEGIN(color, markername) \
837 gs_debug_marker_begin(color, markername)
838 #define GS_DEBUG_MARKER_BEGIN_FORMAT(color, format, ...) \
839 gs_debug_marker_begin_format(color, format, __VA_ARGS__)
840 #define GS_DEBUG_MARKER_END() gs_debug_marker_end()
841 #else
842 #define GS_DEBUG_MARKER_BEGIN(color, markername) ((void)0)
843 #define GS_DEBUG_MARKER_BEGIN_FORMAT(color, format, ...) ((void)0)
844 #define GS_DEBUG_MARKER_END() ((void)0)
845 #endif
846
847 EXPORT void gs_debug_marker_begin(const float color[4], const char *markername);
848 EXPORT void gs_debug_marker_begin_format(const float color[4],
849 const char *format, ...);
850 EXPORT void gs_debug_marker_end(void);
851
852 #ifdef __APPLE__
853
854 /** platform specific function for creating (GL_TEXTURE_RECTANGLE) textures
855 * from shared surface resources */
856 EXPORT gs_texture_t *gs_texture_create_from_iosurface(void *iosurf);
857 EXPORT bool gs_texture_rebind_iosurface(gs_texture_t *texture, void *iosurf);
858 EXPORT gs_texture_t *gs_texture_open_shared(uint32_t handle);
859 EXPORT bool gs_shared_texture_available(void);
860
861 #elif _WIN32
862
863 EXPORT bool gs_gdi_texture_available(void);
864 EXPORT bool gs_shared_texture_available(void);
865
866 struct gs_duplicator;
867 typedef struct gs_duplicator gs_duplicator_t;
868
869 /**
870 * Gets information about the monitor at the specific index, returns false
871 * when there is no monitor at the specified index
872 */
873 EXPORT bool
874 gs_get_duplicator_monitor_info(int monitor_idx,
875 struct gs_monitor_info *monitor_info);
876
877 EXPORT int gs_duplicator_get_monitor_index(void *monitor);
878
879 /** creates a windows 8+ output duplicator (monitor capture) */
880 EXPORT gs_duplicator_t *gs_duplicator_create(int monitor_idx);
881 EXPORT void gs_duplicator_destroy(gs_duplicator_t *duplicator);
882
883 EXPORT bool gs_duplicator_update_frame(gs_duplicator_t *duplicator);
884 EXPORT gs_texture_t *gs_duplicator_get_texture(gs_duplicator_t *duplicator);
885
886 EXPORT uint32_t gs_get_adapter_count(void);
887
888 /** creates a windows GDI-lockable texture */
889 EXPORT gs_texture_t *gs_texture_create_gdi(uint32_t width, uint32_t height);
890
891 EXPORT void *gs_texture_get_dc(gs_texture_t *gdi_tex);
892 EXPORT void gs_texture_release_dc(gs_texture_t *gdi_tex);
893
894 /** creates a windows shared texture from a texture handle */
895 EXPORT gs_texture_t *gs_texture_open_shared(uint32_t handle);
896
897 #define GS_INVALID_HANDLE (uint32_t) - 1
898 EXPORT uint32_t gs_texture_get_shared_handle(gs_texture_t *tex);
899
900 EXPORT gs_texture_t *gs_texture_wrap_obj(void *obj);
901
902 #define GS_WAIT_INFINITE (uint32_t) - 1
903
904 /**
905 * acquires a lock on a keyed mutex texture.
906 * returns -1 on generic failure, ETIMEDOUT if timed out
907 */
908 EXPORT int gs_texture_acquire_sync(gs_texture_t *tex, uint64_t key,
909 uint32_t ms);
910
911 /**
912 * releases a lock on a keyed mutex texture to another device.
913 * return 0 on success, -1 on error
914 */
915 EXPORT int gs_texture_release_sync(gs_texture_t *tex, uint64_t key);
916
917 EXPORT bool gs_texture_create_nv12(gs_texture_t **tex_y, gs_texture_t **tex_uv,
918 uint32_t width, uint32_t height,
919 uint32_t flags);
920
921 EXPORT gs_stagesurf_t *gs_stagesurface_create_nv12(uint32_t width,
922 uint32_t height);
923
924 EXPORT void gs_register_loss_callbacks(const struct gs_device_loss *callbacks);
925 EXPORT void gs_unregister_loss_callbacks(void *data);
926
927 #elif __linux__
928
929 EXPORT gs_texture_t *gs_texture_create_from_dmabuf(
930 unsigned int width, unsigned int height, uint32_t drm_format,
931 enum gs_color_format color_format, uint32_t n_planes, const int *fds,
932 const uint32_t *strides, const uint32_t *offsets,
933 const uint64_t *modifiers);
934
935 #endif
936
937 /* inline functions used by modules */
938
gs_get_format_bpp(enum gs_color_format format)939 static inline uint32_t gs_get_format_bpp(enum gs_color_format format)
940 {
941 switch (format) {
942 case GS_A8:
943 return 8;
944 case GS_R8:
945 return 8;
946 case GS_RGBA:
947 return 32;
948 case GS_BGRX:
949 return 32;
950 case GS_BGRA:
951 return 32;
952 case GS_R10G10B10A2:
953 return 32;
954 case GS_RGBA16:
955 return 64;
956 case GS_R16:
957 return 16;
958 case GS_RGBA16F:
959 return 64;
960 case GS_RGBA32F:
961 return 128;
962 case GS_RG16F:
963 return 32;
964 case GS_RG32F:
965 return 64;
966 case GS_R16F:
967 return 16;
968 case GS_R32F:
969 return 32;
970 case GS_DXT1:
971 return 4;
972 case GS_DXT3:
973 return 8;
974 case GS_DXT5:
975 return 8;
976 case GS_R8G8:
977 return 16;
978 case GS_RGBA_UNORM:
979 return 32;
980 case GS_BGRX_UNORM:
981 return 32;
982 case GS_BGRA_UNORM:
983 return 32;
984 case GS_UNKNOWN:
985 return 0;
986 }
987
988 return 0;
989 }
990
gs_is_compressed_format(enum gs_color_format format)991 static inline bool gs_is_compressed_format(enum gs_color_format format)
992 {
993 return (format == GS_DXT1 || format == GS_DXT3 || format == GS_DXT5);
994 }
995
gs_is_srgb_format(enum gs_color_format format)996 static inline bool gs_is_srgb_format(enum gs_color_format format)
997 {
998 switch (format) {
999 case GS_RGBA:
1000 case GS_BGRX:
1001 case GS_BGRA:
1002 return true;
1003 default:
1004 return false;
1005 }
1006 }
1007
1008 static inline enum gs_color_format
gs_generalize_format(enum gs_color_format format)1009 gs_generalize_format(enum gs_color_format format)
1010 {
1011 switch (format) {
1012 case GS_RGBA_UNORM:
1013 return GS_RGBA;
1014 case GS_BGRX_UNORM:
1015 return GS_BGRX;
1016 case GS_BGRA_UNORM:
1017 return GS_BGRA;
1018 default:
1019 return format;
1020 }
1021 }
1022
gs_get_total_levels(uint32_t width,uint32_t height,uint32_t depth)1023 static inline uint32_t gs_get_total_levels(uint32_t width, uint32_t height,
1024 uint32_t depth)
1025 {
1026 uint32_t size = width > height ? width : height;
1027 size = size > depth ? size : depth;
1028 uint32_t num_levels = 1;
1029
1030 while (size > 1) {
1031 size /= 2;
1032 num_levels++;
1033 }
1034
1035 return num_levels;
1036 }
1037
1038 #ifdef __cplusplus
1039 }
1040 #endif
1041