jp9000/obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

(API Change) Remove pointers from all typedefs

Browse Source 
Typedef pointers are unsafe.  If you do:
typedef struct bla *bla_t;
then you cannot use it as a constant, such as: const bla_t, because
that constant will be to the pointer itself rather than to the
underlying data.  I admit this was a fundamental mistake that must
be corrected.

All typedefs that were pointer types will now have their pointers
removed from the type itself, and the pointers will be used when they
are actually used as variables/parameters/returns instead.

This does not break ABI though, which is pretty nice.
This commit is contained in:
jp9000
2014-09-25 17:44:05 -07:00
parent 4a06960188
commit c9df41c1e2
146 changed files with 3105 additions and 3079 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
libobs/graphics/device-exports.h
View File

@@ -26,118 +26,121 @@ extern "C" {
EXPORT const char *device_get_name(void);
EXPORT int device_get_type(void);
EXPORT const char *device_preprocessor_name(void);
EXPORT int device_create(gs_device_t *device, struct gs_init_data *data);
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 gs_swapchain_t device_swapchain_create(gs_device_t device,
EXPORT int device_create(gs_device_t **device, struct gs_init_data *data);
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 gs_swapchain_t *device_swapchain_create(gs_device_t *device,
struct gs_init_data *data);
EXPORT void device_resize(gs_device_t device, uint32_t x, uint32_t y);
EXPORT void device_get_size(gs_device_t device, uint32_t *x, uint32_t *y);
EXPORT uint32_t device_get_width(gs_device_t device);
EXPORT uint32_t device_get_height(gs_device_t device);
EXPORT gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
EXPORT void device_resize(gs_device_t *device, uint32_t x, uint32_t y);
EXPORT void device_get_size(gs_device_t *device, uint32_t *x, uint32_t *y);
EXPORT uint32_t device_get_width(gs_device_t *device);
EXPORT uint32_t device_get_height(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,
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 **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 **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,
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,
EXPORT gs_samplerstate_t *device_samplerstate_create(gs_device_t *device,
struct gs_sampler_info *info);
EXPORT gs_shader_t device_vertexshader_create(gs_device_t device,
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,
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,
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,
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 enum gs_texture_type device_get_texture_type(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_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,
EXPORT enum gs_texture_type device_get_texture_type(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 gs_shader_t device_get_vertex_shader(gs_device_t device);
EXPORT gs_shader_t device_get_pixel_shader(gs_device_t device);
EXPORT gs_texture_t device_get_render_target(gs_device_t device);
EXPORT gs_zstencil_t device_get_zstencil_target(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_cube_render_target(gs_device_t device,
gs_texture_t cubetex,
int side, gs_zstencil_t zstencil);
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,
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(gs_device_t *device);
EXPORT gs_shader_t *device_get_pixel_shader(gs_device_t *device);
EXPORT gs_texture_t *device_get_render_target(gs_device_t *device);
EXPORT gs_zstencil_t *device_get_zstencil_target(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_cube_render_target(gs_device_t *device,
gs_texture_t *cubetex,
int side, gs_zstencil_t *zstencil);
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_scene(gs_device_t device);
EXPORT void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
EXPORT void device_stage_texture(gs_device_t *device, gs_stagesurf_t *dst,
gs_texture_t *src);
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,
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,
struct vec4 *color, float depth, uint8_t stencil);
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(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,
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(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,
EXPORT void device_blend_function(gs_device_t *device, enum gs_blend_type src,
enum gs_blend_type dest);
EXPORT void device_depth_function(gs_device_t device, enum gs_depth_test test);
EXPORT void device_stencil_function(gs_device_t device,
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,
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_enable_fullscreen(gs_device_t device, bool enable);
EXPORT int device_fullscreen_enabled(gs_device_t device);
EXPORT void device_setdisplaymode(gs_device_t device,
EXPORT void device_enable_fullscreen(gs_device_t *device, bool enable);
EXPORT int device_fullscreen_enabled(gs_device_t *device);
EXPORT void device_setdisplaymode(gs_device_t *device,
const struct gs_display_mode *mode);
EXPORT void device_getdisplaymode(gs_device_t device,
EXPORT void device_getdisplaymode(gs_device_t *device,
struct gs_display_mode *mode);
EXPORT void device_setcolorramp(gs_device_t device, float gamma,
EXPORT void device_setcolorramp(gs_device_t *device, float gamma,
float brightness, float contrast);
EXPORT void device_set_viewport(gs_device_t device, int x, int y, int width,
EXPORT void device_set_viewport(gs_device_t *device, int x, int y, int width,
int height);
EXPORT void device_get_viewport(gs_device_t device, struct gs_rect *rect);
EXPORT void device_set_scissor_rect(gs_device_t device, struct gs_rect *rect);
EXPORT void device_ortho(gs_device_t device, float left, float right,
EXPORT void device_get_viewport(gs_device_t *device, struct gs_rect *rect);
EXPORT void device_set_scissor_rect(gs_device_t *device, 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,
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_projection_push(gs_device_t *device);
EXPORT void device_projection_pop(gs_device_t *device);
#ifdef __cplusplus
}

6
libobs/graphics/effect-parser.c
View File

@@ -919,7 +919,7 @@ static bool ep_compile(struct effect_parser *ep);
extern const char *gs_preprocessor_name(void);
bool ep_parse(struct effect_parser *ep, gs_effect_t effect,
bool ep_parse(struct effect_parser *ep, gs_effect_t *effect,
const char *effect_string, const char *file)
{
bool success;
@@ -1320,7 +1320,7 @@ static void ep_compile_param(struct effect_parser *ep, size_t idx)
static bool ep_compile_pass_shaderparams(struct effect_parser *ep,
struct darray *pass_params, struct darray *used_params,
gs_shader_t shader)
gs_shader_t *shader)
{
size_t i;
darray_resize(sizeof(struct pass_shaderparam), pass_params,
@@ -1357,7 +1357,7 @@ static inline bool ep_compile_pass_shader(struct effect_parser *ep,
struct dstr location;
struct darray used_params; /* struct dstr */
struct darray *pass_params = NULL; /* struct pass_shaderparam */
gs_shader_t shader = NULL;
gs_shader_t *shader = NULL;
bool success = true;
dstr_init(&shader_str);

4
libobs/graphics/effect-parser.h
View File

@@ -243,7 +243,7 @@ static inline void ep_func_free(struct ep_func *epf)
/* ------------------------------------------------------------------------- */
struct effect_parser {
gs_effect_t effect;
gs_effect_t *effect;
DARRAY(struct ep_param) params;
DARRAY(struct ep_struct) structs;
@@ -275,7 +275,7 @@ static inline void ep_init(struct effect_parser *ep)
extern void ep_free(struct effect_parser *ep);
extern bool ep_parse(struct effect_parser *ep, gs_effect_t effect,
extern bool ep_parse(struct effect_parser *ep, gs_effect_t *effect,
const char *effect_string, const char *file);
#ifdef __cplusplus

54
libobs/graphics/effect.c
View File

@@ -21,7 +21,7 @@
#include "vec3.h"
#include "vec4.h"
void gs_effect_destroy(gs_effect_t effect)
void gs_effect_destroy(gs_effect_t *effect)
{
if (effect) {
effect_free(effect);
@@ -29,7 +29,7 @@ void gs_effect_destroy(gs_effect_t effect)
}
}
gs_technique_t gs_effect_get_technique(gs_effect_t effect, const char *name)
gs_technique_t *gs_effect_get_technique(gs_effect_t *effect, const char *name)
{
if (!effect) return NULL;
@@ -42,7 +42,7 @@ gs_technique_t gs_effect_get_technique(gs_effect_t effect, const char *name)
return NULL;
}
size_t gs_technique_begin(gs_technique_t tech)
size_t gs_technique_begin(gs_technique_t *tech)
{
if (!tech) return 0;
@@ -52,7 +52,7 @@ size_t gs_technique_begin(gs_technique_t tech)
return tech->passes.num;
}
void gs_technique_end(gs_technique_t tech)
void gs_technique_end(gs_technique_t *tech)
{
if (!tech) return;
@@ -91,7 +91,7 @@ static void upload_shader_params(struct darray *pass_params, bool changed_only)
for (i = 0; i < pass_params->num; i++) {
struct pass_shaderparam *param = params+i;
struct gs_effect_param *eparam = param->eparam;
gs_sparam_t sparam = param->sparam;
gs_sparam_t *sparam = param->sparam;
if (changed_only && !eparam->changed)
continue;
@@ -125,13 +125,13 @@ static inline void upload_parameters(struct gs_effect *effect,
reset_params(pshader_params);
}
void gs_effect_update_params(gs_effect_t effect)
void gs_effect_update_params(gs_effect_t *effect)
{
if (effect)
upload_parameters(effect, true);
}
bool gs_technique_begin_pass(gs_technique_t tech, size_t idx)
bool gs_technique_begin_pass(gs_technique_t *tech, size_t idx)
{
struct gs_effect_pass *passes;
struct gs_effect_pass *cur_pass;
@@ -150,7 +150,7 @@ bool gs_technique_begin_pass(gs_technique_t tech, size_t idx)
return true;
}
bool gs_technique_begin_pass_by_name(gs_technique_t tech,
bool gs_technique_begin_pass_by_name(gs_technique_t *tech,
const char *name)
{
if (!tech)
@@ -181,7 +181,7 @@ static inline void clear_tex_params(struct darray *in_params)
}
}
void gs_technique_end_pass(gs_technique_t tech)
void gs_technique_end_pass(gs_technique_t *tech)
{
if (!tech) return;
@@ -194,12 +194,12 @@ void gs_technique_end_pass(gs_technique_t tech)
tech->effect->cur_pass = NULL;
}
size_t gs_effect_get_num_params(gs_effect_t effect)
size_t gs_effect_get_num_params(gs_effect_t *effect)
{
return effect ? effect->params.num : 0;
}
gs_eparam_t gs_effect_get_param_by_idx(gs_effect_t effect, size_t param)
gs_eparam_t *gs_effect_get_param_by_idx(gs_effect_t *effect, size_t param)
{
if (!effect) return NULL;
@@ -210,7 +210,7 @@ gs_eparam_t gs_effect_get_param_by_idx(gs_effect_t effect, size_t param)
return params+param;
}
gs_eparam_t gs_effect_get_param_by_name(gs_effect_t effect, const char *name)
gs_eparam_t *gs_effect_get_param_by_name(gs_effect_t *effect, const char *name)
{
if (!effect) return NULL;
@@ -226,17 +226,17 @@ gs_eparam_t gs_effect_get_param_by_name(gs_effect_t effect, const char *name)
return NULL;
}
gs_eparam_t gs_effect_get_viewproj_matrix(gs_effect_t effect)
gs_eparam_t *gs_effect_get_viewproj_matrix(gs_effect_t *effect)
{
return effect ? effect->view_proj : NULL;
}
gs_eparam_t gs_effect_get_world_matrix(gs_effect_t effect)
gs_eparam_t *gs_effect_get_world_matrix(gs_effect_t *effect)
{
return effect ? effect->world : NULL;
}
void gs_effect_get_param_info(gs_eparam_t param,
void gs_effect_get_param_info(gs_eparam_t *param,
struct gs_effect_param_info *info)
{
if (!param)
@@ -246,7 +246,7 @@ void gs_effect_get_param_info(gs_eparam_t param,
info->type = param->type;
}
static inline void effect_setval_inline(gs_eparam_t param,
static inline void effect_setval_inline(gs_eparam_t *param,
const void *data, size_t size)
{
bool size_changed;
@@ -272,52 +272,52 @@ static inline void effect_setval_inline(gs_eparam_t param,
}
}
void gs_effect_set_bool(gs_eparam_t param, bool val)
void gs_effect_set_bool(gs_eparam_t *param, bool val)
{
effect_setval_inline(param, &val, sizeof(bool));
}
void gs_effect_set_float(gs_eparam_t param, float val)
void gs_effect_set_float(gs_eparam_t *param, float val)
{
effect_setval_inline(param, &val, sizeof(float));
}
void gs_effect_set_int(gs_eparam_t param, int val)
void gs_effect_set_int(gs_eparam_t *param, int val)
{
effect_setval_inline(param, &val, sizeof(int));
}
void gs_effect_set_matrix4(gs_eparam_t param, const struct matrix4 *val)
void gs_effect_set_matrix4(gs_eparam_t *param, const struct matrix4 *val)
{
effect_setval_inline(param, val, sizeof(struct matrix4));
}
void gs_effect_set_vec2(gs_eparam_t param, const struct vec2 *val)
void gs_effect_set_vec2(gs_eparam_t *param, const struct vec2 *val)
{
effect_setval_inline(param, val, sizeof(struct vec2));
}
void gs_effect_set_vec3(gs_eparam_t param, const struct vec3 *val)
void gs_effect_set_vec3(gs_eparam_t *param, const struct vec3 *val)
{
effect_setval_inline(param, val, sizeof(float) * 3);
}
void gs_effect_set_vec4(gs_eparam_t param, const struct vec4 *val)
void gs_effect_set_vec4(gs_eparam_t *param, const struct vec4 *val)
{
effect_setval_inline(param, val, sizeof(struct vec4));
}
void gs_effect_set_texture(gs_eparam_t param, gs_texture_t val)
void gs_effect_set_texture(gs_eparam_t *param, gs_texture_t *val)
{
effect_setval_inline(param, &val, sizeof(gs_texture_t));
effect_setval_inline(param, &val, sizeof(gs_texture_t*));
}
void gs_effect_set_val(gs_eparam_t param, const void *val, size_t size)
void gs_effect_set_val(gs_eparam_t *param, const void *val, size_t size)
{
effect_setval_inline(param, val, size);
}
void gs_effect_set_default(gs_eparam_t param)
void gs_effect_set_default(gs_eparam_t *param)
{
effect_setval_inline(param, param->default_val.array,
param->default_val.num);

25
libobs/graphics/effect.h
View File

@@ -56,7 +56,7 @@ struct gs_effect_param {
DARRAY(uint8_t) cur_val;
DARRAY(uint8_t) default_val;
gs_effect_t effect;
gs_effect_t *effect;
/*char *full_name;
float scroller_min, scroller_max, scroller_inc, scroller_mul;*/
@@ -75,22 +75,22 @@ static inline void effect_param_free(struct gs_effect_param *param)
da_free(param->default_val);
}
EXPORT void effect_param_parse_property(gs_eparam_t param,
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;
gs_sparam_t *sparam;
};
struct gs_effect_pass {
char *name;
enum effect_section section;
gs_shader_t vertshader;
gs_shader_t pixelshader;
gs_shader_t *vertshader;
gs_shader_t *pixelshader;
DARRAY(struct pass_shaderparam) vertshader_params;
DARRAY(struct pass_shaderparam) pixelshader_params;
};
@@ -145,16 +145,16 @@ struct gs_effect {
struct gs_effect_technique *cur_technique;
struct gs_effect_pass *cur_pass;
gs_eparam_t view_proj, world, scale;
graphics_t graphics;
gs_eparam_t *view_proj, *world, *scale;
graphics_t *graphics;
};
static inline void effect_init(gs_effect_t effect)
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)
static inline void effect_free(gs_effect_t *effect)
{
size_t i;
for (i = 0; i < effect->params.num; i++)
@@ -171,9 +171,10 @@ static inline void effect_free(gs_effect_t effect)
effect->effect_dir = NULL;
}
EXPORT void effect_upload_params(gs_effect_t effect, bool changed_only);
EXPORT void effect_upload_shader_params(gs_effect_t effect, gs_shader_t shader,
struct darray *pass_params, bool changed_only);
EXPORT void effect_upload_params(gs_effect_t *effect, bool changed_only);
EXPORT void effect_upload_shader_params(gs_effect_t *effect,
gs_shader_t *shader, struct darray *pass_params,
bool changed_only);
#ifdef __cplusplus
}

4
libobs/graphics/graphics-ffmpeg.c
View File

@@ -201,10 +201,10 @@ static inline enum gs_color_format convert_format(enum AVPixelFormat format)
return GS_BGRX;
}
gs_texture_t gs_texture_create_from_file(const char *file)
gs_texture_t *gs_texture_create_from_file(const char *file)
{
struct ffmpeg_image image;
gs_texture_t tex = NULL;
gs_texture_t *tex = NULL;
if (ffmpeg_image_init(&image, file)) {
uint8_t *data = malloc(image.cx * image.cy * 4);

268
libobs/graphics/graphics-internal.h
View File

@@ -27,205 +27,207 @@ struct gs_exports {
const char *(*device_get_name)(void);
int (*device_get_type)(void);
const char *(*device_preprocessor_name)(void);
int (*device_create)(gs_device_t *device, struct gs_init_data *data);
void (*device_destroy)(gs_device_t device);
void (*device_enter_context)(gs_device_t device);
void (*device_leave_context)(gs_device_t device);
gs_swapchain_t (*device_swapchain_create)(gs_device_t device,
int (*device_create)(gs_device_t **device, struct gs_init_data *data);
void (*device_destroy)(gs_device_t *device);
void (*device_enter_context)(gs_device_t *device);
void (*device_leave_context)(gs_device_t *device);
gs_swapchain_t *(*device_swapchain_create)(gs_device_t *device,
struct gs_init_data *data);
void (*device_resize)(gs_device_t device, uint32_t x, uint32_t y);
void (*device_get_size)(gs_device_t device, uint32_t *x, uint32_t *y);
uint32_t (*device_get_width)(gs_device_t device);
uint32_t (*device_get_height)(gs_device_t device);
gs_texture_t (*device_texture_create)(gs_device_t device,
void (*device_resize)(gs_device_t *device, uint32_t x, uint32_t y);
void (*device_get_size)(gs_device_t *device, uint32_t *x, uint32_t *y);
uint32_t (*device_get_width)(gs_device_t *device);
uint32_t (*device_get_height)(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,
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,
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 **data, uint32_t flags);
gs_zstencil_t (*device_zstencil_create)(gs_device_t device,
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,
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,
gs_samplerstate_t *(*device_samplerstate_create)(gs_device_t *device,
struct gs_sampler_info *info);
gs_shader_t (*device_vertexshader_create)(gs_device_t device,
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,
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,
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,
gs_indexbuffer_t *(*device_indexbuffer_create)(gs_device_t *device,
enum gs_index_type type, void *indices, size_t num,
uint32_t flags);
enum gs_texture_type (*device_get_texture_type)(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,
enum gs_texture_type (*device_get_texture_type)(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,
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)(gs_device_t device);
gs_shader_t (*device_get_pixel_shader)(gs_device_t device);
gs_texture_t (*device_get_render_target)(gs_device_t device);
gs_zstencil_t (*device_get_zstencil_target)(gs_device_t device);
void (*device_set_render_target)(gs_device_t device, gs_texture_t tex,
gs_zstencil_t zstencil);
void (*device_set_cube_render_target)(gs_device_t device,
gs_texture_t cubetex, int side, gs_zstencil_t zstencil);
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,
gs_shader_t *(*device_get_vertex_shader)(gs_device_t *device);
gs_shader_t *(*device_get_pixel_shader)(gs_device_t *device);
gs_texture_t *(*device_get_render_target)(gs_device_t *device);
gs_zstencil_t *(*device_get_zstencil_target)(gs_device_t *device);
void (*device_set_render_target)(gs_device_t *device, gs_texture_t *tex,
gs_zstencil_t *zstencil);
void (*device_set_cube_render_target)(gs_device_t *device,
gs_texture_t *cubetex, int side, gs_zstencil_t *zstencil);
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_scene)(gs_device_t device);
void (*device_draw)(gs_device_t device, enum gs_draw_mode draw_mode,
void (*device_stage_texture)(gs_device_t *device, gs_stagesurf_t *dst,
gs_texture_t *src);
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,
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,
struct vec4 *color, float depth, uint8_t stencil);
void (*device_present)(gs_device_t device);
void (*device_flush)(gs_device_t device);
void (*device_set_cull_mode)(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)(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,
enum gs_cull_mode (*device_get_cull_mode)(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,
void (*device_blend_function)(gs_device_t *device,
enum gs_blend_type src, enum gs_blend_type dest);
void (*device_depth_function)(gs_device_t device,
void (*device_depth_function)(gs_device_t *device,
enum gs_depth_test test);
void (*device_stencil_function)(gs_device_t device,
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,
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)(gs_device_t device, struct gs_rect *rect);
void (*device_set_scissor_rect)(gs_device_t device,
void (*device_set_viewport)(gs_device_t *device, int x, int y,
int width, int height);
void (*device_get_viewport)(gs_device_t *device, struct gs_rect *rect);
void (*device_set_scissor_rect)(gs_device_t *device,
struct gs_rect *rect);
void (*device_ortho)(gs_device_t device, float left, float right,
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,
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 (*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_swapchain_destroy)(gs_swapchain_t *swapchain);
void (*gs_texture_destroy)(gs_texture_t tex);
uint32_t (*gs_texture_get_width)(gs_texture_t tex);
uint32_t (*gs_texture_get_height)(gs_texture_t tex);
enum gs_color_format (*gs_texture_get_color_format)(gs_texture_t tex);
bool (*gs_texture_map)(gs_texture_t tex, uint8_t **ptr,
void (*gs_texture_destroy)(gs_texture_t *tex);
uint32_t (*gs_texture_get_width)(gs_texture_t *tex);
uint32_t (*gs_texture_get_height)(gs_texture_t *tex);
enum gs_color_format (*gs_texture_get_color_format)(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)(gs_texture_t tex);
void *(*gs_texture_get_obj)(gs_texture_t tex);
void (*gs_texture_unmap)(gs_texture_t *tex);
bool (*gs_texture_is_rect)(gs_texture_t *tex);
void *(*gs_texture_get_obj)(gs_texture_t *tex);
void (*gs_cubetexture_destroy)(gs_texture_t cubetex);
uint32_t (*gs_cubetexture_get_size)(gs_texture_t cubetex);
void (*gs_cubetexture_destroy)(gs_texture_t *cubetex);
uint32_t (*gs_cubetexture_get_size)(gs_texture_t *cubetex);
enum gs_color_format (*gs_cubetexture_get_color_format)(
gs_texture_t cubetex);
gs_texture_t *cubetex);
void (*gs_voltexture_destroy)(gs_texture_t voltex);
uint32_t (*gs_voltexture_get_width)(gs_texture_t voltex);
uint32_t (*gs_voltexture_get_height)(gs_texture_t voltex);
uint32_t (*gs_voltexture_getdepth)(gs_texture_t voltex);
void (*gs_voltexture_destroy)(gs_texture_t *voltex);
uint32_t (*gs_voltexture_get_width)(gs_texture_t *voltex);
uint32_t (*gs_voltexture_get_height)(gs_texture_t *voltex);
uint32_t (*gs_voltexture_getdepth)(gs_texture_t *voltex);
enum gs_color_format (*gs_voltexture_get_color_format)(
gs_texture_t voltex);
gs_texture_t *voltex);
void (*gs_stagesurface_destroy)(gs_stagesurf_t stagesurf);
uint32_t (*gs_stagesurface_get_width)(gs_stagesurf_t stagesurf);
uint32_t (*gs_stagesurface_get_height)(gs_stagesurf_t stagesurf);
void (*gs_stagesurface_destroy)(gs_stagesurf_t *stagesurf);
uint32_t (*gs_stagesurface_get_width)(gs_stagesurf_t *stagesurf);
uint32_t (*gs_stagesurface_get_height)(gs_stagesurf_t *stagesurf);
enum gs_color_format (*gs_stagesurface_get_color_format)(
gs_stagesurf_t stagesurf);
bool (*gs_stagesurface_map)(gs_stagesurf_t stagesurf,
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_stagesurface_unmap)(gs_stagesurf_t *stagesurf);
void (*gs_zstencil_destroy)(gs_zstencil_t zstencil);
void (*gs_zstencil_destroy)(gs_zstencil_t *zstencil);
void (*gs_samplerstate_destroy)(gs_samplerstate_t samplerstate);
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_destroy)(gs_vertbuffer_t *vertbuffer);
void (*gs_vertexbuffer_flush)(gs_vertbuffer_t *vertbuffer);
struct gs_vb_data *(*gs_vertexbuffer_get_data)(
gs_vertbuffer_t vertbuffer);
gs_vertbuffer_t *vertbuffer);
void (*gs_indexbuffer_destroy)(gs_indexbuffer_t indexbuffer);
void (*gs_indexbuffer_flush)(gs_indexbuffer_t indexbuffer);
void *(*gs_indexbuffer_get_data)(gs_indexbuffer_t indexbuffer);
size_t (*gs_indexbuffer_get_num_indices)(gs_indexbuffer_t indexbuffer);
void (*gs_indexbuffer_destroy)(gs_indexbuffer_t *indexbuffer);
void (*gs_indexbuffer_flush)(gs_indexbuffer_t *indexbuffer);
void *(*gs_indexbuffer_get_data)(gs_indexbuffer_t *indexbuffer);
size_t (*gs_indexbuffer_get_num_indices)(gs_indexbuffer_t *indexbuffer);
enum gs_index_type (*gs_indexbuffer_get_type)(
gs_indexbuffer_t indexbuffer);
gs_indexbuffer_t *indexbuffer);
void (*gs_shader_destroy)(gs_shader_t shader);
int (*gs_shader_get_num_params)(gs_shader_t shader);
gs_sparam_t (*gs_shader_get_param_by_idx)(gs_shader_t shader,
void (*gs_shader_destroy)(gs_shader_t *shader);
int (*gs_shader_get_num_params)(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,
gs_sparam_t *(*gs_shader_get_param_by_name)(gs_shader_t *shader,
const char *name);
gs_sparam_t (*gs_shader_get_viewproj_matrix)(gs_shader_t shader);
gs_sparam_t (*gs_shader_get_world_matrix)(gs_shader_t shader);
void (*gs_shader_get_param_info)(gs_sparam_t param,
gs_sparam_t *(*gs_shader_get_viewproj_matrix)(gs_shader_t *shader);
gs_sparam_t *(*gs_shader_get_world_matrix)(gs_shader_t *shader);
void (*gs_shader_get_param_info)(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_setmatrix3)(gs_sparam_t param,
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_setmatrix3)(gs_sparam_t *param,
const struct matrix3 *val);
void (*gs_shader_set_matrix4)(gs_sparam_t param,
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,
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_default)(gs_sparam_t *param);
#ifdef __APPLE__
/* OSX/Cocoa specific functions */
gs_texture_t (*device_texture_create_from_iosurface)(gs_device_t dev,
gs_texture_t *(*device_texture_create_from_iosurface)(gs_device_t *dev,
void *iosurf);
bool (*gs_texture_rebind_iosurface)(gs_texture_t *texture,
void *iosurf);
bool (*gs_texture_rebind_iosurface)(gs_texture_t texture, void *iosurf);
#elif _WIN32
bool (*device_gdi_texture_available)(void);
gs_texture_t (*device_texture_create_gdi)(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);
void *(*gs_texture_get_dc)(gs_texture_t *gdi_tex);
void (*gs_texture_release_dc)(gs_texture_t *gdi_tex);
#endif
};
@@ -237,7 +239,7 @@ struct blend_state {
struct graphics_subsystem {
void *module;
gs_device_t device;
gs_device_t *device;
struct gs_exports exports;
DARRAY(struct gs_rect) viewport_stack;
@@ -248,11 +250,11 @@ struct graphics_subsystem {
struct matrix4 projection;
struct gs_effect *cur_effect;
gs_vertbuffer_t sprite_buffer;
gs_vertbuffer_t *sprite_buffer;
bool using_immediate;
struct gs_vb_data *vbd;
gs_vertbuffer_t immediate_vertbuffer;
gs_vertbuffer_t *immediate_vertbuffer;
DARRAY(struct vec3) verts;
DARRAY(struct vec3) norms;
DARRAY(uint32_t) colors;

4
libobs/graphics/graphics-magick.c
View File

@@ -14,9 +14,9 @@ void gs_free_image_deps()
MagickCoreTerminus();
}
gs_texture_t gs_texture_create_from_file(const char *file)
gs_texture_t *gs_texture_create_from_file(const char *file)
{
gs_texture_t tex = NULL;
gs_texture_t *tex = NULL;
ImageInfo *info;
ExceptionInfo *exception;
Image *image;

458
libobs/graphics/graphics.c
View File

File diff suppressed because it is too large Load Diff

298
libobs/graphics/graphics.h
View File

@@ -247,21 +247,21 @@ struct gs_effect_param;
struct gs_device;
struct graphics_subsystem;
typedef struct gs_texture *gs_texture_t;
typedef struct gs_stage_surface *gs_stagesurf_t;
typedef struct gs_zstencil_buffer *gs_zstencil_t;
typedef struct gs_vertex_buffer *gs_vertbuffer_t;
typedef struct gs_index_buffer *gs_indexbuffer_t;
typedef struct gs_sampler_state *gs_samplerstate_t;
typedef struct gs_swap_chain *gs_swapchain_t;
typedef struct gs_texture_render *gs_texrender_t;
typedef struct gs_shader *gs_shader_t;
typedef struct gs_shader_param *gs_sparam_t;
typedef struct gs_effect *gs_effect_t;
typedef struct gs_effect_technique *gs_technique_t;
typedef struct gs_effect_param *gs_eparam_t;
typedef struct gs_device *gs_device_t;
typedef struct graphics_subsystem *graphics_t;
typedef struct gs_texture gs_texture_t;
typedef struct gs_stage_surface gs_stagesurf_t;
typedef struct gs_zstencil_buffer gs_zstencil_t;
typedef struct gs_vertex_buffer gs_vertbuffer_t;
typedef struct gs_index_buffer gs_indexbuffer_t;
typedef struct gs_sampler_state gs_samplerstate_t;
typedef struct gs_swap_chain gs_swapchain_t;
typedef struct gs_texture_render gs_texrender_t;
typedef struct gs_shader gs_shader_t;
typedef struct gs_shader_param gs_sparam_t;
typedef struct gs_effect gs_effect_t;
typedef struct gs_effect_technique gs_technique_t;
typedef struct gs_effect_param gs_eparam_t;
typedef struct gs_device gs_device_t;
typedef struct graphics_subsystem graphics_t;
/* ---------------------------------------------------
* shader functions
@@ -290,30 +290,30 @@ enum gs_shader_type {
GS_SHADER_PIXEL,
};
EXPORT void gs_shader_destroy(gs_shader_t shader);
EXPORT void gs_shader_destroy(gs_shader_t *shader);
EXPORT int gs_shader_get_num_params(gs_shader_t shader);
EXPORT gs_sparam_t gs_shader_get_param_by_idx(gs_shader_t shader,
EXPORT int gs_shader_get_num_params(gs_shader_t *shader);
EXPORT gs_sparam_t *gs_shader_get_param_by_idx(gs_shader_t *shader,
uint32_t param);
EXPORT gs_sparam_t gs_shader_get_param_by_name(gs_shader_t shader,
EXPORT gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader,
const char *name);
EXPORT gs_sparam_t gs_shader_get_viewproj_matrix(gs_shader_t shader);
EXPORT gs_sparam_t gs_shader_get_world_matrix(gs_shader_t shader);
EXPORT gs_sparam_t *gs_shader_get_viewproj_matrix(gs_shader_t *shader);
EXPORT gs_sparam_t *gs_shader_get_world_matrix(gs_shader_t *shader);
EXPORT void gs_shader_get_param_info(gs_sparam_t param,
EXPORT void gs_shader_get_param_info(gs_sparam_t *param,
struct gs_shader_param_info *info);
EXPORT void gs_shader_set_bool(gs_sparam_t param, bool val);
EXPORT void gs_shader_set_float(gs_sparam_t param, float val);
EXPORT void gs_shader_set_int(gs_sparam_t param, int val);
EXPORT void gs_shader_setmatrix3(gs_sparam_t param, const struct matrix3 *val);
EXPORT void gs_shader_set_matrix4(gs_sparam_t param, const struct matrix4 *val);
EXPORT void gs_shader_set_vec2(gs_sparam_t param, const struct vec2 *val);
EXPORT void gs_shader_set_vec3(gs_sparam_t param, const struct vec3 *val);
EXPORT void gs_shader_set_vec4(gs_sparam_t param, const struct vec4 *val);
EXPORT void gs_shader_set_texture(gs_sparam_t param, gs_texture_t val);
EXPORT void gs_shader_set_val(gs_sparam_t param, const void *val, size_t size);
EXPORT void gs_shader_set_default(gs_sparam_t param);
EXPORT void gs_shader_set_bool(gs_sparam_t *param, bool val);
EXPORT void gs_shader_set_float(gs_sparam_t *param, float val);
EXPORT void gs_shader_set_int(gs_sparam_t *param, int val);
EXPORT void gs_shader_setmatrix3(gs_sparam_t *param, const struct matrix3 *val);
EXPORT void gs_shader_set_matrix4(gs_sparam_t *param, const struct matrix4 *val);
EXPORT void gs_shader_set_vec2(gs_sparam_t *param, const struct vec2 *val);
EXPORT void gs_shader_set_vec3(gs_sparam_t *param, const struct vec3 *val);
EXPORT void gs_shader_set_vec4(gs_sparam_t *param, const struct vec4 *val);
EXPORT void gs_shader_set_texture(gs_sparam_t *param, gs_texture_t *val);
EXPORT void gs_shader_set_val(gs_sparam_t *param, const void *val, size_t size);
EXPORT void gs_shader_set_default(gs_sparam_t *param);
/* ---------------------------------------------------
* effect functions
@@ -337,54 +337,55 @@ struct gs_effect_param_info {
float min, max, inc, mul; */
};
EXPORT void gs_effect_destroy(gs_effect_t effect);
EXPORT void gs_effect_destroy(gs_effect_t *effect);
EXPORT gs_technique_t gs_effect_get_technique(gs_effect_t effect,
EXPORT gs_technique_t *gs_effect_get_technique(gs_effect_t *effect,
const char *name);
EXPORT size_t gs_technique_begin(gs_technique_t technique);
EXPORT void gs_technique_end(gs_technique_t technique);
EXPORT bool gs_technique_begin_pass(gs_technique_t technique, size_t pass);
EXPORT bool gs_technique_begin_pass_by_name(gs_technique_t technique,
EXPORT size_t gs_technique_begin(gs_technique_t *technique);
EXPORT void gs_technique_end(gs_technique_t *technique);
EXPORT bool gs_technique_begin_pass(gs_technique_t *technique, size_t pass);
EXPORT bool gs_technique_begin_pass_by_name(gs_technique_t *technique,
const char *name);
EXPORT void gs_technique_end_pass(gs_technique_t technique);
EXPORT void gs_technique_end_pass(gs_technique_t *technique);
EXPORT size_t gs_effect_get_num_params(gs_effect_t effect);
EXPORT gs_eparam_t gs_effect_get_param_by_idx(gs_effect_t effect, size_t param);
EXPORT gs_eparam_t gs_effect_get_param_by_name(gs_effect_t effect,
EXPORT size_t gs_effect_get_num_params(gs_effect_t *effect);
EXPORT gs_eparam_t *gs_effect_get_param_by_idx(gs_effect_t *effect, size_t param);
EXPORT gs_eparam_t *gs_effect_get_param_by_name(gs_effect_t *effect,
const char *name);
/** used internally */
EXPORT void gs_effect_update_params(gs_effect_t effect);
EXPORT void gs_effect_update_params(gs_effect_t *effect);
EXPORT gs_eparam_t gs_effect_get_viewproj_matrix(gs_effect_t effect);
EXPORT gs_eparam_t gs_effect_get_world_matrix(gs_effect_t effect);
EXPORT gs_eparam_t *gs_effect_get_viewproj_matrix(gs_effect_t *effect);
EXPORT gs_eparam_t *gs_effect_get_world_matrix(gs_effect_t *effect);
EXPORT void gs_effect_get_param_info(gs_eparam_t param,
EXPORT void gs_effect_get_param_info(gs_eparam_t *param,
struct gs_effect_param_info *info);
EXPORT void gs_effect_set_bool(gs_eparam_t param, bool val);
EXPORT void gs_effect_set_float(gs_eparam_t param, float val);
EXPORT void gs_effect_set_int(gs_eparam_t param, int val);
EXPORT void gs_effect_set_matrix4(gs_eparam_t param, const struct matrix4 *val);
EXPORT void gs_effect_set_vec2(gs_eparam_t param, const struct vec2 *val);
EXPORT void gs_effect_set_vec3(gs_eparam_t param, const struct vec3 *val);
EXPORT void gs_effect_set_vec4(gs_eparam_t param, const struct vec4 *val);
EXPORT void gs_effect_set_texture(gs_eparam_t param, gs_texture_t val);
EXPORT void gs_effect_set_val(gs_eparam_t param, const void *val, size_t size);
EXPORT void gs_effect_set_default(gs_eparam_t param);
EXPORT void gs_effect_set_bool(gs_eparam_t *param, bool val);
EXPORT void gs_effect_set_float(gs_eparam_t *param, float val);
EXPORT void gs_effect_set_int(gs_eparam_t *param, int val);
EXPORT void gs_effect_set_matrix4(gs_eparam_t *param,
const struct matrix4 *val);
EXPORT void gs_effect_set_vec2(gs_eparam_t *param, const struct vec2 *val);
EXPORT void gs_effect_set_vec3(gs_eparam_t *param, const struct vec3 *val);
EXPORT void gs_effect_set_vec4(gs_eparam_t *param, const struct vec4 *val);
EXPORT void gs_effect_set_texture(gs_eparam_t *param, gs_texture_t *val);
EXPORT void gs_effect_set_val(gs_eparam_t *param, const void *val, size_t size);
EXPORT void gs_effect_set_default(gs_eparam_t *param);
/* ---------------------------------------------------
* texture render helper functions
* --------------------------------------------------- */
EXPORT gs_texrender_t gs_texrender_create(enum gs_color_format format,
EXPORT gs_texrender_t *gs_texrender_create(enum gs_color_format format,
enum gs_zstencil_format zsformat);
EXPORT void gs_texrender_destroy(gs_texrender_t texrender);
EXPORT bool gs_texrender_begin(gs_texrender_t texrender, uint32_t cx,
EXPORT void gs_texrender_destroy(gs_texrender_t *texrender);
EXPORT bool gs_texrender_begin(gs_texrender_t *texrender, uint32_t cx,
uint32_t cy);
EXPORT void gs_texrender_end(gs_texrender_t texrender);
EXPORT void gs_texrender_reset(gs_texrender_t texrender);
EXPORT gs_texture_t gs_texrender_get_texture(gs_texrender_t texrender);
EXPORT void gs_texrender_end(gs_texrender_t *texrender);
EXPORT void gs_texrender_reset(gs_texrender_t *texrender);
EXPORT gs_texture_t *gs_texrender_get_texture(gs_texrender_t *texrender);
/* ---------------------------------------------------
* graphics subsystem
@@ -430,13 +431,13 @@ struct gs_init_data {
EXPORT const char *gs_get_device_name(void);
EXPORT int gs_get_device_type(void);
EXPORT int gs_create(graphics_t *graphics, const char *module,
EXPORT int gs_create(graphics_t **graphics, const char *module,
struct gs_init_data *data);
EXPORT void gs_destroy(graphics_t graphics);
EXPORT void gs_destroy(graphics_t *graphics);
EXPORT void gs_enter_context(graphics_t graphics);
EXPORT void gs_enter_context(graphics_t *graphics);
EXPORT void gs_leave_context(void);
EXPORT graphics_t gs_get_context(void);
EXPORT graphics_t *gs_get_context(void);
EXPORT void gs_matrix_push(void);
EXPORT void gs_matrix_pop(void);
@@ -455,7 +456,7 @@ EXPORT void gs_matrix_scale3f(float x, float y, float z);
EXPORT void gs_render_start(bool b_new);
EXPORT void gs_render_stop(enum gs_draw_mode mode);
EXPORT gs_vertbuffer_t gs_render_save(void);
EXPORT gs_vertbuffer_t *gs_render_save(void);
EXPORT void gs_vertex2f(float x, float y);
EXPORT void gs_vertex3f(float x, float y, float z);
EXPORT void gs_normal3f(float x, float y, float z);
@@ -467,20 +468,20 @@ EXPORT void gs_normal3v(const struct vec3 *v);
EXPORT void gs_color4v(const struct vec4 *v);
EXPORT void gs_texcoord2v(const struct vec2 *v, int unit);
EXPORT input_t gs_get_input(void);
EXPORT gs_effect_t gs_get_effect(void);
EXPORT input_t *gs_get_input(void);
EXPORT gs_effect_t *gs_get_effect(void);
EXPORT gs_effect_t gs_effect_create_from_file(const char *file,
EXPORT gs_effect_t *gs_effect_create_from_file(const char *file,
char **error_string);
EXPORT gs_effect_t gs_effect_create(const char *effect_string,
EXPORT gs_effect_t *gs_effect_create(const char *effect_string,
const char *filename, char **error_string);
EXPORT gs_shader_t gs_vertexshader_create_from_file(const char *file,
EXPORT gs_shader_t *gs_vertexshader_create_from_file(const char *file,
char **error_string);
EXPORT gs_shader_t gs_pixelshader_create_from_file(const char *file,
EXPORT gs_shader_t *gs_pixelshader_create_from_file(const char *file,
char **error_string);
EXPORT gs_texture_t gs_texture_create_from_file(const char *file);
EXPORT gs_texture_t *gs_texture_create_from_file(const char *file);
#define GS_FLIP_U (1<<0)
#define GS_FLIP_V (1<<1)
@@ -492,10 +493,10 @@ EXPORT gs_texture_t gs_texture_create_from_file(const char *file);
* The flip value specifies whether the texture shoudl be flipped on the U or V
* axis with GS_FLIP_U and GS_FLIP_V.
*/
EXPORT void gs_draw_sprite(gs_texture_t tex, uint32_t flip, uint32_t width,
EXPORT void gs_draw_sprite(gs_texture_t *tex, uint32_t flip, uint32_t width,
uint32_t height);
EXPORT void gs_draw_cube_backdrop(gs_texture_t cubetex, const struct quat *rot,
EXPORT void gs_draw_cube_backdrop(gs_texture_t *cubetex, const struct quat *rot,
float left, float right, float top, float bottom, float znear);
/** sets the viewport to current swap chain size */
@@ -509,9 +510,9 @@ EXPORT void gs_set_3d_mode(double fovy, double znear, double zvar);
EXPORT void gs_viewport_push(void);
EXPORT void gs_viewport_pop(void);
EXPORT void gs_texture_set_image(gs_texture_t tex, const uint8_t *data,
EXPORT void gs_texture_set_image(gs_texture_t *tex, const uint8_t *data,
uint32_t linesize, bool invert);
EXPORT void gs_cubetexture_set_image(gs_texture_t cubetex, uint32_t side,
EXPORT void gs_cubetexture_set_image(gs_texture_t *cubetex, uint32_t side,
const void *data, uint32_t linesize, bool invert);
EXPORT void gs_perspective(float fovy, float aspect, float znear, float zfar);
@@ -521,68 +522,68 @@ EXPORT void gs_reset_blend_state(void);
/* -------------------------- */
/* library-specific functions */
EXPORT gs_swapchain_t gs_swapchain_create(struct gs_init_data *data);
EXPORT gs_swapchain_t *gs_swapchain_create(struct gs_init_data *data);
EXPORT void gs_resize(uint32_t x, uint32_t y);
EXPORT void gs_get_size(uint32_t *x, uint32_t *y);
EXPORT uint32_t gs_get_width(void);
EXPORT uint32_t gs_get_height(void);
EXPORT gs_texture_t gs_texture_create(uint32_t width, uint32_t height,
EXPORT gs_texture_t *gs_texture_create(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 gs_cubetexture_create(uint32_t size,
EXPORT gs_texture_t *gs_cubetexture_create(uint32_t size,
enum gs_color_format color_format, uint32_t levels,
const uint8_t **data, uint32_t flags);
EXPORT gs_texture_t gs_voltexture_create(uint32_t width, uint32_t height,
EXPORT gs_texture_t *gs_voltexture_create(uint32_t width, uint32_t height,
uint32_t depth, enum gs_color_format color_format,
uint32_t levels, const uint8_t **data, uint32_t flags);
EXPORT gs_zstencil_t gs_zstencil_create(uint32_t width, uint32_t height,
EXPORT gs_zstencil_t *gs_zstencil_create(uint32_t width, uint32_t height,
enum gs_zstencil_format format);
EXPORT gs_stagesurf_t gs_stagesurface_create(uint32_t width, uint32_t height,
EXPORT gs_stagesurf_t *gs_stagesurface_create(uint32_t width, uint32_t height,
enum gs_color_format color_format);
EXPORT gs_samplerstate_t gs_samplerstate_create(struct gs_sampler_info *info);
EXPORT gs_samplerstate_t *gs_samplerstate_create(struct gs_sampler_info *info);
EXPORT gs_shader_t gs_vertexshader_create(const char *shader,
EXPORT gs_shader_t *gs_vertexshader_create(const char *shader,
const char *file, char **error_string);
EXPORT gs_shader_t gs_pixelshader_create(const char *shader,
EXPORT gs_shader_t *gs_pixelshader_create(const char *shader,
const char *file, char **error_string);
EXPORT gs_vertbuffer_t gs_vertexbuffer_create(struct gs_vb_data *data,
EXPORT gs_vertbuffer_t *gs_vertexbuffer_create(struct gs_vb_data *data,
uint32_t flags);
EXPORT gs_indexbuffer_t gs_indexbuffer_create(enum gs_index_type type,
EXPORT gs_indexbuffer_t *gs_indexbuffer_create(enum gs_index_type type,
void *indices, size_t num, uint32_t flags);
EXPORT enum gs_texture_type gs_get_texture_type(gs_texture_t texture);
EXPORT enum gs_texture_type gs_get_texture_type(gs_texture_t *texture);
EXPORT void gs_load_vertexbuffer(gs_vertbuffer_t vertbuffer);
EXPORT void gs_load_indexbuffer(gs_indexbuffer_t indexbuffer);
EXPORT void gs_load_texture(gs_texture_t tex, int unit);
EXPORT void gs_load_samplerstate(gs_samplerstate_t samplerstate, int unit);
EXPORT void gs_load_vertexshader(gs_shader_t vertshader);
EXPORT void gs_load_pixelshader(gs_shader_t pixelshader);
EXPORT void gs_load_vertexbuffer(gs_vertbuffer_t *vertbuffer);
EXPORT void gs_load_indexbuffer(gs_indexbuffer_t *indexbuffer);
EXPORT void gs_load_texture(gs_texture_t *tex, int unit);
EXPORT void gs_load_samplerstate(gs_samplerstate_t *samplerstate, int unit);
EXPORT void gs_load_vertexshader(gs_shader_t *vertshader);
EXPORT void gs_load_pixelshader(gs_shader_t *pixelshader);
EXPORT void gs_load_default_samplerstate(bool b_3d, int unit);
EXPORT gs_shader_t gs_get_vertex_shader(void);
EXPORT gs_shader_t gs_get_pixel_shader(void);
EXPORT gs_shader_t *gs_get_vertex_shader(void);
EXPORT gs_shader_t *gs_get_pixel_shader(void);
EXPORT gs_texture_t gs_get_render_target(void);
EXPORT gs_zstencil_t gs_get_zstencil_target(void);
EXPORT gs_texture_t *gs_get_render_target(void);
EXPORT gs_zstencil_t *gs_get_zstencil_target(void);
EXPORT void gs_set_render_target(gs_texture_t tex, gs_zstencil_t zstencil);
EXPORT void gs_set_cube_render_target(gs_texture_t cubetex, int side,
gs_zstencil_t zstencil);
EXPORT void gs_set_render_target(gs_texture_t *tex, gs_zstencil_t *zstencil);
EXPORT void gs_set_cube_render_target(gs_texture_t *cubetex, int side,
gs_zstencil_t *zstencil);
EXPORT void gs_copy_texture(gs_texture_t dst, gs_texture_t src);
EXPORT void gs_copy_texture(gs_texture_t *dst, gs_texture_t *src);
EXPORT void gs_copy_texture_region(
gs_texture_t dst, uint32_t dst_x, uint32_t dst_y,
gs_texture_t src, uint32_t src_x, uint32_t src_y,
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 gs_stage_texture(gs_stagesurf_t dst, gs_texture_t src);
EXPORT void gs_stage_texture(gs_stagesurf_t *dst, gs_texture_t *src);
EXPORT void gs_begin_scene(void);
EXPORT void gs_draw(enum gs_draw_mode draw_mode, uint32_t start_vert,
@@ -593,7 +594,7 @@ EXPORT void gs_end_scene(void);
#define GS_CLEAR_DEPTH (1<<1)
#define GS_CLEAR_STENCIL (1<<2)
EXPORT void gs_load_swapchain(gs_swapchain_t swapchain);
EXPORT void gs_load_swapchain(gs_swapchain_t *swapchain);
EXPORT void gs_clear(uint32_t clear_flags, struct vec4 *color,
float depth, uint8_t stencil);
EXPORT void gs_present(void);
@@ -630,75 +631,78 @@ EXPORT void gs_frustum(float left, float right, float top, float bottom,
EXPORT void gs_projection_push(void);
EXPORT void gs_projection_pop(void);
EXPORT void gs_swapchain_destroy(gs_swapchain_t swapchain);
EXPORT void gs_swapchain_destroy(gs_swapchain_t *swapchain);
EXPORT void gs_texture_destroy(gs_texture_t tex);
EXPORT uint32_t gs_texture_get_width(gs_texture_t tex);
EXPORT uint32_t gs_texture_get_height(gs_texture_t tex);
EXPORT enum gs_color_format gs_texture_get_color_format(gs_texture_t tex);
EXPORT bool gs_texture_map(gs_texture_t tex, uint8_t **ptr,
EXPORT void gs_texture_destroy(gs_texture_t *tex);
EXPORT uint32_t gs_texture_get_width(gs_texture_t *tex);
EXPORT uint32_t gs_texture_get_height(gs_texture_t *tex);
EXPORT enum gs_color_format gs_texture_get_color_format(gs_texture_t *tex);
EXPORT bool gs_texture_map(gs_texture_t *tex, uint8_t **ptr,
uint32_t *linesize);
EXPORT void gs_texture_unmap(gs_texture_t tex);
EXPORT void gs_texture_unmap(gs_texture_t *tex);
/** special-case function (GL only) - specifies whether the texture is a
* GL_TEXTURE_RECTANGLE type, which doesn't use normalized texture
* coordinates, doesn't support mipmapping, and requires address clamping */
EXPORT bool gs_texture_is_rect(gs_texture_t tex);
EXPORT bool gs_texture_is_rect(gs_texture_t *tex);
/**
* Gets a pointer to the context-specific object associated with the texture.
* For example, for GL, this is a GLuint*. For D3D11, ID3D11Texture2D*.
*/
EXPORT void *gs_texture_get_obj(gs_texture_t tex);
EXPORT void *gs_texture_get_obj(gs_texture_t *tex);
EXPORT void gs_cubetexture_destroy(gs_texture_t cubetex);
EXPORT uint32_t gs_cubetexture_get_size(gs_texture_t cubetex);
EXPORT void gs_cubetexture_destroy(gs_texture_t *cubetex);
EXPORT uint32_t gs_cubetexture_get_size(gs_texture_t *cubetex);
EXPORT enum gs_color_format gs_cubetexture_get_color_format(
gs_texture_t cubetex);
gs_texture_t *cubetex);
EXPORT void gs_voltexture_destroy(gs_texture_t voltex);
EXPORT uint32_t gs_voltexture_get_width(gs_texture_t voltex);
EXPORT uint32_t gs_voltexture_get_height(gs_texture_t voltex);
EXPORT uint32_t gs_voltexture_getdepth(gs_texture_t voltex);
EXPORT enum gs_color_format gs_voltexture_get_color_format(gs_texture_t voltex);
EXPORT void gs_voltexture_destroy(gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_get_width(gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_get_height(gs_texture_t *voltex);
EXPORT uint32_t gs_voltexture_getdepth(gs_texture_t *voltex);
EXPORT enum gs_color_format gs_voltexture_get_color_format(
gs_texture_t *voltex);
EXPORT void gs_stagesurface_destroy(gs_stagesurf_t stagesurf);
EXPORT uint32_t gs_stagesurface_get_width(gs_stagesurf_t stagesurf);
EXPORT uint32_t gs_stagesurface_get_height(gs_stagesurf_t stagesurf);
EXPORT void gs_stagesurface_destroy(gs_stagesurf_t *stagesurf);
EXPORT uint32_t gs_stagesurface_get_width(gs_stagesurf_t *stagesurf);
EXPORT uint32_t gs_stagesurface_get_height(gs_stagesurf_t *stagesurf);
EXPORT enum gs_color_format gs_stagesurface_get_color_format(
gs_stagesurf_t stagesurf);
EXPORT bool gs_stagesurface_map(gs_stagesurf_t stagesurf, uint8_t **data,
gs_stagesurf_t *stagesurf);
EXPORT bool gs_stagesurface_map(gs_stagesurf_t *stagesurf, uint8_t **data,
uint32_t *linesize);
EXPORT void gs_stagesurface_unmap(gs_stagesurf_t stagesurf);
EXPORT void gs_stagesurface_unmap(gs_stagesurf_t *stagesurf);
EXPORT void gs_zstencil_destroy(gs_zstencil_t zstencil);
EXPORT void gs_zstencil_destroy(gs_zstencil_t *zstencil);
EXPORT void gs_samplerstate_destroy(gs_samplerstate_t samplerstate);
EXPORT void gs_samplerstate_destroy(gs_samplerstate_t *samplerstate);
EXPORT void gs_vertexbuffer_destroy(gs_vertbuffer_t vertbuffer);
EXPORT void gs_vertexbuffer_flush(gs_vertbuffer_t vertbuffer);
EXPORT struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t vertbuffer);
EXPORT void gs_vertexbuffer_destroy(gs_vertbuffer_t *vertbuffer);
EXPORT void gs_vertexbuffer_flush(gs_vertbuffer_t *vertbuffer);
EXPORT struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t *vertbuffer);
EXPORT void gs_indexbuffer_destroy(gs_indexbuffer_t indexbuffer);
EXPORT void gs_indexbuffer_flush(gs_indexbuffer_t indexbuffer);
EXPORT void *gs_indexbuffer_get_data(gs_indexbuffer_t indexbuffer);
EXPORT size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t indexbuffer);
EXPORT enum gs_index_type gs_indexbuffer_get_type(gs_indexbuffer_t indexbuffer);
EXPORT void gs_indexbuffer_destroy(gs_indexbuffer_t *indexbuffer);
EXPORT void gs_indexbuffer_flush(gs_indexbuffer_t *indexbuffer);
EXPORT void *gs_indexbuffer_get_data(gs_indexbuffer_t *indexbuffer);
EXPORT size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t *indexbuffer);
EXPORT enum gs_index_type gs_indexbuffer_get_type(
gs_indexbuffer_t *indexbuffer);
#ifdef __APPLE__
/** platform specific function for creating (GL_TEXTURE_RECTANGLE) textures
* from shared surface resources */
EXPORT gs_texture_t gs_texture_create_from_iosurface(void *iosurf);
EXPORT bool gs_texture_rebind_iosurface(gs_texture_t texture, void *iosurf);
EXPORT gs_texture_t *gs_texture_create_from_iosurface(void *iosurf);
EXPORT bool gs_texture_rebind_iosurface(gs_texture_t *texture,
void *iosurf);
#elif _WIN32
EXPORT bool gs_gdi_texture_available(void);
/** creates a windows GDI-lockable texture */
EXPORT gs_texture_t gs_texture_create_gdi(uint32_t width, uint32_t height);
EXPORT gs_texture_t *gs_texture_create_gdi(uint32_t width, uint32_t height);
EXPORT void *gs_texture_get_dc(gs_texture_t gdi_tex);
EXPORT void gs_texture_release_dc(gs_texture_t gdi_tex);
EXPORT void *gs_texture_get_dc(gs_texture_t *gdi_tex);
EXPORT void gs_texture_release_dc(gs_texture_t *gdi_tex);
#endif

4
libobs/graphics/input.h
View File

@@ -143,9 +143,9 @@ extern "C" {
/* wrapped opaque data types */
struct input_subsystem;
typedef struct input_subsystem* input_t;
typedef struct input_subsystem input_t;
EXPORT int input_getbuttonstate(input_t input, uint32_t button);
EXPORT int input_getbuttonstate(input_t *input, uint32_t button);
#ifdef __cplusplus
}

18
libobs/graphics/texture-render.c
View File

@@ -24,8 +24,8 @@
#include "graphics.h"
struct gs_texture_render {
gs_texture_t target, prev_target;
gs_zstencil_t zs, prev_zs;
gs_texture_t *target, *prev_target;
gs_zstencil_t *zs, *prev_zs;
uint32_t cx, cy;
@@ -35,7 +35,7 @@ struct gs_texture_render {
bool rendered;
};
gs_texrender_t gs_texrender_create(enum gs_color_format format,
gs_texrender_t *gs_texrender_create(enum gs_color_format format,
enum gs_zstencil_format zsformat)
{
struct gs_texture_render *texrender;
@@ -46,7 +46,7 @@ gs_texrender_t gs_texrender_create(enum gs_color_format format,
return texrender;
}
void gs_texrender_destroy(gs_texrender_t texrender)
void gs_texrender_destroy(gs_texrender_t *texrender)
{
if (texrender) {
gs_texture_destroy(texrender->target);
@@ -55,7 +55,7 @@ void gs_texrender_destroy(gs_texrender_t texrender)
}
}
static bool texrender_resetbuffer(gs_texrender_t texrender, uint32_t cx,
static bool texrender_resetbuffer(gs_texrender_t *texrender, uint32_t cx,
uint32_t cy)
{
if (!texrender)
@@ -87,7 +87,7 @@ static bool texrender_resetbuffer(gs_texrender_t texrender, uint32_t cx,
return true;
}
bool gs_texrender_begin(gs_texrender_t texrender, uint32_t cx, uint32_t cy)
bool gs_texrender_begin(gs_texrender_t *texrender, uint32_t cx, uint32_t cy)
{
if (!texrender || texrender->rendered)
return false;
@@ -119,7 +119,7 @@ bool gs_texrender_begin(gs_texrender_t texrender, uint32_t cx, uint32_t cy)
return true;
}
void gs_texrender_end(gs_texrender_t texrender)
void gs_texrender_end(gs_texrender_t *texrender)
{
if (!texrender)
return;
@@ -133,13 +133,13 @@ void gs_texrender_end(gs_texrender_t texrender)
texrender->rendered = true;
}
void gs_texrender_reset(gs_texrender_t texrender)
void gs_texrender_reset(gs_texrender_t *texrender)
{
if (texrender)
texrender->rendered = false;
}
gs_texture_t gs_texrender_get_texture(gs_texrender_t texrender)
gs_texture_t *gs_texrender_get_texture(gs_texrender_t *texrender)
{
return texrender ? texrender->target : NULL;
}