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

2
libobs-d3d11/d3d11-indexbuffer.cpp
View File

@@ -37,7 +37,7 @@ void gs_index_buffer::InitBuffer()
throw HRError("Failed to create buffer", hr);
}
gs_index_buffer::gs_index_buffer(gs_device_t device, enum gs_index_type type,
gs_index_buffer::gs_index_buffer(gs_device_t *device, enum gs_index_type type,
void *indices, size_t num, uint32_t flags)
: device (device),
type (type),

2
libobs-d3d11/d3d11-samplerstate.cpp
View File

@@ -59,7 +59,7 @@ static inline D3D11_FILTER ConvertGSFilter( gs_sample_filter filter)
return D3D11_FILTER_MIN_MAG_MIP_POINT;
}
gs_sampler_state::gs_sampler_state(gs_device_t device, gs_sampler_info *info)
gs_sampler_state::gs_sampler_state(gs_device_t *device, gs_sampler_info *info)
: device (device),
info (*info)
{

48
libobs-d3d11/d3d11-shader.cpp
View File

@@ -38,7 +38,7 @@ void gs_vertex_shader::GetBuffersExpected(
}
}
gs_vertex_shader::gs_vertex_shader(gs_device_t device, const char *file,
gs_vertex_shader::gs_vertex_shader(gs_device_t *device, const char *file,
const char *shaderString)
: gs_shader (device, GS_SHADER_VERTEX),
hasNormals (false),
@@ -76,7 +76,7 @@ gs_vertex_shader::gs_vertex_shader(gs_device_t device, const char *file,
world = gs_shader_get_param_by_name(this, "World");
}
gs_pixel_shader::gs_pixel_shader(gs_device_t device, const char *file,
gs_pixel_shader::gs_pixel_shader(gs_device_t *device, const char *file,
const char *shaderString)
: gs_shader(device, GS_SHADER_PIXEL)
{
@@ -216,9 +216,9 @@ inline void gs_shader::UpdateParam(vector<uint8_t> &constData,
upload = true;
param.changed = false;
}
} else if (param.curValue.size() == sizeof(gs_texture_t)) {
gs_texture_t tex;
memcpy(&tex, param.curValue.data(), sizeof(gs_texture_t));
} else if (param.curValue.size() == sizeof(gs_texture_t*)) {
gs_texture_t *tex;
memcpy(&tex, param.curValue.data(), sizeof(gs_texture_t*));
device_load_texture(device, tex, param.textureID);
}
}
@@ -250,22 +250,22 @@ void gs_shader::UploadParams()
}
}
void gs_shader_destroy(gs_shader_t shader)
void gs_shader_destroy(gs_shader_t *shader)
{
delete shader;
}
int gs_shader_get_num_params(gs_shader_t shader)
int gs_shader_get_num_params(gs_shader_t *shader)
{
return (int)shader->params.size();
}
gs_sparam_t gs_shader_get_param_by_idx(gs_shader_t shader, uint32_t param)
gs_sparam_t *gs_shader_get_param_by_idx(gs_shader_t *shader, uint32_t param)
{
return &shader->params[param];
}
gs_sparam_t gs_shader_get_param_by_name(gs_shader_t shader, const char *name)
gs_sparam_t *gs_shader_get_param_by_name(gs_shader_t *shader, const char *name)
{
for (size_t i = 0; i < shader->params.size(); i++) {
gs_shader_param &param = shader->params[i];
@@ -276,7 +276,7 @@ gs_sparam_t gs_shader_get_param_by_name(gs_shader_t shader, const char *name)
return NULL;
}
gs_sparam_t gs_shader_get_viewproj_matrix(gs_shader_t shader)
gs_sparam_t *gs_shader_get_viewproj_matrix(gs_shader_t *shader)
{
if (shader->type != GS_SHADER_VERTEX)
return NULL;
@@ -284,7 +284,7 @@ gs_sparam_t gs_shader_get_viewproj_matrix(gs_shader_t shader)
return static_cast<gs_vertex_shader*>(shader)->viewProj;
}
gs_sparam_t gs_shader_get_world_matrix(gs_shader_t shader)
gs_sparam_t *gs_shader_get_world_matrix(gs_shader_t *shader)
{
if (shader->type != GS_SHADER_VERTEX)
return NULL;
@@ -292,7 +292,7 @@ gs_sparam_t gs_shader_get_world_matrix(gs_shader_t shader)
return static_cast<gs_vertex_shader*>(shader)->world;
}
void gs_shader_get_param_info(gs_sparam_t param,
void gs_shader_get_param_info(gs_sparam_t *param,
struct gs_shader_param_info *info)
{
if (!param)
@@ -319,59 +319,59 @@ static inline void shader_setval_inline(gs_shader_param *param,
}
}
void gs_shader_set_bool(gs_sparam_t param, bool val)
void gs_shader_set_bool(gs_sparam_t *param, bool val)
{
shader_setval_inline(param, &val, sizeof(bool));
}
void gs_shader_set_float(gs_sparam_t param, float val)
void gs_shader_set_float(gs_sparam_t *param, float val)
{
shader_setval_inline(param, &val, sizeof(float));
}
void gs_shader_set_int(gs_sparam_t param, int val)
void gs_shader_set_int(gs_sparam_t *param, int val)
{
shader_setval_inline(param, &val, sizeof(int));
}
void gs_shader_setmatrix3(gs_sparam_t param, const struct matrix3 *val)
void gs_shader_setmatrix3(gs_sparam_t *param, const struct matrix3 *val)
{
struct matrix4 mat;
matrix4_from_matrix3(&mat, val);
shader_setval_inline(param, &mat, sizeof(matrix4));
}
void gs_shader_set_matrix4(gs_sparam_t param, const struct matrix4 *val)
void gs_shader_set_matrix4(gs_sparam_t *param, const struct matrix4 *val)
{
shader_setval_inline(param, val, sizeof(matrix4));
}
void gs_shader_set_vec2(gs_sparam_t param, const struct vec2 *val)
void gs_shader_set_vec2(gs_sparam_t *param, const struct vec2 *val)
{
shader_setval_inline(param, val, sizeof(vec2));
}
void gs_shader_set_vec3(gs_sparam_t param, const struct vec3 *val)
void gs_shader_set_vec3(gs_sparam_t *param, const struct vec3 *val)
{
shader_setval_inline(param, val, sizeof(float) * 3);
}
void gs_shader_set_vec4(gs_sparam_t param, const struct vec4 *val)
void gs_shader_set_vec4(gs_sparam_t *param, const struct vec4 *val)
{
shader_setval_inline(param, val, sizeof(vec4));
}
void gs_shader_set_texture(gs_sparam_t param, gs_texture_t val)
void gs_shader_set_texture(gs_sparam_t *param, gs_texture_t *val)
{
shader_setval_inline(param, &val, sizeof(gs_texture_t));
shader_setval_inline(param, &val, sizeof(gs_texture_t*));
}
void gs_shader_set_val(gs_sparam_t param, const void *val, size_t size)
void gs_shader_set_val(gs_sparam_t *param, const void *val, size_t size)
{
shader_setval_inline(param, val, size);
}
void gs_shader_set_default(gs_sparam_t param)
void gs_shader_set_default(gs_sparam_t *param)
{
if (param->defaultValue.size())
shader_setval_inline(param, param->defaultValue.data(),

2
libobs-d3d11/d3d11-shaderprocessor.cpp
View File

@@ -180,7 +180,7 @@ void ShaderProcessor::BuildParams(vector<gs_shader_param> &params)
AddParam(parser.params.array[i], params, texCounter);
}
static inline void AddSampler(gs_device_t device, shader_sampler &sampler,
static inline void AddSampler(gs_device_t *device, shader_sampler &sampler,
vector<ShaderSampler> &samplers)
{
gs_sampler_info si;

4
libobs-d3d11/d3d11-shaderprocessor.hpp
View File

@@ -25,7 +25,7 @@ struct ShaderParser : shader_parser {
};
struct ShaderProcessor {
gs_device_t device;
gs_device_t *device;
ShaderParser parser;
void BuildInputLayout(vector<D3D11_INPUT_ELEMENT_DESC> &inputs);
@@ -34,7 +34,7 @@ struct ShaderProcessor {
void BuildString(string &outputString);
void Process(const char *shader_string, const char *file);
inline ShaderProcessor(gs_device_t device) : device(device)
inline ShaderProcessor(gs_device_t *device) : device(device)
{
}
};

2
libobs-d3d11/d3d11-stagesurf.cpp
View File

@@ -17,7 +17,7 @@
#include "d3d11-subsystem.hpp"
gs_stage_surface::gs_stage_surface(gs_device_t device, uint32_t width,
gs_stage_surface::gs_stage_surface(gs_device_t *device, uint32_t width,
uint32_t height, gs_color_format colorFormat)
: device (device),
width (width),

221
libobs-d3d11/d3d11-subsystem.cpp
View File

@@ -443,7 +443,7 @@ const char *device_preprocessor_name(void)
return "_D3D11";
}
int device_create(gs_device_t *p_device, gs_init_data *data)
int device_create(gs_device_t **p_device, gs_init_data *data)
{
gs_device *device = NULL;
int errorcode = GS_SUCCESS;
@@ -466,24 +466,24 @@ int device_create(gs_device_t *p_device, gs_init_data *data)
return errorcode;
}
void device_destroy(gs_device_t device)
void device_destroy(gs_device_t *device)
{
delete device;
}
void device_enter_context(gs_device_t device)
void device_enter_context(gs_device_t *device)
{
/* does nothing */
UNUSED_PARAMETER(device);
}
void device_leave_context(gs_device_t device)
void device_leave_context(gs_device_t *device)
{
/* does nothing */
UNUSED_PARAMETER(device);
}
gs_swapchain_t device_swapchain_create(gs_device_t device,
gs_swapchain_t *device_swapchain_create(gs_device_t *device,
struct gs_init_data *data)
{
gs_swap_chain *swap = NULL;
@@ -498,7 +498,7 @@ gs_swapchain_t device_swapchain_create(gs_device_t device,
return swap;
}
void device_resize(gs_device_t device, uint32_t cx, uint32_t cy)
void device_resize(gs_device_t *device, uint32_t cx, uint32_t cy)
{
try {
ID3D11RenderTargetView *renderView = NULL;
@@ -520,23 +520,23 @@ void device_resize(gs_device_t device, uint32_t cx, uint32_t cy)
}
}
void device_get_size(gs_device_t device, uint32_t *cx, uint32_t *cy)
void device_get_size(gs_device_t *device, uint32_t *cx, uint32_t *cy)
{
*cx = device->curSwapChain->target.width;
*cy = device->curSwapChain->target.height;
}
uint32_t device_get_width(gs_device_t device)
uint32_t device_get_width(gs_device_t *device)
{
return device->curSwapChain->target.width;
}
uint32_t device_get_height(gs_device_t device)
uint32_t device_get_height(gs_device_t *device)
{
return device->curSwapChain->target.height;
}
gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
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)
{
@@ -555,7 +555,7 @@ gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
return texture;
}
gs_texture_t device_cubetexture_create(gs_device_t device, uint32_t size,
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)
{
@@ -576,7 +576,7 @@ gs_texture_t device_cubetexture_create(gs_device_t device, uint32_t size,
return texture;
}
gs_texture_t device_voltexture_create(gs_device_t device, uint32_t width,
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)
@@ -593,7 +593,7 @@ gs_texture_t device_voltexture_create(gs_device_t device, uint32_t width,
return NULL;
}
gs_zstencil_t device_zstencil_create(gs_device_t device, uint32_t width,
gs_zstencil_t *device_zstencil_create(gs_device_t *device, uint32_t width,
uint32_t height, enum gs_zstencil_format format)
{
gs_zstencil_buffer *zstencil = NULL;
@@ -608,7 +608,7 @@ gs_zstencil_t device_zstencil_create(gs_device_t device, uint32_t width,
return zstencil;
}
gs_stagesurf_t device_stagesurface_create(gs_device_t device, uint32_t width,
gs_stagesurf_t *device_stagesurface_create(gs_device_t *device, uint32_t width,
uint32_t height, enum gs_color_format color_format)
{
gs_stage_surface *surf = NULL;
@@ -624,7 +624,7 @@ gs_stagesurf_t device_stagesurface_create(gs_device_t device, uint32_t width,
return surf;
}
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_sampler_state *ss = NULL;
@@ -639,7 +639,7 @@ gs_samplerstate_t device_samplerstate_create(gs_device_t device,
return ss;
}
gs_shader_t device_vertexshader_create(gs_device_t device,
gs_shader_t *device_vertexshader_create(gs_device_t *device,
const char *shader_string, const char *file,
char **error_string)
{
@@ -668,7 +668,7 @@ gs_shader_t device_vertexshader_create(gs_device_t device,
return shader;
}
gs_shader_t device_pixelshader_create(gs_device_t device,
gs_shader_t *device_pixelshader_create(gs_device_t *device,
const char *shader_string, const char *file,
char **error_string)
{
@@ -697,7 +697,7 @@ gs_shader_t device_pixelshader_create(gs_device_t device,
return shader;
}
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_vertex_buffer *buffer = NULL;
@@ -715,7 +715,7 @@ gs_vertbuffer_t device_vertexbuffer_create(gs_device_t device,
return buffer;
}
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)
{
@@ -730,12 +730,12 @@ gs_indexbuffer_t device_indexbuffer_create(gs_device_t device,
return buffer;
}
enum gs_texture_type device_get_texture_type(gs_texture_t texture)
enum gs_texture_type device_get_texture_type(gs_texture_t *texture)
{
return texture->type;
}
void device_load_vertexbuffer(gs_device_t device, gs_vertbuffer_t vertbuffer)
void device_load_vertexbuffer(gs_device_t *device, gs_vertbuffer_t *vertbuffer)
{
if (device->curVertexBuffer == vertbuffer)
return;
@@ -764,7 +764,7 @@ void device_load_vertexbuffer(gs_device_t device, gs_vertbuffer_t vertbuffer)
buffers.data(), strides.data(), offsets.data());
}
void device_load_indexbuffer(gs_device_t device, gs_indexbuffer_t indexbuffer)
void device_load_indexbuffer(gs_device_t *device, gs_indexbuffer_t *indexbuffer)
{
DXGI_FORMAT format;
ID3D11Buffer *buffer;
@@ -789,7 +789,7 @@ void device_load_indexbuffer(gs_device_t device, gs_indexbuffer_t indexbuffer)
device->context->IASetIndexBuffer(buffer, format, 0);
}
void device_load_texture(gs_device_t device, gs_texture_t tex, int unit)
void device_load_texture(gs_device_t *device, gs_texture_t *tex, int unit)
{
ID3D11ShaderResourceView *view = NULL;
@@ -803,8 +803,8 @@ void device_load_texture(gs_device_t device, gs_texture_t tex, int unit)
device->context->PSSetShaderResources(unit, 1, &view);
}
void device_load_samplerstate(gs_device_t device,
gs_samplerstate_t samplerstate, int unit)
void device_load_samplerstate(gs_device_t *device,
gs_samplerstate_t *samplerstate, int unit)
{
ID3D11SamplerState *state = NULL;
@@ -818,7 +818,7 @@ void device_load_samplerstate(gs_device_t device,
device->context->PSSetSamplers(unit, 1, &state);
}
void device_load_vertexshader(gs_device_t device, gs_shader_t vertshader)
void device_load_vertexshader(gs_device_t *device, gs_shader_t *vertshader)
{
ID3D11VertexShader *shader = NULL;
ID3D11InputLayout *layout = NULL;
@@ -855,7 +855,7 @@ void device_load_vertexshader(gs_device_t device, gs_shader_t vertshader)
device_load_vertexbuffer(device, curVB);
}
static inline void clear_textures(gs_device_t device)
static inline void clear_textures(gs_device_t *device)
{
ID3D11ShaderResourceView *views[GS_MAX_TEXTURES];
memset(views, 0, sizeof(views));
@@ -863,7 +863,7 @@ static inline void clear_textures(gs_device_t device)
device->context->PSSetShaderResources(0, GS_MAX_TEXTURES, views);
}
void device_load_pixelshader(gs_device_t device, gs_shader_t pixelshader)
void device_load_pixelshader(gs_device_t *device, gs_shader_t *pixelshader)
{
ID3D11PixelShader *shader = NULL;
ID3D11Buffer *constants = NULL;
@@ -902,7 +902,7 @@ void device_load_pixelshader(gs_device_t device, gs_shader_t pixelshader)
device->curSamplers[i] = nullptr;
}
void device_load_default_samplerstate(gs_device_t device, bool b_3d, int unit)
void device_load_default_samplerstate(gs_device_t *device, bool b_3d, int unit)
{
/* TODO */
UNUSED_PARAMETER(device);
@@ -910,17 +910,17 @@ void device_load_default_samplerstate(gs_device_t device, bool b_3d, int unit)
UNUSED_PARAMETER(unit);
}
gs_shader_t device_get_vertex_shader(gs_device_t device)
gs_shader_t *device_get_vertex_shader(gs_device_t *device)
{
return device->curVertexShader;
}
gs_shader_t device_get_pixel_shader(gs_device_t device)
gs_shader_t *device_get_pixel_shader(gs_device_t *device)
{
return device->curPixelShader;
}
gs_texture_t device_get_render_target(gs_device_t device)
gs_texture_t *device_get_render_target(gs_device_t *device)
{
if (device->curRenderTarget == &device->curSwapChain->target)
return NULL;
@@ -928,7 +928,7 @@ gs_texture_t device_get_render_target(gs_device_t device)
return device->curRenderTarget;
}
gs_zstencil_t device_get_zstencil_target(gs_device_t device)
gs_zstencil_t *device_get_zstencil_target(gs_device_t *device)
{
if (device->curZStencilBuffer == &device->curSwapChain->zs)
return NULL;
@@ -936,8 +936,8 @@ gs_zstencil_t device_get_zstencil_target(gs_device_t device)
return device->curZStencilBuffer;
}
void device_set_render_target(gs_device_t device, gs_texture_t tex,
gs_zstencil_t zstencil)
void device_set_render_target(gs_device_t *device, gs_texture_t *tex,
gs_zstencil_t *zstencil)
{
if (!tex)
tex = &device->curSwapChain->target;
@@ -969,8 +969,8 @@ void device_set_render_target(gs_device_t device, gs_texture_t tex,
device->context->OMSetRenderTargets(1, &rt, zstencil->view);
}
void device_set_cube_render_target(gs_device_t device, gs_texture_t tex,
int side, gs_zstencil_t zstencil)
void device_set_cube_render_target(gs_device_t *device, gs_texture_t *tex,
int side, gs_zstencil_t *zstencil)
{
if (!tex) {
tex = &device->curSwapChain->target;
@@ -1008,7 +1008,7 @@ void device_set_cube_render_target(gs_device_t device, gs_texture_t tex,
inline void gs_device::CopyTex(ID3D11Texture2D *dst,
uint32_t dst_x, uint32_t dst_y,
gs_texture_t src, uint32_t src_x, uint32_t src_y,
gs_texture_t *src, uint32_t src_x, uint32_t src_y,
uint32_t src_w, uint32_t src_h)
{
if (src->type != GS_TEXTURE_2D)
@@ -1043,9 +1043,9 @@ inline void gs_device::CopyTex(ID3D11Texture2D *dst,
}
}
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,
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)
{
try {
@@ -1092,13 +1092,14 @@ void device_copy_texture_region(gs_device_t device,
}
}
void device_copy_texture(gs_device_t device, gs_texture_t dst, gs_texture_t src)
void device_copy_texture(gs_device_t *device, gs_texture_t *dst,
gs_texture_t *src)
{
device_copy_texture_region(device, dst, 0, 0, src, 0, 0, 0, 0);
}
void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
gs_texture_t src)
void device_stage_texture(gs_device_t *device, gs_stagesurf_t *dst,
gs_texture_t *src)
{
try {
gs_texture_2d *src2d = static_cast<gs_texture_2d*>(src);
@@ -1123,12 +1124,12 @@ void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
}
}
void device_begin_scene(gs_device_t device)
void device_begin_scene(gs_device_t *device)
{
clear_textures(device);
}
void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
void device_draw(gs_device_t *device, enum gs_draw_mode draw_mode,
uint32_t start_vert, uint32_t num_verts)
{
try {
@@ -1141,7 +1142,7 @@ void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
if (!device->curVertexBuffer)
throw "No vertex buffer specified";
gs_effect_t effect = gs_get_effect();
gs_effect_t *effect = gs_get_effect();
if (effect)
gs_effect_update_params(effect);
@@ -1179,16 +1180,16 @@ void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
}
}
void device_end_scene(gs_device_t device)
void device_end_scene(gs_device_t *device)
{
/* does nothing in D3D11 */
UNUSED_PARAMETER(device);
}
void device_load_swapchain(gs_device_t device, gs_swapchain_t swapchain)
void device_load_swapchain(gs_device_t *device, gs_swapchain_t *swapchain)
{
gs_texture_t target = device->curRenderTarget;
gs_zstencil_t zs = device->curZStencilBuffer;
gs_texture_t *target = device->curRenderTarget;
gs_zstencil_t *zs = device->curZStencilBuffer;
bool is_cube = device->curRenderTarget->type == GS_TEXTURE_CUBE;
if (target == &device->curSwapChain->target)
@@ -1208,7 +1209,7 @@ void device_load_swapchain(gs_device_t device, gs_swapchain_t swapchain)
device_set_render_target(device, target, zs);
}
void device_clear(gs_device_t device, uint32_t clear_flags, struct vec4 *color,
void device_clear(gs_device_t *device, uint32_t clear_flags, struct vec4 *color,
float depth, uint8_t stencil)
{
int side = device->curRenderSide;
@@ -1231,17 +1232,17 @@ void device_clear(gs_device_t device, uint32_t clear_flags, struct vec4 *color,
}
}
void device_present(gs_device_t device)
void device_present(gs_device_t *device)
{
device->curSwapChain->swap->Present(0, 0);
}
void device_flush(gs_device_t device)
void device_flush(gs_device_t *device)
{
device->context->Flush();
}
void device_set_cull_mode(gs_device_t device, enum gs_cull_mode mode)
void device_set_cull_mode(gs_device_t *device, enum gs_cull_mode mode)
{
if (mode == device->rasterState.cullMode)
return;
@@ -1250,12 +1251,12 @@ void device_set_cull_mode(gs_device_t device, enum gs_cull_mode mode)
device->rasterStateChanged = true;
}
enum gs_cull_mode device_get_cull_mode(gs_device_t device)
enum gs_cull_mode device_get_cull_mode(gs_device_t *device)
{
return device->rasterState.cullMode;
}
void device_enable_blending(gs_device_t device, bool enable)
void device_enable_blending(gs_device_t *device, bool enable)
{
if (enable == device->blendState.blendEnabled)
return;
@@ -1264,7 +1265,7 @@ void device_enable_blending(gs_device_t device, bool enable)
device->blendStateChanged = true;
}
void device_enable_depth_test(gs_device_t device, bool enable)
void device_enable_depth_test(gs_device_t *device, bool enable)
{
if (enable == device->zstencilState.depthEnabled)
return;
@@ -1273,7 +1274,7 @@ void device_enable_depth_test(gs_device_t device, bool enable)
device->zstencilStateChanged = true;
}
void device_enable_stencil_test(gs_device_t device, bool enable)
void device_enable_stencil_test(gs_device_t *device, bool enable)
{
if (enable == device->zstencilState.stencilEnabled)
return;
@@ -1282,7 +1283,7 @@ void device_enable_stencil_test(gs_device_t device, bool enable)
device->zstencilStateChanged = true;
}
void device_enable_stencil_write(gs_device_t device, bool enable)
void device_enable_stencil_write(gs_device_t *device, bool enable)
{
if (enable == device->zstencilState.stencilWriteEnabled)
return;
@@ -1291,7 +1292,7 @@ void device_enable_stencil_write(gs_device_t device, bool enable)
device->zstencilStateChanged = true;
}
void device_enable_color(gs_device_t device, bool red, bool green,
void device_enable_color(gs_device_t *device, bool red, bool green,
bool blue, bool alpha)
{
if (device->blendState.redEnabled == red &&
@@ -1307,7 +1308,7 @@ void device_enable_color(gs_device_t device, bool red, bool green,
device->blendStateChanged = true;
}
void device_blend_function(gs_device_t device, enum gs_blend_type src,
void device_blend_function(gs_device_t *device, enum gs_blend_type src,
enum gs_blend_type dest)
{
if (device->blendState.srcFactor == src &&
@@ -1319,7 +1320,7 @@ void device_blend_function(gs_device_t device, enum gs_blend_type src,
device->blendStateChanged = true;
}
void device_depth_function(gs_device_t device, enum gs_depth_test test)
void device_depth_function(gs_device_t *device, enum gs_depth_test test)
{
if (device->zstencilState.depthFunc == test)
return;
@@ -1328,8 +1329,8 @@ void device_depth_function(gs_device_t device, enum gs_depth_test test)
device->zstencilStateChanged = true;
}
static inline void update_stencilside_test(gs_device_t device, StencilSide &side,
gs_depth_test test)
static inline void update_stencilside_test(gs_device_t *device,
StencilSide &side, gs_depth_test test)
{
if (side.test == test)
return;
@@ -1338,7 +1339,7 @@ static inline void update_stencilside_test(gs_device_t device, StencilSide &side
device->zstencilStateChanged = true;
}
void device_stencil_function(gs_device_t device, enum gs_stencil_side side,
void device_stencil_function(gs_device_t *device, enum gs_stencil_side side,
enum gs_depth_test test)
{
int sideVal = (int)side;
@@ -1351,7 +1352,7 @@ void device_stencil_function(gs_device_t device, enum gs_stencil_side side,
device->zstencilState.stencilBack, test);
}
static inline void update_stencilside_op(gs_device_t device, StencilSide &side,
static inline void update_stencilside_op(gs_device_t *device, StencilSide &side,
enum gs_stencil_op_type fail, enum gs_stencil_op_type zfail,
enum gs_stencil_op_type zpass)
{
@@ -1364,7 +1365,7 @@ static inline void update_stencilside_op(gs_device_t device, StencilSide &side,
device->zstencilStateChanged = true;
}
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)
{
@@ -1380,7 +1381,7 @@ void device_stencil_op(gs_device_t device, enum gs_stencil_side side,
fail, zfail, zpass);
}
void device_set_viewport(gs_device_t device, int x, int y, int width,
void device_set_viewport(gs_device_t *device, int x, int y, int width,
int height)
{
D3D11_VIEWPORT vp;
@@ -1398,12 +1399,12 @@ void device_set_viewport(gs_device_t device, int x, int y, int width,
device->viewport.cy = height;
}
void device_get_viewport(gs_device_t device, struct gs_rect *rect)
void device_get_viewport(gs_device_t *device, struct gs_rect *rect)
{
memcpy(rect, &device->viewport, sizeof(gs_rect));
}
void device_set_scissor_rect(gs_device_t device, struct gs_rect *rect)
void device_set_scissor_rect(gs_device_t *device, struct gs_rect *rect)
{
D3D11_RECT d3drect;
@@ -1420,7 +1421,7 @@ void device_set_scissor_rect(gs_device_t device, struct gs_rect *rect)
device->rasterStateChanged = true;
}
void device_ortho(gs_device_t device, float left, float right, float top,
void device_ortho(gs_device_t *device, float left, float right, float top,
float bottom, float zNear, float zFar)
{
matrix4 *dst = &device->curProjMatrix;
@@ -1446,7 +1447,7 @@ void device_ortho(gs_device_t device, float left, float right, float top,
dst->t.w = 1.0f;
}
void device_frustum(gs_device_t device, float left, float right, float top,
void device_frustum(gs_device_t *device, float left, float right, float top,
float bottom, float zNear, float zFar)
{
matrix4 *dst = &device->curProjMatrix;
@@ -1473,14 +1474,14 @@ void device_frustum(gs_device_t device, float left, float right, float top,
dst->z.w = 1.0f;
}
void device_projection_push(gs_device_t device)
void device_projection_push(gs_device_t *device)
{
mat4float mat;
memcpy(&mat, &device->curProjMatrix, sizeof(matrix4));
device->projStack.push_back(mat);
}
void device_projection_pop(gs_device_t device)
void device_projection_pop(gs_device_t *device)
{
if (!device->projStack.size())
return;
@@ -1493,7 +1494,7 @@ void device_projection_pop(gs_device_t device)
device->projStack.pop_back();
}
void gs_swapchain_destroy(gs_swapchain_t swapchain)
void gs_swapchain_destroy(gs_swapchain_t *swapchain)
{
if (!swapchain)
return;
@@ -1505,12 +1506,12 @@ void gs_swapchain_destroy(gs_swapchain_t swapchain)
delete swapchain;
}
void gs_texture_destroy(gs_texture_t tex)
void gs_texture_destroy(gs_texture_t *tex)
{
delete tex;
}
uint32_t gs_texture_get_width(gs_texture_t tex)
uint32_t gs_texture_get_width(gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return 0;
@@ -1518,7 +1519,7 @@ uint32_t gs_texture_get_width(gs_texture_t tex)
return static_cast<gs_texture_2d*>(tex)->width;
}
uint32_t gs_texture_get_height(gs_texture_t tex)
uint32_t gs_texture_get_height(gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return 0;
@@ -1526,7 +1527,7 @@ uint32_t gs_texture_get_height(gs_texture_t tex)
return static_cast<gs_texture_2d*>(tex)->height;
}
enum gs_color_format gs_texture_get_color_format(gs_texture_t tex)
enum gs_color_format gs_texture_get_color_format(gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return GS_UNKNOWN;
@@ -1534,7 +1535,7 @@ enum gs_color_format gs_texture_get_color_format(gs_texture_t tex)
return static_cast<gs_texture_2d*>(tex)->format;
}
bool gs_texture_map(gs_texture_t tex, uint8_t **ptr, uint32_t *linesize)
bool gs_texture_map(gs_texture_t *tex, uint8_t **ptr, uint32_t *linesize)
{
HRESULT hr;
@@ -1554,7 +1555,7 @@ bool gs_texture_map(gs_texture_t tex, uint8_t **ptr, uint32_t *linesize)
return true;
}
void gs_texture_unmap(gs_texture_t tex)
void gs_texture_unmap(gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return;
@@ -1563,7 +1564,7 @@ void gs_texture_unmap(gs_texture_t tex)
tex2d->device->context->Unmap(tex2d->texture, 0);
}
void *gs_texture_get_obj(gs_texture_t tex)
void *gs_texture_get_obj(gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return nullptr;
@@ -1573,12 +1574,12 @@ void *gs_texture_get_obj(gs_texture_t tex)
}
void gs_cubetexture_destroy(gs_texture_t cubetex)
void gs_cubetexture_destroy(gs_texture_t *cubetex)
{
delete cubetex;
}
uint32_t gs_cubetexture_get_size(gs_texture_t cubetex)
uint32_t gs_cubetexture_get_size(gs_texture_t *cubetex)
{
if (cubetex->type != GS_TEXTURE_CUBE)
return 0;
@@ -1587,7 +1588,7 @@ uint32_t gs_cubetexture_get_size(gs_texture_t cubetex)
return tex->width;
}
enum gs_color_format gs_cubetexture_get_color_format(gs_texture_t cubetex)
enum gs_color_format gs_cubetexture_get_color_format(gs_texture_t *cubetex)
{
if (cubetex->type != GS_TEXTURE_CUBE)
return GS_UNKNOWN;
@@ -1597,33 +1598,33 @@ enum gs_color_format gs_cubetexture_get_color_format(gs_texture_t cubetex)
}
void gs_voltexture_destroy(gs_texture_t voltex)
void gs_voltexture_destroy(gs_texture_t *voltex)
{
delete voltex;
}
uint32_t gs_voltexture_get_width(gs_texture_t voltex)
uint32_t gs_voltexture_get_width(gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
uint32_t gs_voltexture_get_height(gs_texture_t voltex)
uint32_t gs_voltexture_get_height(gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
uint32_t gs_voltexture_getdepth(gs_texture_t voltex)
uint32_t gs_voltexture_getdepth(gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
return 0;
}
enum gs_color_format gs_voltexture_get_color_format(gs_texture_t voltex)
enum gs_color_format gs_voltexture_get_color_format(gs_texture_t *voltex)
{
/* TODO */
UNUSED_PARAMETER(voltex);
@@ -1631,27 +1632,27 @@ enum gs_color_format gs_voltexture_get_color_format(gs_texture_t voltex)
}
void gs_stagesurface_destroy(gs_stagesurf_t stagesurf)
void gs_stagesurface_destroy(gs_stagesurf_t *stagesurf)
{
delete stagesurf;
}
uint32_t gs_stagesurface_get_width(gs_stagesurf_t stagesurf)
uint32_t gs_stagesurface_get_width(gs_stagesurf_t *stagesurf)
{
return stagesurf->width;
}
uint32_t gs_stagesurface_get_height(gs_stagesurf_t stagesurf)
uint32_t gs_stagesurface_get_height(gs_stagesurf_t *stagesurf)
{
return stagesurf->height;
}
enum gs_color_format gs_stagesurface_get_color_format(gs_stagesurf_t stagesurf)
enum gs_color_format gs_stagesurface_get_color_format(gs_stagesurf_t *stagesurf)
{
return stagesurf->format;
}
bool gs_stagesurface_map(gs_stagesurf_t stagesurf, uint8_t **data,
bool gs_stagesurface_map(gs_stagesurf_t *stagesurf, uint8_t **data,
uint32_t *linesize)
{
D3D11_MAPPED_SUBRESOURCE map;
@@ -1664,19 +1665,19 @@ bool gs_stagesurface_map(gs_stagesurf_t stagesurf, uint8_t **data,
return true;
}
void gs_stagesurface_unmap(gs_stagesurf_t stagesurf)
void gs_stagesurface_unmap(gs_stagesurf_t *stagesurf)
{
stagesurf->device->context->Unmap(stagesurf->texture, 0);
}
void gs_zstencil_destroy(gs_zstencil_t zstencil)
void gs_zstencil_destroy(gs_zstencil_t *zstencil)
{
delete zstencil;
}
void gs_samplerstate_destroy(gs_samplerstate_t samplerstate)
void gs_samplerstate_destroy(gs_samplerstate_t *samplerstate)
{
if (!samplerstate)
return;
@@ -1691,12 +1692,12 @@ void gs_samplerstate_destroy(gs_samplerstate_t samplerstate)
}
void gs_vertexbuffer_destroy(gs_vertbuffer_t vertbuffer)
void gs_vertexbuffer_destroy(gs_vertbuffer_t *vertbuffer)
{
delete vertbuffer;
}
void gs_vertexbuffer_flush(gs_vertbuffer_t vertbuffer)
void gs_vertexbuffer_flush(gs_vertbuffer_t *vertbuffer)
{
if (!vertbuffer->dynamic) {
blog(LOG_ERROR, "gs_vertexbuffer_flush: vertex buffer is "
@@ -1726,18 +1727,18 @@ void gs_vertexbuffer_flush(gs_vertbuffer_t vertbuffer)
}
}
struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t vertbuffer)
struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t *vertbuffer)
{
return vertbuffer->vbd.data;
}
void gs_indexbuffer_destroy(gs_indexbuffer_t indexbuffer)
void gs_indexbuffer_destroy(gs_indexbuffer_t *indexbuffer)
{
delete indexbuffer;
}
void gs_indexbuffer_flush(gs_indexbuffer_t indexbuffer)
void gs_indexbuffer_flush(gs_indexbuffer_t *indexbuffer)
{
HRESULT hr;
@@ -1756,17 +1757,17 @@ void gs_indexbuffer_flush(gs_indexbuffer_t indexbuffer)
indexbuffer->device->context->Unmap(indexbuffer->indexBuffer, 0);
}
void *gs_indexbuffer_get_data(gs_indexbuffer_t indexbuffer)
void *gs_indexbuffer_get_data(gs_indexbuffer_t *indexbuffer)
{
return indexbuffer->indices.data;
}
size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t indexbuffer)
size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t *indexbuffer)
{
return indexbuffer->num;
}
enum gs_index_type gs_indexbuffer_get_type(gs_indexbuffer_t indexbuffer)
enum gs_index_type gs_indexbuffer_get_type(gs_indexbuffer_t *indexbuffer)
{
return indexbuffer->type;
}
@@ -1776,7 +1777,7 @@ extern "C" EXPORT bool device_gdi_texture_available(void)
return true;
}
extern "C" EXPORT gs_texture_t device_texture_create_gdi(gs_device_t device,
extern "C" EXPORT gs_texture_t *device_texture_create_gdi(gs_device_t *device,
uint32_t width, uint32_t height)
{
gs_texture *texture = nullptr;
@@ -1805,7 +1806,7 @@ static inline bool TextureGDICompatible(gs_texture_2d *tex2d, const char *func)
return true;
}
extern "C" EXPORT void *gs_texture_get_dc(gs_texture_t tex)
extern "C" EXPORT void *gs_texture_get_dc(gs_texture_t *tex)
{
HDC hDC = nullptr;
@@ -1820,7 +1821,7 @@ extern "C" EXPORT void *gs_texture_get_dc(gs_texture_t tex)
return hDC;
}
extern "C" EXPORT void gs_texture_release_dc(gs_texture_t tex)
extern "C" EXPORT void gs_texture_release_dc(gs_texture_t *tex)
{
if (tex->type != GS_TEXTURE_2D)
return;

35
libobs-d3d11/d3d11-subsystem.hpp
View File

@@ -182,7 +182,7 @@ struct gs_vertex_buffer {
ComPtr<ID3D11Buffer> tangentBuffer;
vector<ComPtr<ID3D11Buffer>> uvBuffers;
gs_device_t device;
gs_device_t *device;
bool dynamic;
VBDataPtr vbd;
size_t numVerts;
@@ -199,7 +199,7 @@ struct gs_vertex_buffer {
const size_t numVerts, void *array,
ID3D11Buffer **buffer);
gs_vertex_buffer(gs_device_t device, struct gs_vb_data *data,
gs_vertex_buffer(gs_device_t *device, struct gs_vb_data *data,
uint32_t flags);
};
@@ -213,7 +213,7 @@ struct DataPtr {
struct gs_index_buffer {
ComPtr<ID3D11Buffer> indexBuffer;
gs_device_t device;
gs_device_t *device;
bool dynamic;
gs_index_type type;
size_t indexSize;
@@ -222,7 +222,7 @@ struct gs_index_buffer {
void InitBuffer();
gs_index_buffer(gs_device_t device, enum gs_index_type type,
gs_index_buffer(gs_device_t *device, enum gs_index_type type,
void *indices, size_t num, uint32_t flags);
};
@@ -279,7 +279,7 @@ struct gs_texture_2d : gs_texture {
{
}
gs_texture_2d(gs_device_t device, uint32_t width, uint32_t height,
gs_texture_2d(gs_device_t *device, uint32_t width, uint32_t height,
gs_color_format colorFormat, uint32_t levels,
const uint8_t **data, uint32_t flags,
gs_texture_type type, bool gdiCompatible, bool shared);
@@ -304,7 +304,7 @@ struct gs_zstencil_buffer {
{
}
gs_zstencil_buffer(gs_device_t device, uint32_t width, uint32_t height,
gs_zstencil_buffer(gs_device_t *device, uint32_t width, uint32_t height,
gs_zstencil_format format);
};
@@ -316,16 +316,16 @@ struct gs_stage_surface {
gs_color_format format;
DXGI_FORMAT dxgiFormat;
gs_stage_surface(gs_device_t device, uint32_t width, uint32_t height,
gs_stage_surface(gs_device_t *device, uint32_t width, uint32_t height,
gs_color_format colorFormat);
};
struct gs_sampler_state {
ComPtr<ID3D11SamplerState> state;
gs_device_t device;
gs_device_t *device;
gs_sampler_info info;
gs_sampler_state(gs_device_t device, gs_sampler_info *info);
gs_sampler_state(gs_device_t *device, gs_sampler_info *info);
};
struct gs_shader_param {
@@ -357,7 +357,7 @@ struct ShaderError {
};
struct gs_shader {
gs_device_t device;
gs_device_t *device;
gs_shader_type type;
vector<gs_shader_param> params;
ComPtr<ID3D11Buffer> constants;
@@ -371,7 +371,7 @@ struct gs_shader {
void Compile(const char *shaderStr, const char *file,
const char *target, ID3D10Blob **shader);
inline gs_shader(gs_device_t device, gs_shader_type type)
inline gs_shader(gs_device_t *device, gs_shader_type type)
: device (device),
type (type),
constantSize (0)
@@ -385,7 +385,7 @@ struct ShaderSampler {
string name;
gs_sampler_state sampler;
inline ShaderSampler(const char *name, gs_device_t device,
inline ShaderSampler(const char *name, gs_device_t *device,
gs_sampler_info *info)
: name (name),
sampler (device, info)
@@ -416,7 +416,7 @@ struct gs_vertex_shader : gs_shader {
void GetBuffersExpected(const vector<D3D11_INPUT_ELEMENT_DESC> &inputs);
gs_vertex_shader(gs_device_t device, const char *file,
gs_vertex_shader(gs_device_t *device, const char *file,
const char *shaderString);
};
@@ -433,7 +433,7 @@ struct gs_pixel_shader : gs_shader {
states[i] = NULL;
}
gs_pixel_shader(gs_device_t device, const char *file,
gs_pixel_shader(gs_device_t *device, const char *file,
const char *shaderString);
};
@@ -623,9 +623,10 @@ struct gs_device {
void UpdateRasterState();
void UpdateBlendState();
inline void CopyTex(ID3D11Texture2D *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);
inline void CopyTex(ID3D11Texture2D *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 UpdateViewProjMatrix();

4
libobs-d3d11/d3d11-texture2d.cpp
View File

@@ -141,8 +141,8 @@ void gs_texture_2d::InitRenderTargets()
}
}
gs_texture_2d::gs_texture_2d(gs_device_t device, uint32_t width, uint32_t height,
gs_color_format colorFormat, uint32_t levels,
gs_texture_2d::gs_texture_2d(gs_device_t *device, uint32_t width,
uint32_t height, gs_color_format colorFormat, uint32_t levels,
const uint8_t **data, uint32_t flags, gs_texture_type type,
bool gdiCompatible, bool shared)
: gs_texture (device, type, levels, colorFormat),

2
libobs-d3d11/d3d11-vertexbuffer.cpp
View File

@@ -93,7 +93,7 @@ inline void gs_vertex_buffer::InitBuffer(const size_t elementSize,
throw HRError("Failed to create buffer", hr);
}
gs_vertex_buffer::gs_vertex_buffer(gs_device_t device, struct gs_vb_data *data,
gs_vertex_buffer::gs_vertex_buffer(gs_device_t *device, struct gs_vb_data *data,
uint32_t flags)
: device (device),
vbd (data),

2
libobs-d3d11/d3d11-zstencilbuffer.cpp
View File

@@ -47,7 +47,7 @@ void gs_zstencil_buffer::InitBuffer()
throw HRError("Failed to create depth stencil view", hr);
}
gs_zstencil_buffer::gs_zstencil_buffer(gs_device_t device,
gs_zstencil_buffer::gs_zstencil_buffer(gs_device_t *device,
uint32_t width, uint32_t height,
gs_zstencil_format format)
: device (device),